Development Note Letting the ToDo / ToDoList class visible in the header is clumsy. More...

Namespaces
	ai

	arm

	ast

	bpred

	branch

	cache

	cat

	ccg

	cfgio

	clp

	concept

	cpp

	dcache

	dfa

	display

	dynbranch

	etime

	gliss

	graph

	hard

	icache

	icat3

	ilp

	ip

	ipet

	ograph

	oslice

	ot

	p

	ppc

	proc

	s12x

	script

	se

	sem

	sim

	stack

	trivial

	tsim

	view

Classes
struct	__type

struct	__type< bool >

struct	__type< char >

struct	__type< double >

struct	__type< elm::CString >

struct	__type< elm::String >

struct	__type< float >

struct	__type< int >

struct	__type< long >

struct	__type< long double >

struct	__type< long long >

struct	__type< short >

struct	__type< signed char >

struct	__type< unsigned char >

struct	__type< unsigned int >

struct	__type< unsigned long >

struct	__type< unsigned long long >

struct	__type< unsigned short >

struct	__type< void >

class	AbsAddress

class	AbsoluteAddress

class	AbstractAccessor

class	AbstractCFGBuilder

class	AbstractFeature

class	AbstractIdentifier

class	AbstractMaker

class	AbstractRegistration

class	AccessedAddress

class	AccessedAddresses

class	AccessedAddressFromStack

class	Accessor

class	ACSBuilder

class	ACSMayBuilder

class	Address

struct	address_stat_t

class	AddressOption

class	AlternativeProcessor

class	AmbiguousBoundException

class	Application

class	BACK_EDGES

class	BackIter

class	BackwardCFGAdapter

class	Bag

class	BaseBundle

class	BaseType

class	BasicBlock

class	BasicGraphBBTime
	This property is used to pass the microprocessor description to the code processor. More...

class	BBCleaner

class	BBDeletor

class	BBProcessor

class	BBRatioDisplayer

class	BBRemover

class	BBStatCollector

class	BitSetManager

class	Block

class	BranchProblem

class	Bundle

class	BundleInstIter

class	CachePenalty

class	CAT2Builder

class	CAT2ConstraintBuilder

class	CAT2NCBuilder

class	CAT2OnlyConstraintBuilder

class	CEClass

class	CFG

class	CFGApplication

class	CFGBuilder

class	CFGChecker

class	CFGCheckSummer

class	CFGCollection

class	CFGCollector

class	CFGInfo

class	CFGMaker

class	CFGNormalizer

class	CFGProcessor

class	CFGSaver

class	CFGTransformer

class	CompositeCFG

class	ConcurrentCFGProcessor

class	Condition

class	ConditionalRestructurer

class	ConfigIter

class	Conflict

class	ConflictOfPath

class	ContextPath

class	ContextTree

class	ContextTreeBuilder

class	ContextTreeByCFGBuilder

class	ContextualList

class	ContextualLoopBound

class	ContextualPath

class	ContextualProcessor

class	ContextualProperty

class	ContextualStep

class	DeadCodeAnalysis

class	DecodingException

struct	default_handler_t

class	DelayedBuilder

class	DelayedInfo

class	DelayedMaker

class	DeletableProperty

class	Dominance

class	DomInfo

class	DuplicateIdentifierException

class	DynFeature

class	DynIdentifier

class	DynProcessor

class	Edge

class	EdgeACSBuilder

class	EdgeCAT2Builder

class	EdgeCAT2ConstraintBuilder

class	EdgeInfoOfConflict

class	EdgeProcessor

class	ENTRY_EDGES

class	EntryIter

class	Event

class	Exception

class	EXIT_EDGES

class	ExpNode

class	Feature

class	FeatureDependency

class	FeatureIter

class	FeatureNotFound

class	FeatureRequirer

class	FeatureUsage

class	File

class	FirstLastBuilder

class	FixedTextDecoder

class	FlowFactLoader

class	ForwardCFGAdapter

class	FunAccessor

class	FunProcessor

class	GenericProperty

class	Give

class	GraphBBTime

class	Identifier

class	ImmutableRef

class	Inst

class	LabelAddress

class	LBlockManager

class	Level

class	LinkedBlocksDetector

class	ListOfEdgeConflict

class	ListOfEndConflict

class	ListOfLoopConflict

class	Loader

class	LoadException

class	LockedProperty

class	LogOption

class	Loop

class	LoopIter

class	LoopManager

class	LoopOfConflict

class	LoopReductor

class	LoopUnroller

class	Maker

class	Manager

class	MAYBranch

class	MAYProblem

class	MemArea

class	MemBlockMap

class	Monitor

class	MUSTBranch

class	MUSTPERS

class	MUSTProblem

class	NodeLatency

class	NoMemFU

class	NOP

class	NoProcessor

class	NoProcessorException

class	NoType

class	NullProcessor

class	NullStream

struct	object_init

class	OutOfSegmentException

class	ParExeEdge

class	ParExeException

class	ParExeGraph

class	ParExeInst

class	ParExeNode

class	ParExePipeline

class	ParExeProc

class	ParExeQueue

class	ParExeSequence

class	ParExeStage

class	PathContext

class	PCG

class	PCGBlock

class	PCGBuilder

class	PCGEdge

class	PERSBranch

class	PERSProblem

class	PhonyBlock

class	PostDominance

class	PostDomInfo

class	Process

class	ProcessException

class	Processor

class	ProcessorException

class	ProcessorNotFound

class	ProcessorPlugin

class	ProgItem

class	Progress

class	Property

class	PropList

class	PSTBuilder

class	QueueResource

class	Ref

class	Registry

class	RegIter

class	RegResource

class	Requirement

class	Resource

class	ResourceList

struct	scalar_init

class	Segment

class	SESERegion

class	SimState

class	SPAddress

class	StackAnalysis

class	StageResource

class	StandardEventBuilder

class	StartResource

class	StatCollector

class	StatInfo

class	SubCFGBuilder

class	SymAddress

class	Symbol

class	SynthBlock

class	Test

class	TextDecoder

class	TimingContext

class	Trace

class	TrivialBBLBlockTime

class	Type

class	UnavailableFeatureException

class	UnsupportedFeatureException

class	VarTextDecoder

class	VirtualInst

class	VirtualInstManager

class	Virtualizer

class	WorkSpace

class	XSLTScript

Typedefs
typedef enum otawa::action_t	action_t

typedef struct otawa::address_stat_t	address_stat_t

typedef Address	address_t

typedef struct otawa::call_t	call_t

typedef otawa::cache::category_t	category_t

typedef cache::CategoryStats	CategoryStats

typedef enum otawa::code_part	code_part_t

typedef struct otawa::default_handler_t	default_handler_t

typedef enum otawa::delayed_t	delayed_t

typedef enum otawa::fmlevel	fmlevel_t

typedef SortedList< LBlock *, NumberOrder >	LinkedBlockList

typedef Pair< BasicBlock , Inst >	location_t

typedef elm::Tree< SESERegion * >	PSTree

typedef Vector< t::uint16 >	RegSet

typedef elm::Vector< Pair< Block *, Block::EdgeIter > >	stack_t

Enumerations
enum	action_t { DO_NOTHING = 0, DO_SWALLOW, DO_INSERT }

enum	code_part { PROLOGUE, BLOCK, EPILOGUE, CODE_PARTS_NUMBER }

enum	delayed_t { DELAYED_None = 0, DELAYED_Always = 1, DELAYED_Taken = 2 }

enum	fmlevel { FML_INNER = 0, FML_OUTER = 1, FML_MULTI = 2, FML_NONE }

Functions
Identifier< Pair< Address, Address > >	ACCESS_RANGE ("otawa::ACCESS_RANGE")
	Put on a memory access instruction, provides a range of possible accesses. More...

p::id< Address >	ADDED_CFG ("otawa::ADDED_CFG", 0)
	This configuration property allows to add unlinked CFG to the used CFG collection. More...

p::id< CString >	ADDED_FUNCTION ("otawa::ADDED_FUNCTION", 0)
	This configuration property allows to add unlinked functions to the used CFG collection. More...

p::feature	ADDRESS_ANALYSIS_FEATURE ("otawa::ADDRESS_ANALYSIS_FEATURE", new Maker< NoProcessor >())
	This feature ensures that accessed memory information (class AccessedAddress) is provided for each basic block. More...

Identifier< address_stat_t * >	ADDRESS_STATS ("otawa::ADDRESS_STATS", 0)
	This property provides statistics about ADDRESS_ANALYSIS_FEATURE. More...

Identifier< AccessedAddresses * >	ADDRESSES ("otawa::ADDRESSES", 0)
	Provide the set of accesses to the memory for the current basic block. More...

Identifier< Inst::kind_t >	ALT_KIND ("otawa::ALT_KIND", 0)
	Provide an alternative kind for an instruction, superseding the current kind of the instruction. More...

p::id< int >	ARGC ("otawa::ARGC", -1)
	Argument count as passed to the program (int). More...

p::id< char ** >	ARGV ("otawa::ARGV", 0)
	Argument values as passed to the program (char **). More...

Identifier< Address >	ARGV_ADDRESS ("otawa::ARGV_ADDRESS", Address::null)
	This feature is put on the process object whose image supports Unix-like argument passing. More...

Identifier< Address >	AUXV_ADDRESS ("otawa::AUXV_ADDRESS", Address::null)
	This feature is put on the process object whose image supports Unix-like argument passing. More...

Identifier< bool >	BACK_EDGE ("otawa::BACK_EDGE", false)
	Identifier for marking back edges. More...

p::id< Bag< Address > >	BB_BOUNDS ("otawa::BB_BOUNDS")
	Configuration identifier, provides a list of BB start point (whatever the control flow of the executable). More...

Identifier< Address >	BRANCH_TARGET ("otawa::BRANCH_TARGET", Address())
	Put on instruction that may branch to several targets or whose target computation cannot computed. More...

Identifier< Vector< MAYProblem::Domain * > * >	CACHE_ACS_MAY ("otawa::CACHE_ACS_MAY", NULL)
	This property represents the "may" Abstract Cache State of a basic block. More...

Identifier< Vector< MAYProblem::Domain * > * >	CACHE_ACS_MAY_ENTRY ("otawa::CACHE_ACS_MAY_ENTRY", NULL)
	This property allows us to set an entry may ACS. More...

Identifier< Vector< MUSTProblem::Domain * > * >	CACHE_ACS_MUST ("otawa::CACHE_ACS_MUST", 0)
	This property represents the MUST Abstract Cache State of a basic block. More...

Identifier< Vector< MUSTProblem::Domain * > * >	CACHE_ACS_MUST_ENTRY ("otawa::CACHE_ACS_MUST_ENTRY", 0)
	This property allows to set an entry MUST ACS. More...

Identifier< Vector< PERSProblem::Domain * > * >	CACHE_ACS_PERS ("otawa::CACHE_ACS_PERS", 0)
	This property represents the "persistence" Abstract Cache State of a basic block. More...

Identifier< Vector< PERSProblem::Domain * > * >	CACHE_ACS_PERS_ENTRY ("otawa::CACHE_ACS_PERS_ENTRY", 0)
	This property allows to set an entry PERS ACS. More...

p::id< hard::CacheConfiguration * >	CACHE_CONFIG ("otawa::CACHE_CONFIG", 0)
	This property is used to pass the cache configuration directly to the platform. More...

p::id< elm::xom::Element * >	CACHE_CONFIG_ELEMENT ("otawa::CACHE_CONFIG_ELEMENT", 0)
	Gives an XML element containing the cache configuration. More...

p::id< elm::sys::Path >	CACHE_CONFIG_PATH ("otawa::CACHE_CONFIG_PATH", "")
	Gives the path of file containing the cache configuration. More...

Identifier< Vector< MUSTProblem::Domain * > * >	CACHE_EDGE_ACS_MUST ("otawa::cache_edge_acs_must", NULL)
	This property represents the "must" Abstract Cache State of a basic block. More...

Identifier< Vector< PERSProblem::Domain * > * >	CACHE_EDGE_ACS_PERS ("otawa::cache_edge_acs_pers", NULL)
	This property represents the "persistence" Abstract Cache State of a basic block. More...

Identifier< Address >	CALL_TARGET ("otawa::CALL_TARGET", Address())
	Put on instruction that may call to several targets or whose target computation cannot computed. More...

p::id< Edge * >	CALLED_BY ("otawa::CALLED_BY", 0)
	This properties are put on a CFG to get the list of edges calling it. More...

Identifier< Vector< category_t > * >	CATEGORY_EDGE ("otawa::cactegory_edge", NULL)

Identifier< Vector< BasicBlock * > * >	CATEGORY_EDGE_HEADER ("otawa::category_edge_header", NULL)

p::feature	CFG_CHECKSUM_FEATURE ("otawa::CFG_CHECKSUM_FEATURE", new Maker< CFGCheckSummer >())
	This feature ensures that each CFG has hooked a checksum allowing to check binary modifications between launch of an OTAWA application. More...

Identifier< const CFGInfo * >	CFG_INFO ("otawa::CFG_INFO", 0)
	Get the collection of CFG found in the program. More...

p::feature	CFG_INFO_FEATURE ("otawa::CFG_INFO_FEATURE", new Maker< CFGBuilder >())
	Feature asserting that the CFG has been scanned in the program. More...

p::id< Address >	CFG_START ("otawa::CFG_START")
	Provide the start address of a sub-CFG to extract (inclusive). More...

p::id< Address >	CFG_STOP ("otawa::CFG_STOP", false)
	Provide the stop address of a sub-CFG to extract (exclusive). More...

p::feature	CHECKED_CFG_FEATURE ("otawa::CHECKED_CFG_FEATURE", new Maker< CFGChecker >())
	This feature ensures that. More...

Identifier< unsigned long >	CHECKSUM ("otawa::CHECKSUM", 0)
	This property hooked on a CFG provides a checksum build on the instruction of the CFG. More...

p::interfaced_feature< const CFGCollection >	COLLECTED_CFG_FEATURE ("otawa::COLLECTED_CFG_FEATURE", new Maker< CFGCollector >())
	This feature asserts that all CFG involved in the current computation has been collected and accessible thanks to INVOLVED_CFGS property. More...

p::feature	CONDITIONAL_INSTRUCTIONS_FEATURE ("otawa::CONDITIONAL_INSTRUCTIONS_FEATURE", new Maker< NoProcessor >())
	This feature is provided by Process which architecture provides conditional instructions. More...

p::feature	CONDITIONAL_RESTRUCTURED_FEATURE ("otawa::CONDITIONAL_RESTRUCTURED_FEATURE", p::make< ConditionalRestructurer >())
	This feature ensures that the CFG is transformed to reflect the effects of conditional instructions. More...

p::id< elm::xom::Element * >	CONFIG_ELEMENT ("otawa::CONFIG_ELEMENT", 0)
	XML element containing the configuration of the current computation. More...

p::id< elm::sys::Path >	CONFIG_PATH ("otawa::CONFIG_PATH", "")
	Path to the XML configuration file used in this computation. More...

p::id< ContextualPath >	CONTEXT ("otawa::CONTEXT")
	Provide context for the referred object. More...

Identifier< ContextTree * >	CONTEXT_TREE ("otawa::CONTEXT_TREE", 0)
	This property identifier provides a context tree hooked to a framework. More...

Feature< ContextTreeByCFGBuilder >	CONTEXT_TREE_BY_CFG_FEATURE ("otawa::CONTEXT_TREE_BY_CFG_FEATURE")
	Assert that a context tree has been built for each CFG involved in the current computation. More...

Feature< ContextTreeBuilder >	CONTEXT_TREE_FEATURE ("otawa::CONTEXT_TREE_FEATURE")
	This feature asserts that a context tree of the task is available in the framework. More...

Identifier< ContextualLoopBound * >	CONTEXTUAL_LOOP_BOUND ("otawa::CONTEXTUAL_LOOP_BOUND", 0)
	This property provides context-dependent loop bounds. More...

p::feature	CONTROL_DECODING_FEATURE ("otawa::CONTROL_DECODING_FEATURE", new Maker< NoProcessor >())
	This feature is usually provided by the loader providing decoding facility for control instructions. More...

Feature< DeadCodeAnalysis >	DEAD_CODE_ANALYSIS_FEATURE ("otawa::DEAD_CODE_ANALYSIS_FEATURE")

Feature< TextDecoder >	DECODED_TEXT ("otawa::DECODED_TEXT")
	This feature ensures that text segment of the process has been decoded and, consequently, that instructions are available. More...

Identifier< const AbstractFeature * >	DEF_BY ("otawa::DEF_BY", 0)
	Identifier for identifier property providing ownerness of an identifier. More...

Identifier< int >	DEFAULT_BRANCH_PENALTY ("otawa::DEFAULT_BRANCH_PENALTY", 2)

Property *	defBy (const AbstractFeature *feature)

Identifier< delayed_t >	DELAYED ("otawa::DELAYED", DELAYED_None)
	This kind of property is put on control branch to know if the following instruction is executed as part of a delayed branch. More...

p::feature	DELAYED2_FEATURE ("otawa::DELAYED2_FEATURE", new Maker< NoProcessor >())
	This Process feature informs that the actual architecture supports delayed branch. More...

p::feature	DELAYED_CFG_FEATURE ("otawa::DELAYED_CFG_FEATURE", new Maker< DelayedBuilder >())
	This feature informs that the current microprocessor supports delayed branches and that the CFG has been changed to reflect effect of delay branches. More...

p::feature	DELAYED_FEATURE ("otawa::DELAYED_FEATURE", new Maker< NoProcessor >())
	This feature is put on processes by the loader to inform that the control instruction of the current instruction contains delayed branches. More...

Identifier< DelayedInfo * >	DELAYED_INFO ("otawa::DELAYED_INFO", 0)
	This property provides access to delayed branch information of the current program. More...

Identifier< bool >	DELAYED_INST ("otawa::DELAYED_INST", false)
	This property is set on instruction of a delayed branch. More...

Identifier< bool >	DELAYED_NOP ("otawa::DELAYED_NOP", false)
	This property is true on NOP instructions insserted due to branch delay. More...

p::interfaced_feature< DomInfo >	DOMINANCE_FEATURE ("otawa::DOMINANCE_FEATURE", new Maker< Dominance >())
	This feature ensures that information about domination between nodes of a CFG is available. More...

p::id< bool >	DUMP ("otawa::DUMP", false)
	Dump the results of all analyzes. More...

p::id< string >	DUMP_FOR ("otawa::DUMP_FOR", "")
	Dump the result of the analysis which name is passed as argument. More...

p::id< elm::io::OutStream * >	DUMP_STREAM ("otawa::DUMP_STREAM", nullptr)
	Dump the results to the given stream. More...

p::id< string >	DUMP_TO ("otawa::DUMP_TO", "")
	Dump the result to the given file path. More...

Identifier< LockPtr< ListOfEdgeConflict > >	EDGE_OF_INFEASABLE_PATH_I ("otawa::EDGE_OF_INFEASABLE_PATH_I", NULL)
	Put on an infeasable path edge Mark a edge that is into an path constrain More...

p::id< Block * >	ENCLOSING_LOOP_HEADER ("otawa::ENCLOSING_LOOP_HEADER", 0)
	Defined for any BasicBlock that is part of a loop. More...

const AbstractIdentifier	END ("end")
	This identifier is used for marking the end of property list definition in variable arguments "...". More...

p::id< ContextualStep >	ENTER ("otawa::ENTER")
	Note the entry into a particular context provided by the property. More...

p::id< CFG * >	ENTRY_CFG ("otawa::entry_cfg", 0)
	This property is used to get the entry CFG of the currently processed task. More...

p::id< char ** >	ENVP ("otawa::ENVP", 0)
	Argument values as passed to the program (char **). More...

Identifier< Address >	ENVP_ADDRESS ("otawa::ENVP_ADDRESS", Address::null)
	This feature is put on the process object whose image supports Unix-like argument passing. More...

string	escape (const string &s)
	Escape special characters in the given string. More...

p::id< Event * >	EVENT ("otawa::EVENT", 0)
	Allows to hook an event to a basic block or to an edge. More...

Identifier< bool >	EXIST_PROVIDED_STATE ("otawa::EXISTPROVIDED_STATE", false)

p::id< elm::Vector< Edge * > * >	EXIT_LIST ("otawa::EXIT_LIST", 0)
	Defined for any BasicBlock that is a loop header. More...

p::interfaced_feature< LoopManager * >	EXTENDED_LOOP_FEATURE ("otawa::EXTENDED_LOOP_FEATURE", p::make< ExtendedLoopBuilder >())
	This feature build Loop objects representing the hierarchy of loops and attach it to the CFG and its blocks. More...

Identifier< fmlevel_t >	FIRSTMISS_LEVEL ("otawa::FIRSTMISS_LEVEL", FML_MULTI)
	Specify the loop-level-precision of the First Miss computation (inner, outer, multi-level) More...

p::feature	FLOAT_MEMORY_ACCESS_FEATURE ("otawa::FLOAT_MEMORY_ACCES_FEATURE", new Maker< NoProcessor >())
	This feature is usually asserted by processes that provides access to the memory segment of the program with float values. More...

p::feature	FLOW_FACTS_FEATURE ("otawa::FLOW_FACTS_FEATURE", new Maker< FlowFactLoader >())
	This feature ensures that the flow facts has been loaded. More...

Identifier< bool >	FLOW_FACTS_MANDATORY ("otawa::FLOW_FACTS_MANDATORY", false)
	In configuration of the FlowFactLoader, makes it fail if no flow fact fail is available. More...

Identifier< xom::Element * >	FLOW_FACTS_NODES ("otawa::FLOW_FACTS_NODES")
	This property may be used in the configuration of a code processor to directly pass an xml element containing flow facts in Flow Fact XML format format. More...

Identifier< Path >	FLOW_FACTS_PATH ("otawa::FLOW_FACTS_PATH", "")
	This property may be used in the configuration of a code processor to pass the path of an flow fact file containing flow facts. More...

template<class T >
void	from_string (const string &s, T &v)

template<>
void	from_string (const string &str, Address &v)

template<class T >
void	from_string (const string &str, Bag< T > &bag)

template<>
void	from_string (const string &str, bool &v)

template<>
void	from_string (const string &str, double &v)

template<>
void	from_string (const string &str, int &v)

template<>
void	from_string (const string &str, long &v)

template<>
void	from_string (const string &str, long long &v)

template<>
void	from_string (const string &str, string &v)

template<>
void	from_string (const string &str, SymAddress *&v)

template<>
void	from_string (const string &str, sys::Path &v)

template<>
void	from_string (const string &str, unsigned int &v)

template<>
void	from_string (const string &str, unsigned long &v)

template<>
void	from_string (const string &str, unsigned long long &v)

void	from_string_split (const string &str, Vector< string > &items)

Identifier< String >	FUNCTION_LABEL ("otawa::FUNCTION_LABEL", "")
	This property is put on instruction. More...

Identifier< String >	GRAPHS_OUTPUT_DIRECTORY ("otawa::GRAPHS_OUTPUT_DIRECTORY","")

p::feature	ICACHE_ACS_FEATURE ("otawa::ICACHE_ACS_FEATURE", new Maker< ACSBuilder >())
	This feature represents the availability of Abstract Cache State informations. More...

p::feature	ICACHE_ACS_MAY_FEATURE ("otawa::ICACHE_ACS_MAY_FEATURE", new Maker< ACSMayBuilder >())
	This feature represents the availability of MAY Abstract Cache State informations. More...

p::feature	ICACHE_CATEGORY2_FEATURE ("otawa::ICACHE_CATEGORY2_FEATURE", new Maker< CAT2Builder >())
	This feature ensures that the categories for instruction cache according to the following method has been computed: More...

p::feature	ICACHE_CONSTRAINT2_FEATURE ("otawa::ICACHE_CONSTRAINT2_FEATURE", new Maker< CAT2ConstraintBuilder >())
	Ensures that the constraints for cache analysis by categories 2 has been built and that the term of instruction cache has been added to the objective function. More...

Feature< EdgeACSBuilder >	ICACHE_EDGE_ACS_FEATURE ("otawa::ICACHE_EDGE_ACS_FEATURE")
	This feature represents the availability of Abstract Cache State informations. More...

Feature< EdgeCAT2Builder >	ICACHE_EDGE_CATEGORY2_FEATURE ("otawa::ICACHE_EDGE_CATEGORY2_FEATURE")

Feature< FirstLastBuilder >	ICACHE_FIRSTLAST_FEATURE ("otawa::ICACHE_FIRSTLAST_FEATURE")
	This feature represents the availability of the LAST_LBLOCK and LBLOCK_ISFIRST properties. More...

p::feature	ICACHE_ONLY_CONSTRAINT2_FEATURE ("otawa::ICACHE_ONLY_CONSTRAINT2_FEATURE", new Maker< CAT2OnlyConstraintBuilder >())
	Ensures that the constraints for cache analysis by categories 2 has been built. More...

Identifier< CachePenalty * >	ICACHE_PENALTY ("otawa::CACHE_PENALTY", NULL)

Property *	idDesc (cstring desc)

Identifier< cstring >	IDENTIFIER_DESC ("otawa::IDENTIFIER_DESC", "")
	Property of this identifier is put on identifier to give a more precise description of the identifier. More...

template<>
Identifier< cstring >	IDENTIFIER_ID ("otawa::IDENTIFIER_ID", "")
	Configuration identifier for objects inheriting from AbstractIdentifier to customize the name and make the object reachable by this name. More...

Identifier< cstring >	IDENTIFIER_LABEL ("otawa::IDENTIFIER_LABEL", "")
	Property of this identifier is put on identifier to give a more human-readable name to the identifier. More...

Property *	idLabel (cstring label)

Identifier< bool >	IGNORE_CONTROL ("otawa::IGNORE_CONTROL", false)
	Put on a control instruction to prevent it to be interpreted as is. More...

Identifier< bool >	IGNORE_ENTRY ("otawa::IGNORE_ENTRY", false)
	Put on function symbol that must be ignored as function entry. More...

Identifier< bool >	IGNORE_SEQ ("otawa::IGNORE_SEQ", false)
	Put on a control instruction to prevent to pass in sequence. More...

Block::EdgeCollection	IN_EDGES (const Block *b)

Identifier< LockPtr< ConflictOfPath > >	INFEASABLE_PATH ("otawa::INFEASABLE_PATH", NULL)
	Put on an infeasable path begining and end mark. More...

Identifier< LockPtr< ListOfEndConflict > >	INFEASABLE_PATH_END ("otawa::INFEASABLE_PATH_END", NULL)

Identifier< bool >	INLINING_POLICY ("otawa::INLINING_POLICY")
	Put on the first instruction of a function to set default inlining behavior during its virtualization. More...

p::id< const CFGCollection * >	INVOLVED_CFGS ("otawa::INVOLVED_CFGS", 0)
	This property is used to link the current computation involved CFG on the framework. More...

Identifier< bool >	IS_RETURN ("otawa::IS_RETURN", false)
	Put on a control flow instruction, this shows that this instruction is equivalent to a function return. More...

const Level	L1 (1)

const Level	L2 (2)

const Level	L3 (3)

const Level	L4 (4)

const Level	L5 (5)

const Level	L6 (6)

const Level	L7 (7)

const Level	L8 (8)

const Level	L9 (9)

Identifier< String >	LABEL ("otawa::LABEL", "")
	Property with this identifier is put on instructions or basic blocks which a symbol is known for. More...

p::feature	LABEL_FEATURE ("otawa::LABEL_FEATURE", new Maker< LabelSetter >())
	This feature ensures that label or symbol information has been linked to the concerned instruction. More...

Identifier< LBlock ** >	LAST_LBLOCK ("otawa::LAST_LBLOCK", NULL)
	This property gives the ID of the last lblock of a BasicBlock, for each line. More...

Identifier< bool >	LBLOCK_ISFIRST ("otawa::LBLOCK_ISFIRST", false)
	This property tells if the lblock is the first of its BasicBlock (for its cache line) This information is useful, because if it's false, then, the lblock is always a miss. More...

ot::size	leastGreaterLog2 (ot::size x)
	Compute the least greater logarithm of 2 for the given value. More...

p::id< int >	LEAVE ("otawa::LEAVE", 0)
	Leave the number of context provided by the number of argument. More...

Identifier< Vector< LBlock * > * >	LINKED_BLOCKS ("otawa::LINKED_BLOCKS", NULL)
	!!TODO!! More...

p::id< string >	LOAD_PARAM ("otawa::LOAD_PARAM", "")
	Identifier used for Manager::load() configuration. More...

p::id< Loader * >	LOADER ("otawa::LOADER", 0)
	Identifier of the property indicating the loader to use. More...

p::id< string >	LOADER_NAME ("otawa::LOADER_NAME", "")
	Identifier of the property indicating a name (CString) of the loader to use. More...

p::id< location_t >	LOCATION_START ("otawa::LOCATION_START", location_t(nullptr, nullptr))
	Provide the start location of a sub-CFG to extract (inclusive). More...

p::id< location_t >	LOCATION_STOP ("otawa::LOCATION_STOP", location_t(nullptr, nullptr))
	Provide the stop location of a sub-CFG to extract (inclusive). More...

p::id< elm::io::OutStream * >	LOG ("otawa::LOG", &cerr.stream())
	This property identifier is used for setting the log stream used by the processor to write messages (information, warning, error). More...

p::id< string >	LOG_FOR ("otawa::LOG_FOR")
	Display logs only for the named processor. More...

p::id< Monitor::log_level_t >	LOG_LEVEL ("otawa::LOG_LEVEL", Monitor::LOG_NONE)
	Property passed in the configuration property list of a processor to select the log level between LOG_PROC, LOG_CFG or LOG_BB. More...

p::id< Block * >	LOOP_ENTRY ("otawa::LOOP_ENTRY", nullptr)
	Is defined for an Edge if this Edge is the entry-edge of any loop. More...

p::id< Block * >	LOOP_EXIT ("otawa::LOOP_EXIT", nullptr)
	Is defined for an Edge if this Edge is the exit-edge of any loop. More...

Identifier< bool >	LOOP_HEADER ("otawa::LOOP_HEADER", false)
	Identifier for marking basic blocks that are entries of loops. More...

p::feature	LOOP_HEADERS_FEATURE ("otawa::LOOP_HEADERS_FEATURE", new Maker< Dominance >())
	This feature ensures that all loop header are marked with a LOOP_HEADER property, and the backedges are marked with a BACK_EDGE property. More...

p::feature	LOOP_INFO_FEATURE ("otawa::LOOP_INFO_FEATURE", new Maker< LoopInfoBuilder >())
	This feature asserts that the loop info of the task is available in the framework. More...

Identifier< LockPtr< ListOfLoopConflict > >	LOOP_OF_INFEASABLE_PATH_I ("otawa::LOOP_OF_INFEASABLE_PATH_I", NULL)
	Put on an infeasable path loop Mark a loop that contains or is into an path constrain. More...

Property *	make (const Identifier< cstring > &id, const char *v)

Property *	make (const Identifier< string > &id, const char *v)

template<class T >
Property *	make (const Identifier< T > &id, const T &v)

Identifier< int >	MAX_ITERATION ("otawa::MAX_ITERATION", -1)
	Put on the first instruction of a loop, it gives the maximum number of iteration of this loop. More...

p::feature	MEMORY_ACCESS_FEATURE ("otawa::MEMORY_ACCESS_FEATURE", new Maker< NoProcessor >())
	This feature is usually asserted by processes that provides access to the memory segment of the program. More...

p::feature	MEMORY_ACCESSES ("otawa::MEMORY_ACCESSES", new Maker< NoProcessor >())
	This feature, put on a process, informs that the functional simulator provides the ability to give information about memory accesses. More...

p::id< elm::xom::Element * >	MEMORY_ELEMENT ("otawa::MEMORY_ELEMENT", 0)
	Passed to manager::load() to give the XML element describing the memory configuration. More...

p::id< hard::Memory * >	MEMORY_OBJECT ("otawa::MEMORY_OBJECT", 0)
	Passed to manager::load() to set the memory configuration. More...

p::id< elm::sys::Path >	MEMORY_PATH ("otawa::MEMORY_PATH", "")
	Passed to Manager::load() to give the path of the file describing the memory. More...

Identifier< int >	MIN_ITERATION ("otawa::MIN_ITERATION", -1)
	Put on the first instruction of a loop, it gives the minimal number of iterations. More...

Identifier< ilp::Var * >	MISS_VAR ("otawa::MISS_VAR", 0)
	Property giving the variable counting the number of misses. More...

p::feature	MKFF_PRESERVATION_FEATURE ("otawa::MKFF_PRESERVATION_FEATURE", new Maker< FlowFactLoader >())
	This feature ensures that preservation information used by mkff is put on instruction. More...

template<class T >
Bag< T >	move (int c, T *t)

template<class T >
Bag< T >	move (Vector< T > &v)

Identifier< bool >	NEVER_TAKEN ("otawa::NEVER_TAKEN")

Identifier< bool >	NO_CALL ("otawa::NO_CALL", false)
	Put on the first instruction of a function that must be no called. More...

Identifier< bool >	NO_INLINE ("otawa::NO_INLINE")
	Put on the first instruction of a function to indicate whether it should be inlined or not during virtualization. More...

Identifier< bool >	NO_RETURN ("otawa::NO_RETURN", false)
	This annotation is put on the first instruction of functions that does not never return. More...

p::id< string >	NO_RETURN_FUNCTION ("otawa::NO_RETURN_FUNCTION", "")
	this property may be used to pass information about the non-returning behaviour of some functions. More...

p::id< bool >	NO_STACK ("otawa::NO_STACK", false)
	This property shows that no stack need to be allocated. More...

p::id< bool >	NO_SYSTEM ("otawa::NO_SYSTEM", false)
	This property shows that the system does not need to by simulated when the binary image is built. More...

p::feature	NORMALIZED_CFGS_FEATURE ("otawa::NORMALIZED_CFGS_FEATURE", new Maker< CFGNormalizer >())
	This feature ensures that the CFG are in a normalized form: fully resolved branches, no entering or exiting edges to or from external CFGs. More...

elm::io::Output &	operator<< (elm::io::Output &out, Address addr)

elm::io::Output &	operator<< (elm::io::Output &out, const AbstractIdentifier &id)

elm::io::Output &	operator<< (elm::io::Output &out, const AbstractIdentifier *id)

elm::io::Output &	operator<< (elm::io::Output &out, const Property *prop)

elm::io::Output &	operator<< (elm::io::Output &out, const PropList &props)

elm::io::Output &	operator<< (elm::io::Output &out, const PropList *props)

io::Output &	operator<< (elm::io::Output &out, Inst *inst)

elm::io::Output &	operator<< (elm::io::Output &out, Process *proc)

elm::io::Output &	operator<< (elm::io::Output &output, const MAYProblem::Domain &dom)

elm::io::Output &	operator<< (elm::io::Output &output, const MUSTPERS::Domain &dom)

elm::io::Output &	operator<< (elm::io::Output &output, const MUSTProblem::Domain &dom)

elm::io::Output &	operator<< (elm::io::Output &output, const PERSBranch::Domain &dom)

elm::io::Output &	operator<< (elm::io::Output &output, const PERSProblem::Domain &dom)

io::Output &	operator<< (io::Output &o, const hard::Bank::type_t &t)

io::Output &	operator<< (io::Output &out, AccessedAddresses *aa)

io::Output &	operator<< (io::Output &out, address_stat_t *s)

io::Output &	operator<< (io::Output &out, BasicBlock *block)

io::Output &	operator<< (io::Output &out, Block *block)

io::Output &	operator<< (io::Output &out, CFG *cfg)
	Address CFG::address(void); Get the address of the first instruction of the CFG. More...

io::Output &	operator<< (io::Output &out, const AccessedAddress *addr)

io::Output &	operator<< (io::Output &out, const AccessedAddresses *aa)

io::Output &	operator<< (io::Output &out, const CFG::BlockIter &i)

io::Output &	operator<< (io::Output &out, const Condition &c)

io::Output &	operator<< (io::Output &out, const ContextualPath &path)

template<class T >
io::Output &	operator<< (io::Output &out, const ContextualPath::Ref< T > &r)

io::Output &	operator<< (io::Output &out, const ContextualStep &path)

template<class T , class I >
io::Output &	operator<< (io::Output &out, const ImmutableRef< T, I > &ref)

io::Output &	operator<< (io::Output &out, const location_t &loc)

io::Output &	operator<< (io::Output &out, const Loop *l)

io::Output &	operator<< (io::Output &out, const MemArea &a)

template<class T , class I >
io::Output &	operator<< (io::Output &out, const Ref< T, I > &ref)

io::Output &	operator<< (io::Output &out, const Type &type)

io::Output &	operator<< (io::Output &out, Edge *edge)

io::Output &	operator<< (io::Output &out, Event *event)

io::Output &	operator<< (io::Output &out, Event::occurrence_t occ)

io::Output &	operator<< (io::Output &out, Inst::Kind kind)

io::Output &	operator<< (io::Output &out, PCGBlock *b)

io::Output &	operator<< (io::Output &out, PCGEdge *b)

io::Output &	operator<< (io::Output &out, SymAddress *addr)

io::Output &	operator<< (io::Output &out, Symbol *sym)

io::Output &	operator<< (io::Output &out, Symbol::kind_t k)

io::Output &	operator<< (io::Output &out, SynthBlock *block)

otawa::Output &	operator<< (otawa::Output &out, const fmlevel_t &fml)

Output &	operator<< (Output &out, ContextTree *ct)

Trace &	operator<< (Trace &trace, const Level &level)

Event::occurrence_t	operator\| (Event::occurrence_t x, Event::occurrence_t y)
	Combines two event occcurrences according to the partial order (getting the maximu of x and y). More...

Block::EdgeCollection	OUT_EDGES (const Block *b)

p::id< elm::io::OutStream * >	OUTPUT ("otawa::OUTPUT", &cout.stream())
	This property identifier is used for setting the output stream used by the processor to write results. More...

Identifier< ContextTree * >	OWNER_CONTEXT_TREE ("otawa::OWNER_CONTEXT_TREE", 0)
	Annotations with this identifier are hooked to basic blocks and gives the owner context tree (ContextTree * data). More...

p::feature	PCG_FEATURE ("otawa::PCG_FEATURE", p::make< PCGBuilder >())
	This feature ensure that a PCG is provided. More...

p::id< int >	PIPELINE_DEPTH ("otawa::PIPELINE_DEPTH", -1)
	This property is a hint to have an estimation of the pipeline depth. More...

p::id< hard::Platform * >	PLATFORM ("otawa::PLATFORM", 0)
	Identifier of the property indicating a platform (Platform *) to use. More...

p::id< string >	PLATFORM_NAME ("otawa::PLATFORM_NAME", "")
	Identifier of the property indicating the name (CString) of the platform to use. More...

p::interfaced_feature< PostDomInfo >	POSTDOMINANCE_FEATURE ("otawa::POSTDOMINANCE_FEATURE", new Maker< PostDominance >())
	This feature ensures that information about postdomination between nodes of a CFG is vailable. More...

Block::PredCollection	PREDS (const Block *b)

p::id< Event * >	PREFIX_EVENT ("otawa::PREFIX_EVENT", 0)
	Allows to hook an event to an edge and consider it as part of the prefix of the edge time. More...

Identifier< bool >	PRESERVED ("otawa::PRESERVED", false)
	Put on instruction that must preserved from the mkff special flow-fact detection. More...

Identifier< int >	PROCESSED_CFG ("otawa::processed_cfg", 0)
	This property is used to store statistics about the count of processed CFG. More...

p::id< hard::Processor * >	PROCESSOR ("otawa::PROCESSOR", 0)
	Gives the processor to use in the current computation. More...

p::id< elm::xom::Element * >	PROCESSOR_ELEMENT ("otawa::PROCESSOR_ELEMENT", 0)
	XML element containing the configuration of the processor. More...

p::id< elm::sys::Path >	PROCESSOR_PATH ("otawa::PROCESSOR_PATH", "")
	Path to the XML configuration file of the processor. More...

p::id< PCG * >	PROGRAM_CALL_GRAPH ("otawa::PROGRAM_CALL_GRAPH", 0)
	Property providing the PCG (Program Call Graph). More...

Identifier< dfa::State * >	PROVIDED_STATE ("otawa::PROVIDED_STATE", 0)
	Associate a program point with a provided dfa::State. More...

Identifier< bool >	PSEUDO_UNROLLING ("otawa::PSEUDO_UNROLLING", false)
	This property represents the "persistence" Abstract Cache State of a basic block. More...

p::id< bool >	RECURSE_BACK ("otawa::RECURSE_BACK")
	This property marks PCG edges and synthetic block corresponding to calls backing inside a recursivity nest. More...

p::id< bool >	RECURSE_ENTRY ("otawa::RECURSE_ENTRY")
	This property marks PCG edges and synthetic block corresponding to calls entering a recursivity nest. More...

p::id< PCGBlock * >	RECURSE_HEAD ("RECURSE_HEAD", nullptr)
	This properties marks CFG and PCGNode corresponding to head of recursivity nests. More...

p::id< bool >	RECURSIVE ("otawa::recursive", true)
	Activate the recucursive feature of BBProcessors : each time a basic block contains a function call, the CFG of this function is recorded to be processed later after the current CFG. More...

p::feature	RECURSIVITY_ANALYSIS ("otawa::RECURSIVITY_ANALYSIS", p::make< ResursivityAnalysis >())
	This features ensures that recursive function calls has been identified in the PCG. More...

p::feature	REDUCED_LOOPS_FEATURE ("otawa::REDUCED_LOOPS_FEATURE", p::make< LoopReductor >())
	Ensure that no more irregular loop remains in the program representation. More...

p::feature	REGISTER_USAGE_FEATURE ("otawa::REGISTER_USAGE_FEATURE", new Maker< NoProcessor >())
	This feature is usually asserted by processes that provides access to the register usage information. More...

template<class T >
const AbstractRegistration &	registration (void)

Identifier< const BitSet * >	REVERSE_DOM ("otawa::REVERSE_DOM", 0)
	Identifier of annotation containing reverse-dominance information. More...

p::feature	SEMANTICS_INFO ("otawa::SEMANTICS_INFO", new Maker< NoProcessor >())
	This feature is present when the loader provides implementation of semantics information. More...

p::feature	SEMANTICS_INFO_EXTENDED ("otawa::SEMANTICS_INFO_EXTENDED", new Maker< NoProcessor >())
	This feature is present when the loader provides implementation of extended semantics information. More...

p::feature	SEMANTICS_INFO_FLOAT ("otawa::SEMANTICS_INFO_FLOAT", new Maker< NoProcessor >())
	This feature is present when the loader provides implementation of floating-point semantic instructions. More...

char	sign (t::int32 v)

p::id< sim::Simulator * >	SIMULATOR ("otawa::SIMULATOR", 0)
	This property defines the used the used simulator when a simulator is needed to perform simulation. More...

p::id< string >	SIMULATOR_NAME ("otawa::SIMULATOR_NAME", "")
	Name of the simulator to use. More...

p::feature	SOURCE_LINE_FEATURE ("otawa::SOURCE_LINE_FEATURE", new Maker< NoProcessor >())
	This feature asserts that a table matching program address and source (file, lines) is available. More...

Identifier< Address >	SP_ADDRESS ("otawa::SP_ADDRESS", Address::null)
	This feature is put on the process to get information about the built image. More...

p::feature	SPLIT_CFG ("otawa::SPLIT_CFG", p::make< SubCFGBuilder >())
	This feature ensure that a part of the current has been extracted as a sub-CFG based on address provided by two properties: More...

p::feature	STACK_ANALYSIS_FEATURE ("otawa::STACK_ANALYSIS_FEATURE", new Maker< StackAnalysis >())
	This features ensure that the stack analysis has been identified. More...

Block::SuccCollection	SUCCS (const Block *b)

Identifier< Symbol * >	SYMBOL ("otawa::SYMBOL", 0)
	This property carries the symbol attached to an instruction. More...

p::id< Address >	TASK_ADDRESS ("otawa::TASK_ADDRESS", Address::null)
	This property, passed to the load configuration, select the task entry by its address. More...

p::id< string >	TASK_ENTRY ("otawa::TASK_ENTRY", "main")
	This property, passed to the load configuration, gives the name of the entry function of the current task. More...

Identifier< int >	TOTAL_ITERATION ("otawa::TOTAL_ITERATION", -1)
	Put on the first instruction of a loop, it gives the total number of iterations during the whole execution of the program. More...

template<class T >
const Type &	type (void)

p::id< bool >	UNROLL_THIS ("otawa::UNROLL_THIS", true)
	This property is used by UNROLLED_LOOPS_FEATURE and has to be put on header blocks of loops to select if the corresponding loop has to be unrolled or not. More...

Identifier< Block * >	UNROLLED_FROM ("otawa::UNROLLED_FROM", 0)
	Put on the header ex-header of a loop, this property gives the BB of the unrolled loop. More...

p::feature	UNROLLED_LOOPS_FEATURE ("otawa::UNROLLED_LOOPS_FEATURE", new Maker< LoopUnroller >())
	This feature that the loops have been unrolled at least once. More...

p::id< bool >	VERBOSE ("otawa::VERBOSE", false)
	This property activates the verbose mode of the processor: information about the processor work will be displayed. More...

Identifier< bool >	VIRTUAL_DEFAULT ("otawa::VIRTUAL_DEFAULT", true)
	Configuration property of Virtualizer: it set the default behavior for inlining of function call during virtualization (default to true). More...

p::feature	VIRTUAL_INST_FEATURE ("otawa::VIRTUAL_INST_FEATURE", p::make< VirtualInstBuilder >())
	Ensure that a virtual instruction manager is available to create virtual instructions. More...

p::id< VirtualInstManager * >	VIRTUAL_INST_MANAGER ("otawa::VIRTUAL_INST_MANAGER", 0)
	Get the current virtual instruction manager. More...

p::feature	VIRTUALIZED_CFG_FEATURE ("otawa::VIRTUALIZED_CFG_FEATURE", new Maker< Virtualizer >())
	This features only show that the CFG has been virtualized. More...

p::feature	VLIW_SUPPORTED ("otawa::VLIW_SUPPORTED", new Maker< NoProcessor >())
	This feature is provided on Process objects by architecture implementing VLIW facilities. More...

Identifier< int >	WEIGHT ("otawa::WEIGHT", 0)
	Get the maximum weight for the basic block it is hooked to. More...

p::feature	WEIGHT_FEATURE ("otawa::WEIGHT_FEATURE", new Maker< Weighter >())
	This feature ensures that weight information has been hooked to any BB of the CFG. More...

Variables
elm::CString	_base_displays []

Identifier< Pair< Address, Address > >	ACCESS_RANGE
	Put on a memory access instruction, provides a range of possible accesses. More...

p::id< Address >	ADDED_CFG
	This configuration property allows to add unlinked CFG to the used CFG collection. More...

p::id< CString >	ADDED_FUNCTION
	This configuration property allows to add unlinked functions to the used CFG collection. More...

p::feature	ADDRESS_ANALYSIS_FEATURE
	This feature ensures that accessed memory information (class AccessedAddress) is provided for each basic block. More...

Identifier< address_stat_t * >	ADDRESS_STATS
	This property provides statistics about ADDRESS_ANALYSIS_FEATURE. More...

Identifier< AccessedAddresses * >	ADDRESSES
	Provide the set of accesses to the memory for the current basic block. More...

Identifier< Inst::kind_t >	ALT_KIND
	Provide an alternative kind for an instruction, superseding the current kind of the instruction. More...

const category_t	ALWAYS_HIT = otawa::cache::ALWAYS_HIT

const category_t	ALWAYS_MISS = otawa::cache::ALWAYS_MISS

p::id< int >	ARGC
	Argument count as passed to the program (int). More...

p::id< char ** >	ARGV
	Argument values as passed to the program (char **). More...

Identifier< Address >	ARGV_ADDRESS
	This feature is put on the process object whose image supports Unix-like argument passing. More...

view::View &	ASSEMBLY_VIEW

Identifier< Address >	AUXV_ADDRESS
	This feature is put on the process object whose image supports Unix-like argument passing. More...

Identifier< bool >	BACK_EDGE
	Identifier for marking back edges. More...

p::id< Bag< Address > >	BB_BOUNDS
	Configuration identifier, provides a list of BB start point (whatever the control flow of the executable). More...

Identifier< Address >	BRANCH_TARGET
	Put on instruction that may branch to several targets or whose target computation cannot computed. More...

Identifier< Vector< MAYProblem::Domain * > * >	CACHE_ACS_MAY
	This property represents the "may" Abstract Cache State of a basic block. More...

Identifier< Vector< MAYProblem::Domain * > * >	CACHE_ACS_MAY_ENTRY
	This property allows us to set an entry may ACS. More...

Identifier< Vector< MUSTProblem::Domain * > * >	CACHE_ACS_MUST
	This property represents the MUST Abstract Cache State of a basic block. More...

Identifier< Vector< MUSTProblem::Domain * > * >	CACHE_ACS_MUST_ENTRY
	This property allows to set an entry MUST ACS. More...

Identifier< Vector< PERSProblem::Domain * > * >	CACHE_ACS_PERS
	This property represents the "persistence" Abstract Cache State of a basic block. More...

Identifier< Vector< PERSProblem::Domain * > * >	CACHE_ACS_PERS_ENTRY
	This property allows to set an entry PERS ACS. More...

p::id< hard::CacheConfiguration * >	CACHE_CONFIG
	This property is used to pass the cache configuration directly to the platform. More...

p::id< elm::xom::Element * >	CACHE_CONFIG_ELEMENT
	Gives an XML element containing the cache configuration. More...

p::id< elm::sys::Path >	CACHE_CONFIG_PATH
	Gives the path of file containing the cache configuration. More...

Identifier< Vector< MUSTProblem::Domain * > * >	CACHE_EDGE_ACS_MUST
	This property represents the "must" Abstract Cache State of a basic block. More...

Identifier< Vector< PERSProblem::Domain * > * >	CACHE_EDGE_ACS_PERS
	This property represents the "persistence" Abstract Cache State of a basic block. More...

Identifier< Address >	CALL_TARGET
	Put on instruction that may call to several targets or whose target computation cannot computed. More...

p::id< Edge * >	CALLED_BY
	This properties are put on a CFG to get the list of edges calling it. More...

Identifier< category_t > &	CATEGORY = cache::CATEGORY
	Branch prediction category: it is put on the BB containing the branch instruction. More...

Identifier< Vector< category_t > * >	CATEGORY_EDGE

Identifier< Vector< BasicBlock * > * >	CATEGORY_EDGE_HEADER

Identifier< Block * > &	CATEGORY_HEADER = cache::CATEGORY_HEADER

Identifier< CategoryStats * > &	CATEGORY_STATS = cache::CATEGORY_STATS

p::feature	CFG_CHECKSUM_FEATURE
	This feature ensures that each CFG has hooked a checksum allowing to check binary modifications between launch of an OTAWA application. More...

Identifier< const CFGInfo * >	CFG_INFO
	Get the collection of CFG found in the program. More...

p::feature	CFG_INFO_FEATURE
	Feature asserting that the CFG has been scanned in the program. More...

Identifier< sys::Path >	CFG_IO_PATH

p::id< Address >	CFG_START
	Provide the start address of a sub-CFG to extract (inclusive). More...

p::id< Address >	CFG_STOP
	Provide the stop address of a sub-CFG to extract (exclusive). More...

p::feature	CHECKED_CFG_FEATURE
	This feature ensures that. More...

Identifier< unsigned long >	CHECKSUM
	This property hooked on a CFG provides a checksum build on the instruction of the CFG. More...

p::interfaced_feature< const CFGCollection >	COLLECTED_CFG_FEATURE
	This feature asserts that all CFG involved in the current computation has been collected and accessible thanks to INVOLVED_CFGS property. More...

p::feature	CONDITIONAL_INSTRUCTIONS_FEATURE
	This feature is provided by Process which architecture provides conditional instructions. More...

p::feature	CONDITIONAL_RESTRUCTURED_FEATURE
	This feature ensures that the CFG is transformed to reflect the effects of conditional instructions. More...

p::id< elm::xom::Element * >	CONFIG_ELEMENT
	XML element containing the configuration of the current computation. More...

p::id< elm::sys::Path >	CONFIG_PATH
	Path to the XML configuration file used in this computation. More...

p::id< ContextualPath >	CONTEXT
	Provide context for the referred object. More...

Identifier< ContextTree * >	CONTEXT_TREE
	This property identifier provides a context tree hooked to a framework. More...

Feature< ContextTreeByCFGBuilder >	CONTEXT_TREE_BY_CFG_FEATURE
	Assert that a context tree has been built for each CFG involved in the current computation. More...

Feature< ContextTreeBuilder >	CONTEXT_TREE_FEATURE
	This feature asserts that a context tree of the task is available in the framework. More...

Identifier< ContextualLoopBound * >	CONTEXTUAL_LOOP_BOUND
	This property provides context-dependent loop bounds. More...

p::feature	CONTROL_DECODING_FEATURE
	This feature is usually provided by the loader providing decoding facility for control instructions. More...

Feature< DeadCodeAnalysis >	DEAD_CODE_ANALYSIS_FEATURE

Feature< TextDecoder >	DECODED_TEXT
	This feature ensures that text segment of the process has been decoded and, consequently, that instructions are available. More...

Identifier< const AbstractFeature * >	DEF_BY
	Identifier for identifier property providing ownerness of an identifier. More...

Identifier< int >	DEFAULT_BRANCH_PENALTY

Identifier< delayed_t >	DELAYED
	This kind of property is put on control branch to know if the following instruction is executed as part of a delayed branch. More...

p::feature	DELAYED2_FEATURE
	This Process feature informs that the actual architecture supports delayed branch. More...

p::feature	DELAYED_CFG_FEATURE
	This feature informs that the current microprocessor supports delayed branches and that the CFG has been changed to reflect effect of delay branches. More...

p::feature	DELAYED_FEATURE
	This feature is put on processes by the loader to inform that the control instruction of the current instruction contains delayed branches. More...

Identifier< DelayedInfo * >	DELAYED_INFO
	This property provides access to delayed branch information of the current program. More...

Identifier< bool >	DELAYED_INST
	This property is set on instruction of a delayed branch. More...

Identifier< bool >	DELAYED_NOP
	This property is true on NOP instructions insserted due to branch delay. More...

p::interfaced_feature< DomInfo >	DOMINANCE_FEATURE
	This feature ensures that information about domination between nodes of a CFG is available. More...

p::id< bool >	DUMP
	Dump the results of all analyzes. More...

p::id< string >	DUMP_FOR
	Dump the result of the analysis which name is passed as argument. More...

p::id< elm::io::OutStream * >	DUMP_STREAM
	Dump the results to the given stream. More...

p::id< string >	DUMP_TO
	Dump the result to the given file path. More...

Identifier< LockPtr< ListOfEdgeConflict > >	EDGE_OF_INFEASABLE_PATH_I
	Put on an infeasable path edge Mark a edge that is into an path constrain More...

p::id< Block * >	ENCLOSING_LOOP_HEADER
	Defined for any BasicBlock that is part of a loop. More...

const AbstractIdentifier	END
	This identifier is used for marking the end of property list definition in variable arguments "...". More...

p::id< ContextualStep >	ENTER
	Note the entry into a particular context provided by the property. More...

p::id< CFG * >	ENTRY_CFG
	This property is used to get the entry CFG of the currently processed task. More...

p::id< char ** >	ENVP
	Argument values as passed to the program (char **). More...

Identifier< Address >	ENVP_ADDRESS
	This feature is put on the process object whose image supports Unix-like argument passing. More...

p::id< Event * >	EVENT
	Allows to hook an event to a basic block or to an edge. More...

Identifier< bool >	EXIST_PROVIDED_STATE

p::id< elm::Vector< Edge * > * >	EXIT_LIST
	Defined for any BasicBlock that is a loop header. More...

p::interfaced_feature< LoopManager * >	EXTENDED_LOOP_FEATURE
	This feature build Loop objects representing the hierarchy of loops and attach it to the CFG and its blocks. More...

int	fft_line = 0

const category_t	FIRST_HIT = otawa::cache::FIRST_HIT

const category_t	FIRST_MISS = otawa::cache::FIRST_MISS

Identifier< fmlevel_t >	FIRSTMISS_LEVEL
	Specify the loop-level-precision of the First Miss computation (inner, outer, multi-level) More...

p::feature	FLOAT_MEMORY_ACCESS_FEATURE
	This feature is usually asserted by processes that provides access to the memory segment of the program with float values. More...

p::feature	FLOW_FACTS_FEATURE
	This feature ensures that the flow facts has been loaded. More...

Identifier< bool >	FLOW_FACTS_MANDATORY
	In configuration of the FlowFactLoader, makes it fail if no flow fact fail is available. More...

Identifier< xom::Element * >	FLOW_FACTS_NODES
	This property may be used in the configuration of a code processor to directly pass an xml element containing flow facts in Flow Fact XML format format. More...

Identifier< Path >	FLOW_FACTS_PATH
	This property may be used in the configuration of a code processor to pass the path of an flow fact file containing flow facts. More...

Identifier< BasicBlock * >	FROM_BB ("otawa::FROM_BB", 0)
	When we get the VirtualCFG associated with a SESE region, this property, hooked on a BB from the Virtual CFG, gives the corresponding BB on the original (physical) CFG. More...

Identifier< Edge * >	FROM_EDGE ("otawa::FROM_EDGE", 0)
	This property is like. More...

Identifier< string >	FUNCTION_LABEL
	This property is put on instruction. More...

Identifier< String >	GRAPHS_OUTPUT_DIRECTORY

p::feature	ICACHE_ACS_FEATURE
	This feature represents the availability of Abstract Cache State informations. More...

p::feature	ICACHE_ACS_MAY_FEATURE
	This feature represents the availability of MAY Abstract Cache State informations. More...

p::feature	ICACHE_CATEGORY2_FEATURE
	This feature ensures that the categories for instruction cache according to the following method has been computed: More...

p::feature	ICACHE_CONSTRAINT2_FEATURE
	Ensures that the constraints for cache analysis by categories 2 has been built and that the term of instruction cache has been added to the objective function. More...

Feature< EdgeACSBuilder >	ICACHE_EDGE_ACS_FEATURE
	This feature represents the availability of Abstract Cache State informations. More...

Feature< EdgeCAT2Builder >	ICACHE_EDGE_CATEGORY2_FEATURE

Feature< FirstLastBuilder >	ICACHE_FIRSTLAST_FEATURE
	This feature represents the availability of the LAST_LBLOCK and LBLOCK_ISFIRST properties. More...

p::feature	ICACHE_ONLY_CONSTRAINT2_FEATURE
	Ensures that the constraints for cache analysis by categories 2 has been built. More...

Identifier< CachePenalty * >	ICACHE_PENALTY

Identifier< cstring >	IDENTIFIER_DESC
	Property of this identifier is put on identifier to give a more precise description of the identifier. More...

Identifier< cstring >	IDENTIFIER_ID
	Configuration identifier for objects inheriting from AbstractIdentifier to customize the name and make the object reachable by this name. More...

Identifier< cstring >	IDENTIFIER_LABEL
	Property of this identifier is put on identifier to give a more human-readable name to the identifier. More...

Identifier< bool >	IGNORE_CONTROL
	Put on a control instruction to prevent it to be interpreted as is. More...

Identifier< bool >	IGNORE_ENTRY
	Put on function symbol that must be ignored as function entry. More...

Identifier< bool >	IGNORE_SEQ
	Put on a control instruction to prevent to pass in sequence. More...

Identifier< LockPtr< ConflictOfPath > >	INFEASABLE_PATH
	Put on an infeasable path begining and end mark. More...

Identifier< LockPtr< ListOfEndConflict > >	INFEASABLE_PATH_END

Identifier< bool >	INLINING_POLICY
	Put on the first instruction of a function to set default inlining behavior during its virtualization. More...

const category_t	INVALID_CATEGORY = otawa::cache::INVALID_CATEGORY

p::id< const CFGCollection * >	INVOLVED_CFGS
	This property is used to link the current computation involved CFG on the framework. More...

Identifier< bool >	IS_FEATURE ("otawa::IS_FEATURE", false)

Identifier< bool >	IS_RETURN
	Put on a control flow instruction, this shows that this instruction is equivalent to a function return. More...

const Level	L1

const Level	L2

const Level	L3

const Level	L4

const Level	L5

const Level	L6

const Level	L7

const Level	L8

const Level	L9

Identifier< string >	LABEL
	Property with this identifier is put on instructions or basic blocks which a symbol is known for. More...

p::feature	LABEL_FEATURE
	This feature ensures that label or symbol information has been linked to the concerned instruction. More...

Identifier< LBlock ** >	LAST_LBLOCK
	This property gives the ID of the last lblock of a BasicBlock, for each line. More...

Identifier< bool >	LBLOCK_ISFIRST
	This property tells if the lblock is the first of its BasicBlock (for its cache line) This information is useful, because if it's false, then, the lblock is always a miss. More...

p::id< int >	LEAVE
	Leave the number of context provided by the number of argument. More...

Identifier< Vector< LBlock * > * >	LINKED_BLOCKS
	!!TODO!! More...

p::id< string >	LOAD_PARAM
	Identifier used for Manager::load() configuration. More...

p::id< Loader * >	LOADER
	Identifier of the property indicating the loader to use. More...

p::id< string >	LOADER_NAME
	Identifier of the property indicating a name (CString) of the loader to use. More...

p::id< location_t >	LOCATION_START
	Provide the start location of a sub-CFG to extract (inclusive). More...

p::id< location_t >	LOCATION_STOP
	Provide the stop location of a sub-CFG to extract (inclusive). More...

p::id< elm::io::OutStream * >	LOG
	This property identifier is used for setting the log stream used by the processor to write messages (information, warning, error). More...

p::id< string >	LOG_FOR
	Display logs only for the named processor. More...

p::id< Monitor::log_level_t >	LOG_LEVEL
	Property passed in the configuration property list of a processor to select the log level between LOG_PROC, LOG_CFG or LOG_BB. More...

p::id< Block * >	LOOP_ENTRY
	Is defined for an Edge if this Edge is the entry-edge of any loop. More...

p::id< Block * >	LOOP_EXIT
	Is defined for an Edge if this Edge is the exit-edge of any loop. More...

p::id< Block * > &	LOOP_EXIT_EDGE = LOOP_EXIT

Identifier< bool >	LOOP_HEADER
	Identifier for marking basic blocks that are entries of loops. More...

p::feature	LOOP_HEADERS_FEATURE
	This feature ensures that all loop header are marked with a LOOP_HEADER property, and the backedges are marked with a BACK_EDGE property. More...

p::feature	LOOP_INFO_FEATURE
	This feature asserts that the loop info of the task is available in the framework. More...

Identifier< LockPtr< ListOfLoopConflict > >	LOOP_OF_INFEASABLE_PATH_I
	Put on an infeasable path loop Mark a loop that contains or is into an path constrain. More...

Manager &	MANAGER = *Manager::def()
	Default manager. More...

Identifier< int >	MAX_ITERATION
	Put on the first instruction of a loop, it gives the maximum number of iteration of this loop. More...

p::feature	MEMORY_ACCESS_FEATURE
	This feature is usually asserted by processes that provides access to the memory segment of the program. More...

p::feature	MEMORY_ACCESSES
	This feature, put on a process, informs that the functional simulator provides the ability to give information about memory accesses. More...

p::id< elm::xom::Element * >	MEMORY_ELEMENT
	Passed to manager::load() to give the XML element describing the memory configuration. More...

p::id< hard::Memory * >	MEMORY_OBJECT
	Passed to manager::load() to set the memory configuration. More...

p::id< elm::sys::Path >	MEMORY_PATH
	Passed to Manager::load() to give the path of the file describing the memory. More...

Identifier< int >	MIN_ITERATION
	Put on the first instruction of a loop, it gives the minimal number of iterations. More...

Identifier< ilp::Var * >	MISS_VAR
	Property giving the variable counting the number of misses. More...

p::feature	MKFF_PRESERVATION_FEATURE
	This feature ensures that preservation information used by mkff is put on instruction. More...

Identifier< bool >	NEVER_TAKEN

Identifier< bool >	NO_CALL
	Put on the first instruction of a function that must be no called. More...

Identifier< bool >	NO_INLINE
	Put on the first instruction of a function to indicate whether it should be inlined or not during virtualization. More...

AbstractMaker *	no_maker = &no_inst
	Special maker for "no processor available". More...

Identifier< bool >	NO_RETURN
	This annotation is put on the first instruction of functions that does not never return. More...

p::id< string >	NO_RETURN_FUNCTION
	this property may be used to pass information about the non-returning behaviour of some functions. More...

p::id< bool >	NO_STACK
	This property shows that no stack need to be allocated. More...

p::id< bool >	NO_SYSTEM
	This property shows that the system does not need to by simulated when the binary image is built. More...

p::feature	NORMALIZED_CFGS_FEATURE
	This feature ensures that the CFG are in a normalized form: fully resolved branches, no entering or exiting edges to or from external CFGs. More...

const category_t	NOT_CLASSIFIED = otawa::cache::NOT_CLASSIFIED

Feature< NoProcessor >	NULL_FEATURE ("otawa::NULL")
	Not a real feature, just a marker. More...

AbstractMaker *	null_maker = &null_inst
	Special maker for a null processor. More...

NullStream	null_stream

p::id< elm::io::OutStream * >	OUTPUT
	This property identifier is used for setting the output stream used by the processor to write results. More...

Identifier< ContextTree * >	OWNER_CONTEXT_TREE
	Annotations with this identifier are hooked to basic blocks and gives the owner context tree (ContextTree * data). More...

p::feature	PCG_FEATURE
	This feature ensure that a PCG is provided. More...

Identifier< PostDomInfo * >	PDOM_INFO ("otawa::PDOM_INFO", 0)
	Provide post-domination information. More...

p::id< int >	PIPELINE_DEPTH
	This property is a hint to have an estimation of the pipeline depth. More...

p::id< hard::Platform * >	PLATFORM
	Identifier of the property indicating a platform (Platform *) to use. More...

p::id< hard::Platform::Identification * >	PLATFORM_IDENTFIER ("otawa::PLATFORM_IDENTFIER", 0)
	Identifier of the property indicating the identifier (PlatformId) of the loader to use. More...

p::id< string >	PLATFORM_NAME
	Identifier of the property indicating the name (CString) of the platform to use. More...

p::interfaced_feature< PostDomInfo >	POSTDOMINANCE_FEATURE
	This feature ensures that information about postdomination between nodes of a CFG is vailable. More...

p::id< Event * >	PREFIX_EVENT
	Allows to hook an event to an edge and consider it as part of the prefix of the edge time. More...

Identifier< bool >	PRESERVED
	Put on instruction that must preserved from the mkff special flow-fact detection. More...

Identifier< int >	PROCESSED_CFG
	This property is used to store statistics about the count of processed CFG. More...

p::id< hard::Processor * >	PROCESSOR
	Gives the processor to use in the current computation. More...

p::id< elm::xom::Element * >	PROCESSOR_ELEMENT
	XML element containing the configuration of the processor. More...

p::id< elm::sys::Path >	PROCESSOR_PATH
	Path to the XML configuration file of the processor. More...

p::id< PCG * >	PROGRAM_CALL_GRAPH
	Property providing the PCG (Program Call Graph). More...

Identifier< PSTree * >	PROGRAM_STRUCTURE_TREE ("otawa::PROGRAM_STRUCTURE_TREE", 0)
	This property points to the Program Structure Tree of the CFG. More...

Identifier< dfa::State * >	PROVIDED_STATE
	Associate a program point with a provided dfa::State. More...

Identifier< bool >	PSEUDO_UNROLLING
	This property represents the "persistence" Abstract Cache State of a basic block. More...

p::feature	PST_FEATURE ("otawa::PST_FEATURE", new Maker< PSTBuilder >())
	This feature represents the availability of the Program Structure Tree. More...

p::id< bool >	RECURSE_BACK
	This property marks PCG edges and synthetic block corresponding to calls backing inside a recursivity nest. More...

p::id< bool >	RECURSE_ENTRY
	This property marks PCG edges and synthetic block corresponding to calls entering a recursivity nest. More...

p::id< PCGBlock * >	RECURSE_HEAD
	This properties marks CFG and PCGNode corresponding to head of recursivity nests. More...

p::id< bool >	RECURSIVE
	Activate the recucursive feature of BBProcessors : each time a basic block contains a function call, the CFG of this function is recorded to be processed later after the current CFG. More...

Identifier< bool >	RECURSIVE_LOOP ("otawa::RECURSIVE_LOOP", false)
	A property with this identifier is hooked to edge performing a recursive call when inlining is used. More...

p::feature	RECURSIVITY_ANALYSIS
	This features ensures that recursive function calls has been identified in the PCG. More...

p::feature	REDUCED_LOOPS_FEATURE
	Ensure that no more irregular loop remains in the program representation. More...

p::feature	REGISTER_USAGE_FEATURE
	This feature is usually asserted by processes that provides access to the register usage information. More...

view::PropertyType &	REGISTERS_PROPERTY

Identifier< const dfa::BitSet * >	REVERSE_DOM
	Identifier of annotation containing reverse-dominance information. More...

Identifier< BitSet * >	REVERSE_POSTDOM ("otawa::REVERSE_POSTDOM", 0)
	Identifier of annotation containing reverse-post-dominance information. More...

p::feature	SEMANTICS_INFO
	This feature is present when the loader provides implementation of semantics information. More...

p::feature	SEMANTICS_INFO_EXTENDED
	This feature is present when the loader provides implementation of extended semantics information. More...

p::feature	SEMANTICS_INFO_FLOAT
	This feature is present when the loader provides implementation of floating-point semantic instructions. More...

p::id< sim::Simulator * >	SIMULATOR
	This property defines the used the used simulator when a simulator is needed to perform simulation. More...

p::id< elm::string >	SIMULATOR_NAME
	Name of the simulator to use. More...

p::feature	SOURCE_LINE_FEATURE
	This feature asserts that a table matching program address and source (file, lines) is available. More...

Identifier< Address >	SP_ADDRESS
	This feature is put on the process to get information about the built image. More...

p::feature	SPLIT_CFG
	This feature ensure that a part of the current has been extracted as a sub-CFG based on address provided by two properties: More...

p::feature	STACK_ANALYSIS_FEATURE
	This features ensure that the stack analysis has been identified. More...

p::feature	STANDARD_EVENT_FEATURE

otawa::NullInst	static_null

Identifier< Symbol * >	SYMBOL
	This property carries the symbol attached to an instruction. More...

p::id< Address >	TASK_ADDRESS
	This property, passed to the load configuration, select the task entry by its address. More...

p::id< string >	TASK_ENTRY
	This property, passed to the load configuration, gives the name of the entry function of the current task. More...

Identifier< int >	TIME
	This identifier is used for storing the time of execution in cycles (int) of the program area it applies to. More...

Identifier< int >	TO_DELAY ("", 0)

Identifier< int >	TOTAL_ITERATION
	Put on the first instruction of a loop, it gives the total number of iterations during the whole execution of the program. More...

p::id< bool >	UNROLL_THIS
	This property is used by UNROLLED_LOOPS_FEATURE and has to be put on header blocks of loops to select if the corresponding loop has to be unrolled or not. More...

Identifier< Block * >	UNROLLED_FROM
	Put on the header ex-header of a loop, this property gives the BB of the unrolled loop. More...

p::feature	UNROLLED_LOOPS_FEATURE
	This feature that the loops have been unrolled at least once. More...

p::id< bool >	VERBOSE
	This property activates the verbose mode of the processor: information about the processor work will be displayed. More...

cstring	VERBOSE_ENV = "OTAWA_VERBOSE"

Identifier< bool >	VIRTUAL_DEFAULT
	Configuration property of Virtualizer: it set the default behavior for inlining of function call during virtualization (default to true). More...

p::feature	VIRTUAL_INST_FEATURE
	Ensure that a virtual instruction manager is available to create virtual instructions. More...

p::id< VirtualInstManager * >	VIRTUAL_INST_MANAGER
	Get the current virtual instruction manager. More...

p::feature	VIRTUALIZED_CFG_FEATURE
	This features only show that the CFG has been virtualized. More...

p::feature	VLIW_SUPPORTED
	This feature is provided on Process objects by architecture implementing VLIW facilities. More...

Identifier< int >	WEIGHT
	Get the maximum weight for the basic block it is hooked to. More...

p::feature	WEIGHT_FEATURE
	This feature ensures that weight information has been hooked to any BB of the CFG. More...

Detailed Description

Development Note Letting the ToDo / ToDoList class visible in the header is clumsy.

We should a find a way to remove it from header as it is mainly a linked list of ToDo objects.

Star12X class declarations This file is part of OTAWA

OTAWA is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.

OTAWA is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with Foobar; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA

Typedef Documentation

◆ action_t

typedef enum otawa::action_t otawa::action_t

◆ address_stat_t

typedef struct otawa::address_stat_t otawa::address_stat_t

◆ address_t

typedef Address otawa::address_t

◆ call_t

typedef struct otawa::call_t otawa::call_t

◆ category_t

typedef otawa::cache::category_t otawa::category_t

◆ CategoryStats

typedef cache::CategoryStats otawa::CategoryStats

◆ code_part_t

typedef enum otawa::code_part otawa::code_part_t

◆ default_handler_t

typedef struct otawa::default_handler_t otawa::default_handler_t

◆ delayed_t

typedef enum otawa::delayed_t otawa::delayed_t

◆ fmlevel_t

typedef enum otawa::fmlevel otawa::fmlevel_t

◆ LinkedBlockList

typedef SortedList<LBlock*, NumberOrder> otawa::LinkedBlockList

◆ location_t

typedef Pair<BasicBlock *, Inst *> otawa::location_t

◆ PSTree

typedef elm::Tree<SESERegion*> otawa::PSTree

◆ RegSet

typedef Vector<t::uint16> otawa::RegSet

◆ stack_t

typedef elm::Vector<Pair<Block *, Block::EdgeIter> > otawa::stack_t

Enumeration Type Documentation

◆ action_t

enum otawa::action_t

Enumerator
DO_NOTHING
DO_SWALLOW
DO_INSERT

◆ code_part

enum otawa::code_part

Enumerator
PROLOGUE
BLOCK
EPILOGUE
CODE_PARTS_NUMBER

◆ fmlevel

enum otawa::fmlevel

Enumerator
FML_INNER
FML_OUTER
FML_MULTI
FML_NONE

Function Documentation

◆ ADDRESS_ANALYSIS_FEATURE()

p::feature otawa::ADDRESS_ANALYSIS_FEATURE	(	"otawa::ADDRESS_ANALYSIS_FEATURE"	,
		new Maker< NoProcessor >	()
	)

This feature ensures that accessed memory information (class AccessedAddress) is provided for each basic block.

This feature is useful for any static analysis concerning the memory hierarchy (caches, flash memories with prefetch, etc).

Properties

ADDRESSES

Statistics

ADDRESS_STATS

Processors

No default.
AccessedAddressFromStack

◆ ADDRESS_STATS()

Identifier<address_stat_t *> otawa::ADDRESS_STATS	(	"otawa::ADDRESS_STATS"	,
		0
	)

This property provides statistics about ADDRESS_ANALYSIS_FEATURE.

◆ ADDRESSES()

Identifier<AccessedAddresses *> otawa::ADDRESSES	(	"otawa::ADDRESSES"	,
		0
	)

Provide the set of accesses to the memory for the current basic block.

Hooks

BasicBlock

Features

ADDRESS_ANALYSIS_FEATURE
ADDRESS_FROM_STACK_FEATURE

◆ CACHE_ACS_MAY()

Identifier<Vector<MAYProblem::Domain> > otawa::CACHE_ACS_MAY	(	"otawa::CACHE_ACS_MAY"	,
		NULL
	)

This property represents the "may" Abstract Cache State of a basic block.

The vector stores the abstract cache states corresponding to all cache lines.

Hooks

BasicBlock

◆ CACHE_ACS_MAY_ENTRY()

Identifier<Vector<MAYProblem::Domain> > otawa::CACHE_ACS_MAY_ENTRY	(	"otawa::CACHE_ACS_MAY_ENTRY"	,
		NULL
	)

This property allows us to set an entry may ACS.

Hooks

PropList

◆ CACHE_ACS_MUST()

Identifier<Vector<MUSTProblem::Domain> > otawa::CACHE_ACS_MUST	(	"otawa::CACHE_ACS_MUST"	,
		0
	)

This property represents the MUST Abstract Cache State of a basic block.

The vector stores the abstract cache states corresponding to all cache lines.

Hooks

BasicBlock

◆ CACHE_ACS_MUST_ENTRY()

Identifier<Vector<MUSTProblem::Domain> > otawa::CACHE_ACS_MUST_ENTRY	(	"otawa::CACHE_ACS_MUST_ENTRY"	,
		0
	)

This property allows to set an entry MUST ACS.

It must be set in the property list passed to the invocation of a code processor.

Hooks

PropList (code processor configuration)

◆ CACHE_ACS_PERS()

Identifier<Vector<PERSProblem::Domain> > otawa::CACHE_ACS_PERS	(	"otawa::CACHE_ACS_PERS"	,
		0
	)

This property represents the "persistence" Abstract Cache State of a basic block.

The vector stores the abstract cache states corresponding to all cache lines.

Hooks

BasicBlock

◆ CACHE_ACS_PERS_ENTRY()

Identifier<Vector<PERSProblem::Domain> > otawa::CACHE_ACS_PERS_ENTRY	(	"otawa::CACHE_ACS_PERS_ENTRY"	,
		0
	)

This property allows to set an entry PERS ACS.

It must be set in the property list passed to the invocation of a code processor.

Hooks

PropList (code processor configuration)

◆ CACHE_EDGE_ACS_MUST()

Identifier<Vector<MUSTProblem::Domain> > otawa::CACHE_EDGE_ACS_MUST	(	"otawa::cache_edge_acs_must"	,
		NULL
	)

This property represents the "must" Abstract Cache State of a basic block.

The vector stores the abstract cache states corresponding to all cache lines.

Hooks

BasicBlock

◆ CACHE_EDGE_ACS_PERS()

Identifier<Vector<PERSProblem::Domain> > otawa::CACHE_EDGE_ACS_PERS	(	"otawa::cache_edge_acs_pers"	,
		NULL
	)

This property represents the "persistence" Abstract Cache State of a basic block.

The vector stores the abstract cache states corresponding to all cache lines.

Hooks

BasicBlock

◆ CATEGORY_EDGE()

Identifier<Vector<category_t> *> otawa::CATEGORY_EDGE	(	"otawa::cactegory_edge"	,
		NULL
	)

◆ CATEGORY_EDGE_HEADER()

Identifier<Vector<BasicBlock> > otawa::CATEGORY_EDGE_HEADER	(	"otawa::category_edge_header"	,
		NULL
	)

◆ CONDITIONAL_RESTRUCTURED_FEATURE()

p::feature otawa::CONDITIONAL_RESTRUCTURED_FEATURE	(	"otawa::CONDITIONAL_RESTRUCTURED_FEATURE"	,
		p::make< ConditionalRestructurer >	()
	)

This feature ensures that the CFG is transformed to reflect the effects of conditional instructions.

Default implementation:

ConditionalRestructurer

◆ CONTEXT()

p::id<ContextualPath> otawa::CONTEXT ( "otawa::CONTEXT" )

Provide context for the referred object.

Hooks

CFG

◆ CONTEXT_TREE()

Identifier<ContextTree *> otawa::CONTEXT_TREE	(	"otawa::CONTEXT_TREE"	,
		0
	)

This property identifier provides a context tree hooked to a framework.

A null pointer is retrieved if the context tree is not computed.

Hooks

FrameWork

◆ CONTEXT_TREE_BY_CFG_FEATURE()

Feature<ContextTreeByCFGBuilder> otawa::CONTEXT_TREE_BY_CFG_FEATURE ( "otawa::CONTEXT_TREE_BY_CFG_FEATURE" )

Assert that a context tree has been built for each CFG involved in the current computation.

Properties

CONTEXT_TREE (hooked to the CFG).

◆ CONTEXT_TREE_FEATURE()

Feature<ContextTreeBuilder> otawa::CONTEXT_TREE_FEATURE ( "otawa::CONTEXT_TREE_FEATURE" )

This feature asserts that a context tree of the task is available in the framework.

Properties

CONTEXT_TREE (hooked to the FrameWork).

◆ CONTEXTUAL_LOOP_BOUND()

Identifier<ContextualLoopBound *> otawa::CONTEXTUAL_LOOP_BOUND	(	"otawa::CONTEXTUAL_LOOP_BOUND"	,
		0
	)

This property provides context-dependent loop bounds.

It is part of information given by FLOW_FACT_FEATURE.

Hooks

Inst

◆ DEAD_CODE_ANALYSIS_FEATURE()

Feature<DeadCodeAnalysis> otawa::DEAD_CODE_ANALYSIS_FEATURE ( "otawa::DEAD_CODE_ANALYSIS_FEATURE" )

◆ DECODED_TEXT()

Feature<TextDecoder> otawa::DECODED_TEXT ( "otawa::DECODED_TEXT" )

This feature ensures that text segment of the process has been decoded and, consequently, that instructions are available.

Provided properties

◆ DEF_BY()

Identifier<const AbstractFeature *> otawa::DEF_BY	(	"otawa::DEF_BY"	,
		0
	)

Identifier for identifier property providing ownerness of an identifier.

The arguments describes the feature owning the current

◆ DEFAULT_BRANCH_PENALTY()

Identifier<int> otawa::DEFAULT_BRANCH_PENALTY	(	"otawa::DEFAULT_BRANCH_PENALTY"	,
		2
	)

◆ defBy()

Property* otawa::defBy ( const AbstractFeature * feature )

inline

References DEF_BY, and make().

◆ ENCLOSING_LOOP_HEADER()

p::id<Block*> otawa::ENCLOSING_LOOP_HEADER	(	"otawa::ENCLOSING_LOOP_HEADER"	,
		0
	)

Defined for any BasicBlock that is part of a loop.

Contains the header of the loop immediately containing the block If the block is a loop header, then, the property contains the header of the parent loop.

Hooks

BasicBlock

◆ ENTER()

p::id<ContextualStep> otawa::ENTER ( "otawa::ENTER" )

Note the entry into a particular context provided by the property.

To put a context entry s onto an edge e, just do: ENTER(e).add(s);

Hooks

Edge

◆ escape()

string otawa::escape ( const string & s )

Escape special characters in the given string.

Parameters

s	String to escape characters for.

Returns: Escaped string.

References buf, elm::String::length(), and elm::StringBuffer::toString().

Referenced by otawa::Identifier< otawa::arm::Info * >::printFormatted().

◆ EXIST_PROVIDED_STATE()

Identifier<bool> otawa::EXIST_PROVIDED_STATE	(	"otawa::EXISTPROVIDED_STATE"	,
		false
	)

◆ EXTENDED_LOOP_FEATURE()

p::interfaced_feature<LoopManager *> otawa::EXTENDED_LOOP_FEATURE	(	"otawa::EXTENDED_LOOP_FEATURE"	,
		p::make< ExtendedLoopBuilder >	()
	)

This feature build Loop objects representing the hierarchy of loops and attach it to the CFG and its blocks.

The loop can be accessing using properties (described below) but an easier access is provided by Loop::of(), Loop::top() or by using LoopManager feature interface.

Properties

Loop::ID

Provided by:

ExtendedLoopBuilder (default)

◆ FIRSTMISS_LEVEL()

Identifier<fmlevel_t> otawa::FIRSTMISS_LEVEL	(	"otawa::FIRSTMISS_LEVEL"	,
		FML_MULTI
	)

Specify the loop-level-precision of the First Miss computation (inner, outer, multi-level)

◆ from_string() [1/14]

template<class T >

void otawa::from_string	(	const string &	s,
		T &	v
	)

Referenced by from_string(), and otawa::Identifier< otawa::arm::Info * >::fromString().

◆ from_string() [2/14]

template<>

void otawa::from_string	(	const string &	str,
		Address &	v
	)

References buf, and elm::str().

◆ from_string() [3/14]

template<class T >

void otawa::from_string	(	const string &	str,
		Bag< T > &	bag
	)

References from_string(), from_string_split(), Vector< string >::length(), elm::io::list(), and elm::str().

◆ from_string() [4/14]

template<>

void otawa::from_string	(	const string &	str,
		bool &	v
	)

References elm::str().

◆ from_string() [5/14]

template<>

void otawa::from_string	(	const string &	str,
		double &	v
	)

References elm::str().

◆ from_string() [6/14]

template<>

void otawa::from_string	(	const string &	str,
		int &	v
	)

References elm::str().

◆ from_string() [7/14]

template<>

void otawa::from_string	(	const string &	str,
		long &	v
	)

References elm::str().

◆ from_string() [8/14]

template<>

void otawa::from_string	(	const string &	str,
		long long &	v
	)

References elm::str().

◆ from_string() [9/14]

template<>

void otawa::from_string	(	const string &	str,
		string &	v
	)

References elm::str().

◆ from_string() [10/14]

template<>

void otawa::from_string	(	const string &	str,
		SymAddress *&	v
	)

References otawa::SymAddress::parse(), and elm::str().

◆ from_string() [11/14]

template<>

void otawa::from_string	(	const string &	str,
		sys::Path &	v
	)

References elm::str().

◆ from_string() [12/14]

template<>

void otawa::from_string	(	const string &	str,
		unsigned int &	v
	)

References elm::str().

◆ from_string() [13/14]

template<>

void otawa::from_string	(	const string &	str,
		unsigned long &	v
	)

References elm::str().

◆ from_string() [14/14]

template<>

void otawa::from_string	(	const string &	str,
		unsigned long long &	v
	)

References elm::str().

◆ from_string_split()

void otawa::from_string_split	(	const string &	str,
		Vector< string > &	items
	)

References Vector< string >::add(), elm::String::indexOf(), elm::str(), and elm::String::substring().

Referenced by from_string().

◆ GRAPHS_OUTPUT_DIRECTORY()

Identifier<String> otawa::GRAPHS_OUTPUT_DIRECTORY	(	"otawa::GRAPHS_OUTPUT_DIRECTORY"	,
		""
	)

◆ ICACHE_ACS_FEATURE()

p::feature otawa::ICACHE_ACS_FEATURE	(	"otawa::ICACHE_ACS_FEATURE"	,
		new Maker< ACSBuilder >	()
	)

This feature represents the availability of Abstract Cache State informations.

Configuration

CACHE_ACS_MUST_ENTRY

Properties

Processors

ACSBuilder (default)

◆ ICACHE_ACS_MAY_FEATURE()

p::feature otawa::ICACHE_ACS_MAY_FEATURE	(	"otawa::ICACHE_ACS_MAY_FEATURE"	,
		new Maker< ACSMayBuilder >	()
	)

This feature represents the availability of MAY Abstract Cache State informations.

Properties

CACHE_ACS

Processors

ACSMayBuilder

◆ ICACHE_CATEGORY2_FEATURE()

p::feature otawa::ICACHE_CATEGORY2_FEATURE	(	"otawa::ICACHE_CATEGORY2_FEATURE"	,
		new Maker< CAT2Builder >	()
	)

This feature ensures that the categories for instruction cache according to the following method has been computed:

C. Ballabriga, H. Cassé. Improving the First-Miss Computation in Set-Associative Instruction Caches. Euromicro Conference on Real-Time Systems (ECRTS 2008), IEEE, p. 341-350, 2008.

Properties

Processors

CAT2Builder (default)

◆ ICACHE_CONSTRAINT2_FEATURE()

p::feature otawa::ICACHE_CONSTRAINT2_FEATURE	(	"otawa::ICACHE_CONSTRAINT2_FEATURE"	,
		new Maker< CAT2ConstraintBuilder >	()
	)

Ensures that the constraints for cache analysis by categories 2 has been built and that the term of instruction cache has been added to the objective function.

Properties

MISS_VAR

Configuration

ICACHE_NO_OBJECTIVE

Processors

CAT2ConstraintBuilder

◆ ICACHE_EDGE_ACS_FEATURE()

Feature<EdgeACSBuilder> otawa::ICACHE_EDGE_ACS_FEATURE ( "otawa::ICACHE_EDGE_ACS_FEATURE" )

This feature represents the availability of Abstract Cache State informations.

Properties

CACHE_ACS

◆ ICACHE_EDGE_CATEGORY2_FEATURE()

Feature<EdgeCAT2Builder> otawa::ICACHE_EDGE_CATEGORY2_FEATURE ( "otawa::ICACHE_EDGE_CATEGORY2_FEATURE" )

◆ ICACHE_FIRSTLAST_FEATURE()

Feature<FirstLastBuilder> otawa::ICACHE_FIRSTLAST_FEATURE ( "otawa::ICACHE_FIRSTLAST_FEATURE" )

This feature represents the availability of the LAST_LBLOCK and LBLOCK_ISFIRST properties.

Properties

◆ ICACHE_ONLY_CONSTRAINT2_FEATURE()

p::feature otawa::ICACHE_ONLY_CONSTRAINT2_FEATURE	(	"otawa::ICACHE_ONLY_CONSTRAINT2_FEATURE"	,
		new Maker< CAT2OnlyConstraintBuilder >	()
	)

Ensures that the constraints for cache analysis by categories 2 has been built.

Properties

MISS_VAR

Configuration

ICACHE_NO_OBJECTIVE

Processors

CAT2ConstraintBuilder

◆ ICACHE_PENALTY()

Identifier<CachePenalty*> otawa::ICACHE_PENALTY	(	"otawa::CACHE_PENALTY"	,
		NULL
	)

◆ idDesc()

Property* otawa::idDesc ( cstring desc )

inline

References IDENTIFIER_DESC, and make().

◆ idLabel()

Property* otawa::idLabel ( cstring label )

inline

References IDENTIFIER_LABEL, and make().

◆ IN_EDGES()

Block::EdgeCollection otawa::IN_EDGES ( const Block * b )

inline

References otawa::graph::GenVertex< V, E >::outEdges().

◆ INFEASABLE_PATH_END()

Identifier< LockPtr<ListOfEndConflict> > otawa::INFEASABLE_PATH_END	(	"otawa::INFEASABLE_PATH_END"	,
		NULL
	)

◆ L1()

const Level otawa::L1 ( 1 )

◆ L2()

const Level otawa::L2 ( 2 )

◆ L3()

const Level otawa::L3 ( 3 )

◆ L4()

const Level otawa::L4 ( 4 )

◆ L5()

const Level otawa::L5 ( 5 )

◆ L6()

const Level otawa::L6 ( 6 )

◆ L7()

const Level otawa::L7 ( 7 )

◆ L8()

const Level otawa::L8 ( 8 )

◆ L9()

const Level otawa::L9 ( 9 )

◆ LABEL_FEATURE()

p::feature otawa::LABEL_FEATURE	(	"otawa::LABEL_FEATURE"	,
		new Maker< LabelSetter >	()
	)

This feature ensures that label or symbol information has been linked to the concerned instruction.

It is not mandatory for OTAWA work but improve the readability of error message or logs.

Properties

◆ LAST_LBLOCK()

Identifier<LBlock**> otawa::LAST_LBLOCK	(	"otawa::LAST_LBLOCK"	,
		NULL
	)

This property gives the ID of the last lblock of a BasicBlock, for each line.

Hooks

BasicBlock

◆ LBLOCK_ISFIRST()

Identifier<bool> otawa::LBLOCK_ISFIRST	(	"otawa::LBLOCK_ISFIRST"	,
		false
	)

This property tells if the lblock is the first of its BasicBlock (for its cache line) This information is useful, because if it's false, then, the lblock is always a miss.

Hooks

LBlock

◆ leastGreaterLog2()

ot::size otawa::leastGreaterLog2 ( ot::size x )

Compute the least greater logarithm of 2 for the given value.

Parameters

x	Value to get LGL2.

Returns: LGL2 of x.

References otawa::ilp::x().

◆ LEAVE()

p::id<int> otawa::LEAVE	(	"otawa::LEAVE"	,
		0
	)

Leave the number of context provided by the number of argument.

To mark the edge e as leaving a context, do: LEAVE(e)++;

Hooks

Edge

◆ LINKED_BLOCKS()

Identifier<Vector<LBlock> > otawa::LINKED_BLOCKS	(	"otawa::LINKED_BLOCKS"	,
		NULL
	)

!!TODO!!

◆ LOOP_HEADERS_FEATURE()

p::feature otawa::LOOP_HEADERS_FEATURE	(	"otawa::LOOP_HEADERS_FEATURE"	,
		new Maker< Dominance >	()
	)

This feature ensures that all loop header are marked with a LOOP_HEADER property, and the backedges are marked with a BACK_EDGE property.

Include: <otawa/cfg/features.h>

@Properties

LOOP_HEADER (BasicBlock).
BACK_EDGE (Edge).

◆ LOOP_INFO_FEATURE()

p::feature otawa::LOOP_INFO_FEATURE	(	"otawa::LOOP_INFO_FEATURE"	,
		new Maker< LoopInfoBuilder >	()
	)

This feature asserts that the loop info of the task is available in the framework.

Properties

◆ make() [1/3]

Property* otawa::make	(	const Identifier< cstring > &	id,
		const char *	v
	)

inline

References make().

◆ make() [2/3]

Property* otawa::make	(	const Identifier< string > &	id,
		const char *	v
	)

inline

References make().

◆ make() [3/3]

template<class T >

Property* otawa::make	(	const Identifier< T > &	id,
		const T &	v
	)

inline

Referenced by defBy(), otawa::dfa::FastState< PotentialValue, MyGC >::FastState(), otawa::hard::RegBank::Make::gen(), idDesc(), idLabel(), otawa::hard::RegBank::init(), make(), otawa::hard::RegBank::RegBank(), and otawa::hard::Register::Register().

◆ MISS_VAR()

Identifier<ilp::Var *> otawa::MISS_VAR	(	"otawa::MISS_VAR"	,
		0
	)

Property giving the variable counting the number of misses.

Hook

LBlock

Feature

ICACHE_CONSTRAINT2_FEATURE

◆ MKFF_PRESERVATION_FEATURE()

p::feature otawa::MKFF_PRESERVATION_FEATURE	(	"otawa::MKFF_PRESERVATION_FEATURE"	,
		new Maker< FlowFactLoader >	()
	)

This feature ensures that preservation information used by mkff is put on instruction.

Hooked Properties

PRESERVED

◆ move() [1/2]

template<class T >

Bag< T > otawa::move	(	int	c,
		T *	t
	)

Move the given array content to a bag. After this call, the builder of the array is no more in charge of freeing the corresponding memory. t must have allocated using a new!

Parameters

c	Count of items in t.
t	Array to put in the bag.

Returns: Built bag.

◆ move() [2/2]

template<class T >

Bag< T > otawa::move ( Vector< T > & v )

Move the given vector content to a bag, letting home empty.

Parameters

v	Vector to move.

Returns: Built bag.

◆ NEVER_TAKEN()

Identifier<bool> otawa::NEVER_TAKEN ( "otawa::NEVER_TAKEN" )

◆ NORMALIZED_CFGS_FEATURE()

p::feature otawa::NORMALIZED_CFGS_FEATURE	(	"otawa::NORMALIZED_CFGS_FEATURE"	,
		new Maker< CFGNormalizer >	()
	)

This feature ensures that the CFG are in a normalized form: fully resolved branches, no entering or exiting edges to or from external CFGs.

◆ operator<<() [1/45]

elm::io::Output & otawa::operator<<	(	elm::io::Output &	out,
		Address	addr
	)

References otawa::ot::address(), otawa::Address::isNull(), otawa::Address::offset(), and otawa::Address::page().

◆ operator<<() [2/45]

elm::io::Output& otawa::operator<<	(	elm::io::Output &	out,
		const AbstractIdentifier &	id
	)

inline

References elm::io::Output::print().

◆ operator<<() [3/45]

elm::io::Output& otawa::operator<<	(	elm::io::Output &	out,
		const AbstractIdentifier *	id
	)

inline

◆ operator<<() [4/45]

elm::io::Output& otawa::operator<<	(	elm::io::Output &	out,
		const Property *	prop
	)

inline

References otawa::Property::print().

◆ operator<<() [5/45]

elm::io::Output& otawa::operator<<	(	elm::io::Output &	out,
		const PropList &	props
	)

inline

References otawa::PropList::print().

◆ operator<<() [6/45]

elm::io::Output& otawa::operator<<	(	elm::io::Output &	out,
		const PropList *	props
	)

inline

References otawa::PropList::print().

◆ operator<<() [7/45]

io::Output & otawa::operator<<	(	elm::io::Output &	out,
		Inst *	inst
	)

◆ operator<<() [8/45]

elm::io::Output & otawa::operator<<	(	elm::io::Output &	out,
		Process *	proc
	)

References otawa::File::name(), and otawa::Process::program().

◆ operator<<() [9/45]

elm::io::Output & otawa::operator<<	(	elm::io::Output &	output,
		const MAYProblem::Domain &	dom
	)

References otawa::MAYProblem::Domain::print().

◆ operator<<() [10/45]

elm::io::Output & otawa::operator<<	(	elm::io::Output &	output,
		const MUSTPERS::Domain &	dom
	)

References otawa::MUSTPERS::Domain::print().

◆ operator<<() [11/45]

elm::io::Output & otawa::operator<<	(	elm::io::Output &	output,
		const MUSTProblem::Domain &	dom
	)

References otawa::MUSTProblem::Domain::print().

◆ operator<<() [12/45]

elm::io::Output& otawa::operator<<	(	elm::io::Output &	output,
		const PERSBranch::Domain &	dom
	)

References otawa::PERSBranch::Domain::print().

◆ operator<<() [13/45]

elm::io::Output & otawa::operator<<	(	elm::io::Output &	output,
		const PERSProblem::Domain &	dom
	)

References otawa::PERSProblem::Domain::print().

◆ operator<<() [14/45]

io::Output & otawa::operator<<	(	io::Output &	o,
		const hard::Bank::type_t &	t
	)

◆ operator<<() [15/45]

io::Output& otawa::operator<<	(	io::Output &	out,
		AccessedAddresses *	aa
	)

inline

References otawa::AccessedAddresses::print().

◆ operator<<() [16/45]

io::Output & otawa::operator<<	(	io::Output &	out,
		address_stat_t *	s
	)

References otawa::address_stat_t::abs, otawa::address_stat_t::all, cout, otawa::address_stat_t::sprel, and otawa::address_stat_t::total.

◆ operator<<() [17/45]

io::Output& otawa::operator<<	(	io::Output &	out,
		BasicBlock *	block
	)

inline

◆ operator<<() [18/45]

io::Output & otawa::operator<<	(	io::Output &	out,
		Block *	block
	)

References otawa::graph::Vertex::index(), otawa::Block::isBasic(), otawa::Block::isEntry(), otawa::Block::isExit(), otawa::Block::isPhony(), and otawa::Block::isVirtual().

◆ operator<<() [19/45]

io::Output & otawa::operator<<	(	io::Output &	out,
		CFG *	cfg
	)

Address CFG::address(void); Get the address of the first instruction of the CFG.

Returns: Return address of the first instruction.

◆ operator<<() [20/45]

io::Output& otawa::operator<<	(	io::Output &	out,
		const AccessedAddress *	addr
	)

inline

References otawa::AccessedAddress::print().

◆ operator<<() [21/45]

io::Output& otawa::operator<<	(	io::Output &	out,
		const AccessedAddresses *	aa
	)

inline

References otawa::AccessedAddresses::print().

◆ operator<<() [22/45]

io::Output& otawa::operator<<	(	io::Output &	out,
		const CFG::BlockIter &	i
	)

inline

◆ operator<<() [23/45]

io::Output & otawa::operator<<	(	io::Output &	out,
		const Condition &	c
	)

References otawa::Condition::cond(), otawa::Condition::EQ, otawa::Condition::GT, otawa::Condition::isEmpty(), otawa::Condition::isUnsigned(), otawa::Condition::LT, otawa::hard::Register::name(), and otawa::Condition::reg().

◆ operator<<() [24/45]

io::Output& otawa::operator<<	(	io::Output &	out,
		const ContextualPath &	path
	)

inline

◆ operator<<() [25/45]

template<class T >

io::Output& otawa::operator<<	(	io::Output &	out,
		const ContextualPath::Ref< T > &	r
	)

inline

References otawa::ContextualPath::Ref< T >::print().

◆ operator<<() [26/45]

io::Output& otawa::operator<<	(	io::Output &	out,
		const ContextualStep &	path
	)

inline

◆ operator<<() [27/45]

template<class T , class I >

io::Output& otawa::operator<<	(	io::Output &	out,
		const ImmutableRef< T, I > &	ref
	)

References ref().

◆ operator<<() [28/45]

io::Output & otawa::operator<<	(	io::Output &	out,
		const location_t &	loc
	)

References elm::Pair< class, class >::fst, and elm::Pair< class, class >::snd.

◆ operator<<() [29/45]

io::Output & otawa::operator<<	(	io::Output &	out,
		const Loop *	l
	)

References otawa::Loop::header().

◆ operator<<() [30/45]

io::Output & otawa::operator<<	(	io::Output &	out,
		const MemArea &	a
	)

References otawa::MemArea::address(), otawa::MemArea::isNull(), and otawa::MemArea::topAddress().

◆ operator<<() [31/45]

template<class T , class I >

io::Output& otawa::operator<<	(	io::Output &	out,
		const Ref< T, I > &	ref
	)

References ref().

◆ operator<<() [32/45]

io::Output& otawa::operator<<	(	io::Output &	out,
		const Type &	type
	)

inline

References otawa::Type::print(), and type().

◆ operator<<() [33/45]

io::Output & otawa::operator<<	(	io::Output &	out,
		Edge *	edge
	)

◆ operator<<() [34/45]

io::Output & otawa::operator<<	(	io::Output &	out,
		Event *	event
	)

◆ operator<<() [35/45]

io::Output & otawa::operator<<	(	io::Output &	out,
		Event::occurrence_t	occ
	)

◆ operator<<() [36/45]

io::Output & otawa::operator<<	(	io::Output &	out,
		Inst::Kind	kind
	)

References kind.

◆ operator<<() [37/45]

io::Output & otawa::operator<<	(	io::Output &	out,
		PCGBlock *	b
	)

◆ operator<<() [38/45]

io::Output & otawa::operator<<	(	io::Output &	out,
		PCGEdge *	b
	)

◆ operator<<() [39/45]

io::Output& otawa::operator<<	(	io::Output &	out,
		SymAddress *	addr
	)

inline

References otawa::SymAddress::print().

◆ operator<<() [40/45]

io::Output& otawa::operator<<	(	io::Output &	out,
		Symbol *	sym
	)

inline

References otawa::Symbol::print().

◆ operator<<() [41/45]

io::Output & otawa::operator<<	(	io::Output &	out,
		Symbol::kind_t	k
	)

References k().

◆ operator<<() [42/45]

io::Output& otawa::operator<<	(	io::Output &	out,
		SynthBlock *	block
	)

inline

◆ operator<<() [43/45]

otawa::Output & otawa::operator<<	(	otawa::Output &	out,
		const fmlevel_t &	fml
	)

References FML_INNER, FML_MULTI, FML_NONE, and FML_OUTER.

◆ operator<<() [44/45]

Output& otawa::operator<<	(	Output &	out,
		ContextTree *	ct
	)

inline

◆ operator<<() [45/45]

Trace& otawa::operator<<	(	Trace &	trace,
		const Level &	level
	)

inline

References otawa::Level::_level, and elm::trace().

◆ OUT_EDGES()

Block::EdgeCollection otawa::OUT_EDGES ( const Block * b )

inline

References otawa::graph::GenVertex< V, E >::outEdges().

◆ OWNER_CONTEXT_TREE()

Identifier<ContextTree *> otawa::OWNER_CONTEXT_TREE	(	"otawa::OWNER_CONTEXT_TREE"	,
		0
	)

Annotations with this identifier are hooked to basic blocks and gives the owner context tree (ContextTree * data).

Hooks

BasicBlock

Deprecated:: Not working without inlining.

◆ PIPELINE_DEPTH()

p::id<int> otawa::PIPELINE_DEPTH	(	"otawa::PIPELINE_DEPTH"	,
		-	1
	)

This property is a hint to have an estimation of the pipeline depth.

It is better to look to the processor configuration in the patform.

◆ PREDS()

Block::PredCollection otawa::PREDS ( const Block * b )

inline

References otawa::graph::GenVertex< V, E >::preds().

◆ PROCESSED_CFG()

Identifier<int> otawa::PROCESSED_CFG	(	"otawa::processed_cfg"	,
		0
	)

This property is used to store statistics about the count of processed CFG.

◆ PSEUDO_UNROLLING()

Identifier<bool> otawa::PSEUDO_UNROLLING	(	"otawa::PSEUDO_UNROLLING"	,
		false
	)

This property represents the "persistence" Abstract Cache State of a basic block.

The vector stores the abstract cache states corresponding to all cache lines.

Hooks

BasicBlock

◆ RECURSIVE()

p::id<bool> otawa::RECURSIVE	(	"otawa::recursive"	,
		true
	)

Activate the recucursive feature of BBProcessors : each time a basic block contains a function call, the CFG of this function is recorded to be processed later after the current CFG.

Note that each function is only processed once !

◆ REDUCED_LOOPS_FEATURE()

p::feature otawa::REDUCED_LOOPS_FEATURE	(	"otawa::REDUCED_LOOPS_FEATURE"	,
		p::make< LoopReductor >	()
	)

Ensure that no more irregular loop remains in the program representation.

◆ registration()

template<class T >

const AbstractRegistration& otawa::registration ( void )

inline

◆ REVERSE_DOM()

Identifier<const BitSet *> otawa::REVERSE_DOM	(	"otawa::REVERSE_DOM"	,
		0
	)

Identifier of annotation containing reverse-dominance information.

Hooks

BasicBlock

◆ sign()

char otawa::sign ( t::int32 v )

inline

Referenced by otawa::ilp::System::dumpCPlex(), and otawa::ilp::System::dumpMOSEK().

◆ SUCCS()

Block::SuccCollection otawa::SUCCS ( const Block * b )

inline

References otawa::graph::GenVertex< V, E >::succs().

◆ type()

◆ UNROLL_THIS()

p::id<bool> otawa::UNROLL_THIS	(	"otawa::UNROLL_THIS"	,
		true
	)

This property is used by UNROLLED_LOOPS_FEATURE and has to be put on header blocks of loops to select if the corresponding loop has to be unrolled or not.

Its default value is true to unroll all loops.

Feature

UNROLLED_LOOPS_FEATURE

◆ VIRTUAL_DEFAULT()

Identifier<bool> otawa::VIRTUAL_DEFAULT	(	"otawa::VIRTUAL_DEFAULT"	,
		true
	)

Configuration property of Virtualizer: it set the default behavior for inlining of function call during virtualization (default to true).

The default behavior can be overridden by NO_INLINE

Hooks

Configuration of Virtualizer code processor.

◆ VIRTUAL_INST_FEATURE()

p::feature otawa::VIRTUAL_INST_FEATURE	(	"otawa::VIRTUAL_INST_FEATURE"	,
		p::make< VirtualInstBuilder >	()
	)

Ensure that a virtual instruction manager is available to create virtual instructions.

See also: VirtualInst, VirtualInstManager

Properties

VIRTUAL_INST_MANAGER

◆ VIRTUAL_INST_MANAGER()

p::id<VirtualInstManager *> otawa::VIRTUAL_INST_MANAGER	(	"otawa::VIRTUAL_INST_MANAGER"	,
		0
	)

Get the current virtual instruction manager.

Provided by:

VIRTUAL_INST_FEATURE

Hooked to:

WorkSpace

◆ VIRTUALIZED_CFG_FEATURE()

p::feature otawa::VIRTUALIZED_CFG_FEATURE	(	"otawa::VIRTUALIZED_CFG_FEATURE"	,
		new Maker< Virtualizer >	()
	)

This features only show that the CFG has been virtualized.

This may implies a lot of transformation like function call inlining or loop unrolling.

Header: <otawa/cfg/features.h>

Configuration

Properties

RECURSIVE_LOOP

◆ WEIGHT()

Identifier<int> otawa::WEIGHT	(	"otawa::WEIGHT"	,
		0
	)

Get the maximum weight for the basic block it is hooked to.

Feature

otawa::WEIGHT_FEATURE

Hooks

BasicBlock

◆ WEIGHT_FEATURE()

p::feature otawa::WEIGHT_FEATURE	(	"otawa::WEIGHT_FEATURE"	,
		new Maker< Weighter >	()
	)

This feature ensures that weight information has been hooked to any BB of the CFG.

Weight information is coarse-grain estimation of the number of execution of a basic block. It is simply derived from the maximum and total number of iterations of each loop.

Header: #include <otawa/cfg/features.h>

Properties

WEIGHT

Variable Documentation

◆ _base_displays

elm::CString otawa::_base_displays[]

Initial value:

= {
        "void",
        "block",
        "bool",
        "char",
        "int8",
        "uint8",
        "int16",
        "uint16",
        "int32",
        "uint32",
        "int64",
        "uint64",
        "float32",
        "float64",
        "float128",
        "addr32",
        "cstring",
        "string"
}

Referenced by otawa::BaseType::print().

◆ ADDRESS_ANALYSIS_FEATURE

p::feature otawa::ADDRESS_ANALYSIS_FEATURE("otawa::ADDRESS_ANALYSIS_FEATURE", new Maker< NoProcessor >())

This feature ensures that accessed memory information (class AccessedAddress) is provided for each basic block.

This feature is useful for any static analysis concerning the memory hierarchy (caches, flash memories with prefetch, etc).

Properties

ADDRESSES

Statistics

ADDRESS_STATS

Processors

No default.
AccessedAddressFromStack

◆ ADDRESS_STATS

Identifier<address_stat_t *> otawa::ADDRESS_STATS("otawa::ADDRESS_STATS", 0)

This property provides statistics about ADDRESS_ANALYSIS_FEATURE.

◆ ADDRESSES

Identifier<AccessedAddresses *> otawa::ADDRESSES("otawa::ADDRESSES", 0)

Provide the set of accesses to the memory for the current basic block.

Hooks

BasicBlock

Features

ADDRESS_ANALYSIS_FEATURE
ADDRESS_FROM_STACK_FEATURE

◆ ALWAYS_HIT

const category_t otawa::ALWAYS_HIT = otawa::cache::ALWAYS_HIT

Referenced by otawa::EdgeCAT2ConstraintBuilder::processWorkSpace().

◆ ALWAYS_MISS

const category_t otawa::ALWAYS_MISS = otawa::cache::ALWAYS_MISS

Referenced by otawa::GraphBBTime< ParExeGraph >::computeDefaultTimingContextForICache(), and otawa::EdgeCAT2ConstraintBuilder::processWorkSpace().

◆ ASSEMBLY_VIEW

view::View& otawa::ASSEMBLY_VIEW

◆ CACHE_ACS_MAY

Identifier<Vector<MAYProblem::Domain*>* > otawa::CACHE_ACS_MAY("otawa::CACHE_ACS_MAY", NULL)

This property represents the "may" Abstract Cache State of a basic block.

The vector stores the abstract cache states corresponding to all cache lines.

Hooks

BasicBlock

◆ CACHE_ACS_MAY_ENTRY

Identifier<Vector<MAYProblem::Domain*>* > otawa::CACHE_ACS_MAY_ENTRY("otawa::CACHE_ACS_MAY_ENTRY", NULL)

This property allows us to set an entry may ACS.

Hooks

PropList

Referenced by otawa::ACSMayBuilder::configure().

◆ CACHE_ACS_MUST

Identifier<Vector<MUSTProblem::Domain*>* > otawa::CACHE_ACS_MUST("otawa::CACHE_ACS_MUST", 0)

This property represents the MUST Abstract Cache State of a basic block.

The vector stores the abstract cache states corresponding to all cache lines.

Hooks

BasicBlock

◆ CACHE_ACS_MUST_ENTRY

Identifier< Vector< MUSTProblem::Domain * > * > otawa::CACHE_ACS_MUST_ENTRY

This property allows to set an entry MUST ACS.

It must be set in the property list passed to the invocation of a code processor.

Hooks

PropList (code processor configuration)

Referenced by otawa::ACSBuilder::configure(), and otawa::EdgeACSBuilder::configure().

◆ CACHE_ACS_PERS

Identifier<Vector<PERSProblem::Domain*>* > otawa::CACHE_ACS_PERS("otawa::CACHE_ACS_PERS", 0)

This property represents the "persistence" Abstract Cache State of a basic block.

The vector stores the abstract cache states corresponding to all cache lines.

Hooks

BasicBlock

Referenced by otawa::ACSBuilder::configure().

◆ CACHE_ACS_PERS_ENTRY

Identifier<Vector<PERSProblem::Domain*>* > otawa::CACHE_ACS_PERS_ENTRY("otawa::CACHE_ACS_PERS_ENTRY", 0)

This property allows to set an entry PERS ACS.

It must be set in the property list passed to the invocation of a code processor.

Hooks

PropList (code processor configuration)

◆ CACHE_EDGE_ACS_MUST

Identifier<Vector<MUSTProblem::Domain*> *> otawa::CACHE_EDGE_ACS_MUST("otawa::cache_edge_acs_must", NULL)

This property represents the "must" Abstract Cache State of a basic block.

The vector stores the abstract cache states corresponding to all cache lines.

Hooks

BasicBlock

◆ CACHE_EDGE_ACS_PERS

Identifier<Vector<PERSProblem::Domain*> *> otawa::CACHE_EDGE_ACS_PERS("otawa::cache_edge_acs_pers", NULL)

This property represents the "persistence" Abstract Cache State of a basic block.

The vector stores the abstract cache states corresponding to all cache lines.

Hooks

BasicBlock

◆ CATEGORY_EDGE

Identifier<Vector<category_t> *> otawa::CATEGORY_EDGE("otawa::cactegory_edge", NULL)

Referenced by otawa::EdgeCAT2ConstraintBuilder::processWorkSpace().

◆ CATEGORY_EDGE_HEADER

Identifier<Vector<BasicBlock*> *> otawa::CATEGORY_EDGE_HEADER("otawa::category_edge_header", NULL)

Referenced by otawa::EdgeCAT2ConstraintBuilder::processWorkSpace().

◆ CATEGORY_HEADER

Identifier< Block * > & otawa::CATEGORY_HEADER = cache::CATEGORY_HEADER

Referenced by otawa::dcache::CATBuilder::join().

◆ CATEGORY_STATS

Identifier< cache::CategoryStats * > & otawa::CATEGORY_STATS = cache::CATEGORY_STATS

◆ CFG_IO_PATH

Identifier<sys::Path> otawa::CFG_IO_PATH

◆ CONDITIONAL_RESTRUCTURED_FEATURE

p::feature otawa::CONDITIONAL_RESTRUCTURED_FEATURE("otawa::CONDITIONAL_RESTRUCTURED_FEATURE", p::make< ConditionalRestructurer >())

This feature ensures that the CFG is transformed to reflect the effects of conditional instructions.

Default implementation:

ConditionalRestructurer

◆ CONTEXT

p::id<ContextualPath> otawa::CONTEXT("otawa::CONTEXT")

Provide context for the referred object.

Hooks

CFG

Referenced by otawa::CFGTransformer::transform().

◆ CONTEXT_TREE

Identifier<ContextTree *> otawa::CONTEXT_TREE("otawa::CONTEXT_TREE", 0)

This property identifier provides a context tree hooked to a framework.

A null pointer is retrieved if the context tree is not computed.

Hooks

FrameWork

Referenced by otawa::cat::CATConstraintBuilder::processLBlockSet(), and otawa::ContextTreeBuilder::processWorkSpace().

◆ CONTEXT_TREE_BY_CFG_FEATURE

Feature<ContextTreeByCFGBuilder> otawa::CONTEXT_TREE_BY_CFG_FEATURE("otawa::CONTEXT_TREE_BY_CFG_FEATURE")

Assert that a context tree has been built for each CFG involved in the current computation.

Properties

CONTEXT_TREE (hooked to the CFG).

Referenced by otawa::ContextTreeByCFGBuilder::ContextTreeByCFGBuilder().

◆ CONTEXT_TREE_FEATURE

Feature<ContextTreeBuilder> otawa::CONTEXT_TREE_FEATURE("otawa::CONTEXT_TREE_FEATURE")

This feature asserts that a context tree of the task is available in the framework.

Properties

CONTEXT_TREE (hooked to the FrameWork).

Referenced by otawa::ContextTreeBuilder::ContextTreeBuilder(), and otawa::ContextTreeBuilder::processWorkSpace().

◆ CONTEXTUAL_LOOP_BOUND

Identifier<ContextualLoopBound *> otawa::CONTEXTUAL_LOOP_BOUND("otawa::CONTEXTUAL_LOOP_BOUND", 0)

This property provides context-dependent loop bounds.

It is part of information given by FLOW_FACT_FEATURE.

Hooks

Inst

◆ DEAD_CODE_ANALYSIS_FEATURE

Feature<DeadCodeAnalysis> otawa::DEAD_CODE_ANALYSIS_FEATURE("otawa::DEAD_CODE_ANALYSIS_FEATURE")

Referenced by otawa::DeadCodeAnalysis::DeadCodeAnalysis().

◆ DECODED_TEXT

Feature<TextDecoder> otawa::DECODED_TEXT("otawa::DECODED_TEXT")

This feature ensures that text segment of the process has been decoded and, consequently, that instructions are available.

Provided properties

Referenced by otawa::TextDecoder::TextDecoder(), and otawa::VarTextDecoder::VarTextDecoder().

◆ DEF_BY

Identifier<const AbstractFeature *> otawa::DEF_BY("otawa::DEF_BY", 0)

Identifier for identifier property providing ownerness of an identifier.

The arguments describes the feature owning the current

Referenced by defBy().

◆ DEFAULT_BRANCH_PENALTY

Identifier<int> otawa::DEFAULT_BRANCH_PENALTY("otawa::DEFAULT_BRANCH_PENALTY", 2)

Referenced by otawa::ParExeGraph::ParExeGraph().

◆ ENCLOSING_LOOP_HEADER

p::id<Block*> otawa::ENCLOSING_LOOP_HEADER("otawa::ENCLOSING_LOOP_HEADER", 0)

Defined for any BasicBlock that is part of a loop.

Contains the header of the loop immediately containing the block If the block is a loop header, then, the property contains the header of the parent loop.

Hooks

BasicBlock

Referenced by otawa::ai::PseudoTopoOrder::_topoNodeHelper(), otawa::ipet::EdgeInfoConflict::getLoopHeaderList(), otawa::Loop::Loop(), otawa::LoopIter::next(), and otawa::Loop::of().

◆ ENTER

p::id<ContextualStep> otawa::ENTER("otawa::ENTER")

Note the entry into a particular context provided by the property.

To put a context entry s onto an edge e, just do: ENTER(e).add(s);

Hooks

Edge

◆ EXIST_PROVIDED_STATE

Identifier<bool> otawa::EXIST_PROVIDED_STATE("otawa::EXISTPROVIDED_STATE", false)

◆ EXTENDED_LOOP_FEATURE

p::interfaced_feature<LoopManager *> otawa::EXTENDED_LOOP_FEATURE("otawa::EXTENDED_LOOP_FEATURE", p::make< ExtendedLoopBuilder >())

This feature build Loop objects representing the hierarchy of loops and attach it to the CFG and its blocks.

The loop can be accessing using properties (described below) but an easier access is provided by Loop::of(), Loop::top() or by using LoopManager feature interface.

Properties

Loop::ID

Provided by:

ExtendedLoopBuilder (default)

◆ fft_line

int otawa::fft_line = 0

Referenced by otawa::FlowFactLoader::onError(), and otawa::FlowFactLoader::onWarning().

◆ FIRST_HIT

const category_t otawa::FIRST_HIT = otawa::cache::FIRST_HIT

Referenced by otawa::EdgeCAT2ConstraintBuilder::processWorkSpace().

◆ FIRST_MISS

const category_t otawa::FIRST_MISS = otawa::cache::FIRST_MISS

Referenced by otawa::GraphBBTime< ParExeGraph >::buildFMTimingContextListForICache(), and otawa::EdgeCAT2ConstraintBuilder::processWorkSpace().

◆ FIRSTMISS_LEVEL

Identifier< fmlevel_t > otawa::FIRSTMISS_LEVEL

Specify the loop-level-precision of the First Miss computation (inner, outer, multi-level)

Referenced by otawa::ACSBuilder::configure(), otawa::CAT2Builder::configure(), otawa::EdgeCAT2Builder::configure(), otawa::EdgeACSBuilder::configure(), otawa::ACSBuilder::processWorkSpace(), and otawa::EdgeACSBuilder::processWorkSpace().

◆ FROM_BB

Identifier<BasicBlock*> otawa::FROM_BB("otawa::FROM_BB", 0)

When we get the VirtualCFG associated with a SESE region, this property, hooked on a BB from the Virtual CFG, gives the corresponding BB on the original (physical) CFG.

Hooks

BasicBlock

◆ FROM_EDGE

Identifier<Edge*> otawa::FROM_EDGE("otawa::FROM_EDGE", 0)

This property is like.

otawa::FROM_BB but for edges

◆ GRAPHS_OUTPUT_DIRECTORY

Identifier< String > otawa::GRAPHS_OUTPUT_DIRECTORY

Referenced by otawa::etime::AbstractTimeBuilder::configure(), and otawa::GraphBBTime< ParExeGraph >::configure().

◆ ICACHE_ACS_FEATURE

p::feature otawa::ICACHE_ACS_FEATURE("otawa::ICACHE_ACS_FEATURE", new Maker< ACSBuilder >())

This feature represents the availability of Abstract Cache State informations.

Configuration

CACHE_ACS_MUST_ENTRY

Properties

Processors

ACSBuilder (default)

◆ ICACHE_ACS_MAY_FEATURE

p::feature otawa::ICACHE_ACS_MAY_FEATURE("otawa::ICACHE_ACS_MAY_FEATURE", new Maker< ACSMayBuilder >())

This feature represents the availability of MAY Abstract Cache State informations.

Properties

CACHE_ACS

Processors

ACSMayBuilder

◆ ICACHE_CATEGORY2_FEATURE

p::feature otawa::ICACHE_CATEGORY2_FEATURE("otawa::ICACHE_CATEGORY2_FEATURE", new Maker< CAT2Builder >())

This feature ensures that the categories for instruction cache according to the following method has been computed:

C. Ballabriga, H. Cassé. Improving the First-Miss Computation in Set-Associative Instruction Caches. Euromicro Conference on Real-Time Systems (ECRTS 2008), IEEE, p. 341-350, 2008.

Properties

Processors

CAT2Builder (default)

Referenced by otawa::LinkedBlocksDetector::LinkedBlocksDetector().

◆ ICACHE_CONSTRAINT2_FEATURE

p::feature otawa::ICACHE_CONSTRAINT2_FEATURE("otawa::ICACHE_CONSTRAINT2_FEATURE", new Maker< CAT2ConstraintBuilder >())

Ensures that the constraints for cache analysis by categories 2 has been built and that the term of instruction cache has been added to the objective function.

Properties

MISS_VAR

Configuration

ICACHE_NO_OBJECTIVE

Processors

CAT2ConstraintBuilder

◆ ICACHE_EDGE_ACS_FEATURE

Feature<EdgeACSBuilder> otawa::ICACHE_EDGE_ACS_FEATURE("otawa::ICACHE_EDGE_ACS_FEATURE")

This feature represents the availability of Abstract Cache State informations.

Properties

CACHE_ACS

Referenced by otawa::EdgeACSBuilder::EdgeACSBuilder(), and otawa::EdgeCAT2Builder::EdgeCAT2Builder().

◆ ICACHE_EDGE_CATEGORY2_FEATURE

Feature<EdgeCAT2Builder> otawa::ICACHE_EDGE_CATEGORY2_FEATURE("otawa::ICACHE_EDGE_CATEGORY2_FEATURE")

Referenced by otawa::EdgeCAT2Builder::EdgeCAT2Builder(), and otawa::EdgeCAT2ConstraintBuilder::EdgeCAT2ConstraintBuilder().

◆ ICACHE_FIRSTLAST_FEATURE

Feature<FirstLastBuilder> otawa::ICACHE_FIRSTLAST_FEATURE("otawa::ICACHE_FIRSTLAST_FEATURE")

This feature represents the availability of the LAST_LBLOCK and LBLOCK_ISFIRST properties.

Properties

Referenced by otawa::EdgeACSBuilder::EdgeACSBuilder(), otawa::EdgeCAT2Builder::EdgeCAT2Builder(), and otawa::FirstLastBuilder::FirstLastBuilder().

◆ ICACHE_ONLY_CONSTRAINT2_FEATURE

p::feature otawa::ICACHE_ONLY_CONSTRAINT2_FEATURE("otawa::ICACHE_ONLY_CONSTRAINT2_FEATURE", new Maker< CAT2OnlyConstraintBuilder >())

Ensures that the constraints for cache analysis by categories 2 has been built.

Properties

MISS_VAR

Configuration

ICACHE_NO_OBJECTIVE

Processors

CAT2ConstraintBuilder

Referenced by otawa::etime::StandardEventBuilder::setup().

◆ ICACHE_PENALTY

Identifier<CachePenalty*> otawa::ICACHE_PENALTY("otawa::CACHE_PENALTY", NULL)

◆ INFEASABLE_PATH_END

Identifier< LockPtr<ListOfEndConflict> > otawa::INFEASABLE_PATH_END("otawa::INFEASABLE_PATH_END", NULL)

◆ INVALID_CATEGORY

const category_t otawa::INVALID_CATEGORY = otawa::cache::INVALID_CATEGORY

Referenced by otawa::GraphBBTime< ParExeGraph >::buildFMTimingContextListForICache(), otawa::GraphBBTime< ParExeGraph >::buildNCTimingContextListForICache(), and otawa::GraphBBTime< ParExeGraph >::computeDefaultTimingContextForICache().

◆ IS_FEATURE

Identifier< bool > otawa::IS_FEATURE

Referenced by otawa::AbstractFeature::AbstractFeature(), otawa::ProcessorPlugin::getFeature(), and otawa::p::is_feature().

◆ L1

const Level otawa::L1(1)

◆ L2

const Level otawa::L2(2)

◆ L3

const Level otawa::L3(3)

◆ L4

const Level otawa::L4(4)

◆ L5

const Level otawa::L5(5)

◆ L6

const Level otawa::L6(6)

◆ L7

const Level otawa::L7(7)

◆ L8

const Level otawa::L8(8)

◆ L9

const Level otawa::L9(9)

◆ LABEL_FEATURE

p::feature otawa::LABEL_FEATURE("otawa::LABEL_FEATURE", new Maker< LabelSetter >())

This feature ensures that label or symbol information has been linked to the concerned instruction.

It is not mandatory for OTAWA work but improve the readability of error message or logs.

Properties

◆ LAST_LBLOCK

Identifier<LBlock**> otawa::LAST_LBLOCK("otawa::LAST_LBLOCK", NULL)

This property gives the ID of the last lblock of a BasicBlock, for each line.

Hooks

BasicBlock

◆ LBLOCK_ISFIRST

Identifier<bool> otawa::LBLOCK_ISFIRST("otawa::LBLOCK_ISFIRST", false)

This property tells if the lblock is the first of its BasicBlock (for its cache line) This information is useful, because if it's false, then, the lblock is always a miss.

Hooks

LBlock

◆ LEAVE

p::id<int> otawa::LEAVE("otawa::LEAVE", 0)

Leave the number of context provided by the number of argument.

To mark the edge e as leaving a context, do: LEAVE(e)++;

Hooks

Edge

◆ LINKED_BLOCKS

Identifier<Vector<LBlock*> *> otawa::LINKED_BLOCKS("otawa::LINKED_BLOCKS", NULL)

!!TODO!!

Referenced by otawa::CAT2OnlyConstraintBuilder::processWorkSpace(), and otawa::LinkedBlocksDetector::recordBlocks().

◆ LOOP_HEADERS_FEATURE

p::feature otawa::LOOP_HEADERS_FEATURE("otawa::LOOP_HEADERS_FEATURE", new Maker< Dominance >())

This feature ensures that all loop header are marked with a LOOP_HEADER property, and the backedges are marked with a BACK_EDGE property.

Include: <otawa/cfg/features.h>

@Properties

LOOP_HEADER (BasicBlock).
BACK_EDGE (Edge).

Referenced by otawa::ContextTreeBuilder::ContextTreeBuilder(), otawa::ContextTreeByCFGBuilder::ContextTreeByCFGBuilder(), otawa::EdgeACSBuilder::EdgeACSBuilder(), otawa::EdgeCAT2Builder::EdgeCAT2Builder(), and otawa::FirstLastBuilder::FirstLastBuilder().

◆ LOOP_INFO_FEATURE

p::feature otawa::LOOP_INFO_FEATURE("otawa::LOOP_INFO_FEATURE", new Maker< LoopInfoBuilder >())

This feature asserts that the loop info of the task is available in the framework.

Properties

Referenced by otawa::ContextTreeBuilder::ContextTreeBuilder(), otawa::ContextTreeByCFGBuilder::ContextTreeByCFGBuilder(), otawa::EdgeACSBuilder::EdgeACSBuilder(), otawa::EdgeCAT2Builder::EdgeCAT2Builder(), otawa::FirstLastBuilder::FirstLastBuilder(), and otawa::LinkedBlocksDetector::LinkedBlocksDetector().

◆ MANAGER

Manager & otawa::MANAGER = *Manager::def()

Default manager.

Avoid to declare one in the main.

Referenced by otawa::script::Script::declareGlobals(), otawa::ProcessorPlugin::init(), and otawa::Application::run().

◆ MISS_VAR

Identifier<ilp::Var *> otawa::MISS_VAR("otawa::MISS_VAR", 0)

Property giving the variable counting the number of misses.

Hook

LBlock

Feature

ICACHE_CONSTRAINT2_FEATURE

Referenced by otawa::CAT2OnlyConstraintBuilder::processWorkSpace(), and otawa::CAT2ConstraintBuilder::processWorkSpace().

◆ MKFF_PRESERVATION_FEATURE

p::feature otawa::MKFF_PRESERVATION_FEATURE("otawa::MKFF_PRESERVATION_FEATURE", new Maker< FlowFactLoader >())

This feature ensures that preservation information used by mkff is put on instruction.

Hooked Properties

PRESERVED

◆ NEVER_TAKEN

Identifier<bool> otawa::NEVER_TAKEN("otawa::NEVER_TAKEN")

◆ NORMALIZED_CFGS_FEATURE

p::feature otawa::NORMALIZED_CFGS_FEATURE

This feature ensures that the CFG are in a normalized form: fully resolved branches, no entering or exiting edges to or from external CFGs.

◆ NOT_CLASSIFIED

const category_t otawa::NOT_CLASSIFIED = otawa::cache::NOT_CLASSIFIED

Referenced by otawa::EdgeCAT2ConstraintBuilder::processWorkSpace().

◆ NULL_FEATURE

Feature<NoProcessor> otawa::NULL_FEATURE("otawa::NULL")

Not a real feature, just a marker.

◆ null_stream

NullStream otawa::null_stream

Referenced by otawa::Trace::checkLevel().

◆ OWNER_CONTEXT_TREE

Identifier<ContextTree *> otawa::OWNER_CONTEXT_TREE("otawa::OWNER_CONTEXT_TREE", 0)

Annotations with this identifier are hooked to basic blocks and gives the owner context tree (ContextTree * data).

Hooks

BasicBlock

Deprecated:: Not working without inlining.

◆ PDOM_INFO

Identifier<PostDomInfo *> otawa::PDOM_INFO("otawa::PDOM_INFO", 0)

Provide post-domination information.

Hooks

WorkSpace

Providing Features

POSTDOMINANCE_FEATURE

◆ PIPELINE_DEPTH

p::id<int> otawa::PIPELINE_DEPTH("otawa::PIPELINE_DEPTH", -1)

This property is a hint to have an estimation of the pipeline depth.

It is better to look to the processor configuration in the patform.

◆ PROCESSED_CFG

Identifier<int> otawa::PROCESSED_CFG("otawa::processed_cfg", 0)

This property is used to store statistics about the count of processed CFG.

Referenced by otawa::CFGProcessor::processWorkSpace().

◆ PROGRAM_STRUCTURE_TREE

Identifier<PSTree *> otawa::PROGRAM_STRUCTURE_TREE("otawa::PROGRAM_STRUCTURE_TREE", 0)

This property points to the Program Structure Tree of the CFG.

Hooks

CFG

◆ PSEUDO_UNROLLING

Identifier< bool > otawa::PSEUDO_UNROLLING

This property represents the "persistence" Abstract Cache State of a basic block.

The vector stores the abstract cache states corresponding to all cache lines.

Hooks

BasicBlock

Referenced by otawa::ACSMayBuilder::configure(), otawa::ACSBuilder::configure(), and otawa::EdgeACSBuilder::configure().

◆ PST_FEATURE

p::feature otawa::PST_FEATURE("otawa::PST_FEATURE", new Maker< PSTBuilder >())

This feature represents the availability of the Program Structure Tree.

Properties

otawa::PROGRAM_STRUCTURE_TREE

Referenced by otawa::PSTBuilder::PSTBuilder().

◆ RECURSIVE

p::id<bool> otawa::RECURSIVE("otawa::recursive", true)

Activate the recucursive feature of BBProcessors : each time a basic block contains a function call, the CFG of this function is recorded to be processed later after the current CFG.

Note that each function is only processed once !

Referenced by otawa::ipet::VarAssignment::configure().

◆ RECURSIVE_LOOP

Identifier<bool> otawa::RECURSIVE_LOOP("otawa::RECURSIVE_LOOP", false)

A property with this identifier is hooked to edge performing a recursive call when inlining is used.

Hooks

Edge

Features

VIRTUALIZED_CFG_FEATURE

◆ REDUCED_LOOPS_FEATURE

p::feature otawa::REDUCED_LOOPS_FEATURE("otawa::REDUCED_LOOPS_FEATURE", p::make< LoopReductor >())

Ensure that no more irregular loop remains in the program representation.

◆ REGISTERS_PROPERTY

view::PropertyType& otawa::REGISTERS_PROPERTY

◆ REVERSE_DOM

Identifier<const BitSet *> otawa::REVERSE_DOM("otawa::REVERSE_DOM", 0)

Identifier of annotation containing reverse-dominance information.

Hooks

BasicBlock

Referenced by otawa::Dominance::dom(), and otawa::Dominance::dominates().

◆ REVERSE_POSTDOM

Identifier<BitSet *> otawa::REVERSE_POSTDOM("otawa::REVERSE_POSTDOM", 0)

Identifier of annotation containing reverse-post-dominance information.

Hooks

BasicBlock

Referenced by otawa::PostDominance::destroyCFG(), and otawa::PostDominance::pdom().

◆ STANDARD_EVENT_FEATURE

p::feature otawa::STANDARD_EVENT_FEATURE

◆ static_null

otawa::NullInst otawa::static_null

◆ TO_DELAY

Identifier<int> otawa::TO_DELAY("", 0)

◆ UNROLL_THIS

p::id<bool> otawa::UNROLL_THIS("otawa::UNROLL_THIS", true)

This property is used by UNROLLED_LOOPS_FEATURE and has to be put on header blocks of loops to select if the corresponding loop has to be unrolled or not.

Its default value is true to unroll all loops.

Feature

UNROLLED_LOOPS_FEATURE

Referenced by otawa::LoopUnroller::unrolls().

◆ VERBOSE_ENV

cstring otawa::VERBOSE_ENV = "OTAWA_VERBOSE"

Referenced by otawa::Monitor::configure(), and otawa::Manager::setVerbosity().

◆ VIRTUAL_DEFAULT

Identifier<bool> otawa::VIRTUAL_DEFAULT("otawa::VIRTUAL_DEFAULT", true)

Configuration property of Virtualizer: it set the default behavior for inlining of function call during virtualization (default to true).

The default behavior can be overridden by NO_INLINE

Hooks

Configuration of Virtualizer code processor.

Referenced by otawa::Virtualizer::configure().

◆ VIRTUAL_INST_FEATURE

p::feature otawa::VIRTUAL_INST_FEATURE("otawa::VIRTUAL_INST_FEATURE", p::make< VirtualInstBuilder >())

Ensure that a virtual instruction manager is available to create virtual instructions.

See also: VirtualInst, VirtualInstManager

Properties

VIRTUAL_INST_MANAGER

◆ VIRTUAL_INST_MANAGER

p::id<VirtualInstManager *> otawa::VIRTUAL_INST_MANAGER("otawa::VIRTUAL_INST_MANAGER", 0)

Get the current virtual instruction manager.

Provided by:

VIRTUAL_INST_FEATURE

Hooked to:

WorkSpace

Referenced by otawa::VirtualInst::VirtualInst().

◆ VIRTUALIZED_CFG_FEATURE

p::feature otawa::VIRTUALIZED_CFG_FEATURE("otawa::VIRTUALIZED_CFG_FEATURE", new Maker< Virtualizer >())

This features only show that the CFG has been virtualized.

This may implies a lot of transformation like function call inlining or loop unrolling.

Header: <otawa/cfg/features.h>

Configuration

Properties

RECURSIVE_LOOP

◆ WEIGHT

Identifier<int> otawa::WEIGHT("otawa::WEIGHT", 0)

Get the maximum weight for the basic block it is hooked to.

Feature

otawa::WEIGHT_FEATURE

Hooks

BasicBlock

Referenced by otawa::etime::EdgeTimeBuilder::applyWeightedSplit().

◆ WEIGHT_FEATURE

p::feature otawa::WEIGHT_FEATURE("otawa::WEIGHT_FEATURE", new Maker< Weighter >())

This feature ensures that weight information has been hooked to any BB of the CFG.

Weight information is coarse-grain estimation of the number of execution of a basic block. It is simply derived from the maximum and total number of iterations of each loop.

Header: #include <otawa/cfg/features.h>

Properties

WEIGHT

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

◆ action_t

◆ address_stat_t

◆ address_t

◆ call_t

◆ category_t

◆ CategoryStats

◆ code_part_t

◆ default_handler_t

◆ delayed_t

◆ fmlevel_t

◆ LinkedBlockList

◆ location_t

◆ PSTree

◆ RegSet

◆ stack_t

Enumeration Type Documentation

◆ action_t

◆ code_part

◆ fmlevel

Function Documentation

◆ ADDRESS_ANALYSIS_FEATURE()

◆ ADDRESS_STATS()

◆ ADDRESSES()

◆ CACHE_ACS_MAY()

◆ CACHE_ACS_MAY_ENTRY()

◆ CACHE_ACS_MUST()

◆ CACHE_ACS_MUST_ENTRY()

◆ CACHE_ACS_PERS()

◆ CACHE_ACS_PERS_ENTRY()

◆ CACHE_EDGE_ACS_MUST()

◆ CACHE_EDGE_ACS_PERS()

◆ CATEGORY_EDGE()

◆ CATEGORY_EDGE_HEADER()

◆ CONDITIONAL_RESTRUCTURED_FEATURE()

◆ CONTEXT()

◆ CONTEXT_TREE()

◆ CONTEXT_TREE_BY_CFG_FEATURE()

◆ CONTEXT_TREE_FEATURE()

◆ CONTEXTUAL_LOOP_BOUND()

◆ DEAD_CODE_ANALYSIS_FEATURE()

◆ DECODED_TEXT()

◆ DEF_BY()

◆ DEFAULT_BRANCH_PENALTY()

◆ defBy()

◆ ENCLOSING_LOOP_HEADER()

◆ ENTER()

◆ escape()

◆ EXIST_PROVIDED_STATE()

◆ EXTENDED_LOOP_FEATURE()

◆ FIRSTMISS_LEVEL()

◆ from_string() [1/14]

◆ from_string() [2/14]

◆ from_string() [3/14]

◆ from_string() [4/14]

◆ from_string() [5/14]

◆ from_string() [6/14]

◆ from_string() [7/14]

◆ from_string() [8/14]

◆ from_string() [9/14]

◆ from_string() [10/14]

◆ from_string() [11/14]

◆ from_string() [12/14]

◆ from_string() [13/14]

◆ from_string() [14/14]

◆ from_string_split()

◆ GRAPHS_OUTPUT_DIRECTORY()

◆ ICACHE_ACS_FEATURE()

◆ ICACHE_ACS_MAY_FEATURE()

◆ ICACHE_CATEGORY2_FEATURE()

◆ ICACHE_CONSTRAINT2_FEATURE()

◆ ICACHE_EDGE_ACS_FEATURE()

◆ ICACHE_EDGE_CATEGORY2_FEATURE()