otawa Namespace Reference

$Id$ Copyright (c) 2007, IRIT - UPS casse.nosp@m.@iri.nosp@m.t.fr More...

Namespaces
	ai
	arm
	ast
	bpred
	branch
	cache
	cat
	ccg
	cfgio
	clp
	concept
	cpp
	dcache
	dfa
	display
	etime
	ets
	gliss
	graph
	hard
	ilp
	ipet
	loader
	ot
	p
	pfg
	ppc
	proc
	s12x
	script
	se
	sem
	sim
	stack
	tsim
	util

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
	Subclass of AccessedAddress, this class represents an absolute address access, to a global variable or to an input/output register for example. More...
class	AbsoluteAddress
	Symbolic address as an absolute address. More...
class	AbstractAccessor
class	AbstractFeature
	See Feature. More...
class	AbstractIdentifier
	Represents a unique identifier used by the annotation system. More...
class	AbstractMaker
class	AbstractParamIdentifier
	A parametric identifier allows to instantiate identifier depending on a parametric feature. More...
class	AbstractParamProcessor
	Abstract form of a parametric processor. More...
class	AbstractRegistration
	Abstract class to represent the registered processors. More...
class	AccessedAddress
	Parent class of classes representing accesses to memory. More...
class	AccessedAddresses
	For each basic block, provide the list of performed memory accesses and their addresses. More...
class	AccessedAddressFromStack
class	Accessor
class	ACSBuilder
	This processor builds the MUST and PERS cache states before each basic block. More...
class	ACSMayBuilder
	This processor produces the Abstract Cache States (ACS), for the MAY ACS. More...
class	ActualFeature
	An actual feature is the result of the instantiation of a parametric feature. More...
class	Address
	The representation of an address in OTAWA. More...
struct	address_stat_t
class	AddressOption
	An option allowing to read an address, currently, only an unsigned decimal, hexadecimal and so one value. More...
class	AlternativeProcessor
	With OTAWA classic scheduler, the list of required feature if fixed in the registration data structure. More...
class	AmbiguousBoundException
class	Application
	A class making easier the use of applications built on OTAWA. More...
class	BackwardCFGAdapter
	Adapter of CFG to the concept of otawa::concept::DiGraphWithIndexedVertex but with backward traversal of edges. More...
class	Bag
class	BaseType
	This class provides a representation for the base type. More...
class	BasicBlock
	This is the minimal definition of a basic block. More...
class	BasicGraphBBTime
	This property is used to pass the microprocessor description to the code processor. More...
class	BBCleaner
	Efficient implementation of a cleaner for properties found on a basic block. More...
class	BBDeletor
	Basic block cleaner removing an identifier and deleting its content. More...
class	BBProcessor
	This processor is dedicated to the basic block process thru proccessBB() method. More...
class	BBRatioDisplayer
	This class output statistics for each basic block in the WCET as a table in a textual form on the standard output. More...
class	BBRemover
class	BBStatCollector
	This class alleviates the work of building a statistics collector. More...
class	BranchProblem
class	CachePenalty
	This class can be used to express the penalties due to the instruction cache. More...
class	CAT2Builder
	This processor produces categorization information for each l-block. More...
class	CAT2ConstraintBuilder
	This processor produces constraints, using the categorization of the L-Blocks, as provided by CAT2OnlyConstraintBuilder and the time spent in cache misses added to the objective function. More...
class	CAT2NCBuilder
	This processor produces categorization information for each l-block. More...
class	CAT2OnlyConstraintBuilder
	Build the constraints to support categories of cat2 module. More...
class	CEClass
class	CFG
	Control Flow Graph representation. More...
class	CFGBuilder
	This processor is used for building the CFG from the binary program representation. More...
class	CFGChecker
	The analysis does not produce anything but simply check some properties on the involved CFG: More...
class	CFGCheckSummer
	Add to each involved CFG a checksum build on the instruction of the CFG. More...
class	CFGCollection
	Contains a collection of CFGs (used with INVOLVED_CFGS property). More...
class	CFGCollector
	This processor is used to collect all CFG implied in a computation. More...
class	CFGInfo
	This allows storing all CFG available in a workspace. More...
class	CFGNormalizer
	This processor check and transform the CFG to make it normalized, that is, it performs the following checks and transformation: More...
class	CFGProcessor
	This is a specialization of the processor class dedicated to CFG processing. More...
class	CFGSaver
	Save the CFGs of the current task to a file. More...
class	CodeBasicBlock
	Represent a basic block in the strictess meaning: a sequence of instructions containing no branch, or branch target except for the last instruction that may be a branch. More...
class	ConfigIter
	Iterator on the configurations of a processor. More...
class	ContextPath
	This class is a stack to store call chain in the program call graph. More...
class	ContextTree
class	ContextTreeBuilder
	This processor produces context tree information. More...
class	ContextTreeByCFGBuilder
	Build a context tree for each CFG involved in the current computation. More...
class	ContextualLoopBound
	A contextual loop bound is a collection of loop bound (including max iteration and total iteration number) for the different call contexts of a loop. More...
class	ContextualPath
class	ContextualProcessor
	A contextual processor allows to process basic block in a call-aware way even with a virtual CFG (where called CFG are inlined). More...
class	ContextualProperty
	A contextual property is a special property that allows to retrieve a property value by its contextual path (ContextualPath). More...
class	ContextualStep
class	DeadCodeAnalysis
	This analyzer add the NEVER_TAKEN identifer on edges which are never taken. More...
class	DecodingException
	This exception is thrown by a loader to inform about problems during decoding. More...
struct	default_handler_t
class	DelayedBuilder
	This processor handle the delayed branch information provided by otawa::DELAYED_FEATURE to transform the CFG to let other processor ignore the delayed branch effects. More...
class	DelayedInfo
	Provide information on delayed branches. More...
class	DeletableProperty
	A deletable property is a genericproperty whose value will be deleted when the property is destroyed. More...
class	Dominance
	This CFG processor computes and hook to the CFG the dominance relation that, then, may be tested with Dominance::dominate() function. More...
class	DuplicateIdentifierException
	This exception is thrown when two identifier with the same name are declared. More...
class	DynFeature
	This class is used to resolve feature found in plugins using ProcessorPlugin::getFeature() method. More...
class	DynIdentifier
	An identifier dynamically resolved. More...
class	DynProcessor
	This pseudo-processor allows to call processor based on their name. More...
class	Edge
	This class represents edges in the CFG representation. More...
class	EdgeACSBuilder
	This processor builds the MUST and PERS cache states before each basic block. More...
class	EdgeCAT2Builder
	This processor produces categorization information for each l-block. More...
class	EdgeCAT2ConstraintBuilder
	This processor produces constraints, using the categorization of the lblocks. More...
class	EdgeProcessor
	Abstract processor providing simple traversal of edges of the CFG. More...
class	EndBasicBlock
class	Exception
	Base class of Otawa exceptions. More...
class	ExeGraph
	An execution graph that expresses precedence constraints on the execution of a sequence of instructions in a pipelined processor. More...
class	ExeGraphBBTime
class	ExeInst
	An instruction represented in an ExeGraph. More...
class	ExeSequence
	A sequence of instructions (ExeInst) More...
class	ExpNode
class	Feature
	A feature is a set of facilities, usually provided using properties, available on a framework. More...
class	FeatureDependency
	A feature dependency represents the dependencies used to implement a feature and is a node of the dependency graph. More...
class	FeatureIter
	Iterator on the features used by the processor. More...
class	FeatureNotFound
class	FeatureRequirer
	This class provided feature requirement for non-program processor classes. More...
class	FeatureUsage
class	File
	This class represents a file involved in the building of a process. More...
class	FirstLastBuilder
class	FixedTextDecoder
	Decode the text instruction for a simple RISC architecture, requiring fixed size and fixed alignement instructions. More...
class	FlowFactLoader
	This class is an abstract class to monitor the load of flow facts. More...
class	ForwardCFGAdapter
	Adapter of CFG to the concept of otawa::concept::DiGraphWithIndexedVertex. More...
class	FunAccessor
class	FunProcessor
	This is a specialization of the processor class dedicated to function processing. More...
class	GenericProperty
	This generic class allows attaching any type of data to a property. More...
class	GenGraph
class	Give
class	GraphBBTime
	This basic block processor computes the basic block execution time using the execution graph method described in the following papers: More...
class	Identifier
	This class represents identifier with a typed associated value. More...
class	ImmutableRef
class	Inst
	This class represents assembly instruction of a piece of code. More...
class	LabelAddress
	A label address formed by a label and a possible signed offset. More...
class	LBlock
	The l-block is an abstraction allowing to split the basic block according to the bound of the cache block, that is, instructions composing a l-block are owned by the same basic block and same cache block. More...
class	LBlockBuilder
	This processor builds the list of l-blocks for each lines of instruction cache and stores it in the CFG. More...
class	LBlockManager
class	LBlockProcessor
	This is a specialization of the processor class dedicated to LBlock. More...
class	LBlockSet
	This class represents the list of l-blocks of a task for a chosen cache row. More...
class	Level
class	LiExeGraph
class	LiExeGraphBBTime
class	LiExeNode
class	LinkedBlocksDetector
class	Loader
	This interface is implemented by all objects that may build and provide a process. More...
class	LoadException
	Exception thrown when a loader encounters an error during load. More...
class	LockedProperty
	This class is used for building a lock property, that is, for taking pointer values implementing the elm::Locked class. More...
class	LogOption
	Defines a command line option supporting log level thanks to strings 'proc', 'cfg' or 'bb'. More...
class	LoopReductor
class	LoopUnroller
	This processor unrolls the first iteration of each loop. More...
class	Maker
	Template to make a processor from its class passed as template parameter. More...
class	Manager
	The manager class providesfacilities for storing, grouping and retrieving shared resources like loaders and platforms. More...
class	MAYBranch
class	MAYProblem
class	MemArea
	Utility class representing an area in the memory defined by a base address and a size. More...
class	MemBlockMap
	This class is used to retrieve quickly blocks from their containing address. More...
class	MetaRegistration
class	Microprocessor
class	Monitor
	This class provide a unified interface to interact with external user. More...
class	MUSTBranch
class	MUSTPERS
class	MUSTProblem
class	NodeLatency
class	NoProcessor
	A processor whise execution cause an exception throw. More...
class	NoProcessorException
class	NoType
	Null value for types. More...
class	NullProcessor
	A simple processor that does nothing. More...
class	NullRegistration
class	NullStream
class	OutOfSegmentException
	This exception is thrown when a memory access is performed on process with an address that does not point in a segment of the executable file. More...
class	ParamExeGraph
class	ParamExeGraphBBTime
class	ParamExeNode
class	ParamFeature
	A parametric feature is a feature that may be instantiated according to some parameters passed in a property list. More...
class	ParamIdentifier
	Implementation of AbstractParamIdentifier for an Identifier. More...
class	ParamProcessor
	A parametric processor allows to generate processor for parametric feature. More...
class	ParExeEdge
	An edge in a ParExeGraph. More...
class	ParExeException
	Exception thrown if there is an error during the build and the computation of. More...
class	ParExeGraph
	Representation of a parametric execution graph (Parametric Execution Graph). More...
class	ParExeInst
	Instruction as presented in the ParExeGraph. More...
class	ParExeNode
	A node of the ParExeGraph, that represents the crossing of an instruction inside a microprocessor stage. More...
class	ParExePipeline
	Representation of a pipeline (list of stages). More...
class	ParExeProc
	Représentation of a processor (to be used to build a ParExeGraph). More...
class	ParExeQueue
	Representation of a hardware instruction queue to be used to build a ParExeGraph. More...
class	ParExeSequence
	A sequence of ParExeInstruction for which a ParExeGraph will be built. More...
class	ParExeStage
	Representation of a pipeline stage to be used to build a ParExeGraph. More...
class	PathContext
class	PCG
class	PCGBlock
class	PCGBuilder
class	PERSBranch
class	PERSProblem
	Problem for computing the PERS ACS of L-blocks. More...
class	PFGBuilder
class	PipelineStage
class	PostDominance
	This CFG processor computes and hook to the CFG the postdominance relation that, tehn, may be tested with PostDominance::postDominate() function. More...
class	Process
	A process is the realization of a program on a platform. More...
class	ProcessException
	An exception generated from a process. More...
class	Processor
	The processor class is implemented by all code processor. More...
class	ProcessorException
	This class is used for returning exceptions from the processors. More...
class	ProcessorNotFound
	This exception is thrown when a code processor can not be found. More...
class	ProcessorPlugin
	This class must implemented by plugins containing processor, features and identifiers. More...
class	ProgItem
	Base class of the components of a program file segment. More...
class	Progress
	This class is an interface to get progress information about execution of a processor. More...
class	Property
	A property associates a data with an identifier. More...
class	PropList
	This a list of properties. More...
class	PSTBuilder
	This processor computes the Program Structure Tree of the CFG. More...
class	Queue
class	QueueResource
class	Ref
class	Registration
class	Registry
	Class dedicated to the registering of the processors. More...
class	RegIter
class	RegResource
class	Resource
class	ResourceList
class	Segment
	In usual file format like ELF, COFF and so on, the program file is divided in segment according platform needs or memory propertes. More...
class	SESERegion
class	SilentFeature
	The usual Feature class has as drawback to exhibit completely the processing of the feature and therefore, in C++, to require too much header file inclusion (like the default processor or the default handler structure). More...
class	SimState
class	SPAddress
	Subclass of AccessedAddress, this class represents address with a constant offset relative to the stack pointer. More...
class	SpanningTreeBuilder
class	StackAnalysis
	This analyzer computes accessed addresses. More...
class	StageResource
class	StartResource
class	StatCollector
	A statistics collector allows to access statistics produced by an analysis. More...
class	StatInfo
	Aggregator of statistics put on the workspace. More...
class	SubCFGBuilder
	Build a sub-CFG starting at the given otawa::START address and ending at the multiple otawa::STOP addresses. More...
class	SymAddress
	Abstraction of a program address that may be expressed using several ways: absolute address, label + offset, source file:line, etc. More...
class	Symbol
	A symbol is a name of a location in a program. More...
class	TextDecoder
	A default text decoder: try to find the most adapted text decoder. More...
class	TimingContext
class	Trace
class	TrivialBBLBlockTime
class	Type
	This class describes the type of the data in the program. More...
class	UnavailableFeatureException
	This exception is thrown when an feature can not be computed. More...
class	UnsupportedFeatureException
	This class is used to throw an exception when a process does not support an invoked feature. More...
class	VarTextDecoder
	This text decoder may be used for most processor with fixed or variable length instructions. More...
class	VirtualBasicBlock
class	VirtualCFG
	A virtual CFG is a CFG not-mapped to real code, that is, it may contains virtual nodes for inlining functions calls or for separating nodes according some context information. More...
class	Virtualizer
	This processor inlines the function calls. More...
class	WorkSpace
	A workspace represents a program, its run-time and all information about WCET computation or any other analysis. More...
class	XSLTScript
	This class provides a simple way to implement OTAWA script. More...

Typedefs
typedef Address	address_t
typedef enum otawa::fmlevel	fmlevel_t
typedef otawa::cache::category_t	category_t
typedef cache::CategoryStats	CategoryStats
typedef Edge::kind_t	edge_kind_t
typedef elm::genstruct::Tree < SESERegion * >	PSTree
typedef enum otawa::instruction_category_t	instruction_category_t
typedef enum otawa::code_part_t	code_part_t
typedef struct otawa::default_handler_t	default_handler_t
typedef enum otawa::delayed_t	delayed_t
typedef class WorkSpace	FrameWork
typedef genstruct::Vector < t::uint16 >	RegSet
typedef struct otawa::address_stat_t	address_stat_t
typedef genstruct::SortedSLList < LBlock *, NumberOrder >	LinkedBlockList
typedef enum otawa::action_t	action_t
typedef struct otawa::call_t	call_t

Enumerations
enum	fmlevel { FML_INNER = 0, FML_OUTER = 1, FML_MULTI = 2, FML_NONE }
enum	instruction_category_t {   IALU = 0, FALU = 1, MEMORY = 2, CONTROL = 3,   MUL = 4, DIV = 5, INST_CATEGORY_NUMBER }
enum	code_part_t { PROLOGUE, BLOCK, EPILOGUE, CODE_PARTS_NUMBER }
enum	delayed_t { DELAYED_None = 0, DELAYED_Always = 1, DELAYED_Taken = 2 }
	Enumeration giving the type of delayed modes used by control instruction. More...
enum	action_t { DO_NOTHING = 0, DO_SWALLOW, DO_INSERT }

Functions
elm::io::Output &	operator<< (elm::io::Output &out, Address addr)
io::Output &	operator<< (io::Output &out, const MemArea &a)
otawa::Output &	operator<< (otawa::Output &out, const fmlevel_t &fml)
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 PERSProblem::Domain &dom)
Output &	operator<< (Output &out, const LBlock *block)
Output &	operator<< (Output &out, BasicBlock *bb)
io::Output &	operator<< (io::Output &out, CFG *cfg)
Output &	operator<< (Output &out, const Edge *edge)
Output &	operator<< (Output &out, Edge *edge)
instruction_category_t	instCategory (Inst *inst)
io::Output &	operator<< (io::Output &o, const hard::Bank::type_t &t)
Output &	operator<< (Output &out, const PCG &pcg)
Property *	defBy (const AbstractFeature *feature)
template<class T >
const AbstractRegistration &	registration (void)
elm::io::Output &	operator<< (elm::io::Output &out, Inst *inst)
elm::io::Output &	operator<< (elm::io::Output &out, Process *proc)
io::Output &	operator<< (io::Output &out, Symbol *sym)
io::Output &	operator<< (io::Output &out, Symbol::kind_t k)
elm::io::Output &	operator<< (elm::io::Output &out, const AbstractIdentifier &id)
elm::io::Output &	operator<< (elm::io::Output &out, const AbstractIdentifier *id)
io::Output &	operator<< (io::Output &out, const ContextualStep &path)
io::Output &	operator<< (io::Output &out, const ContextualPath &path)
template<class T >
io::Output &	operator<< (io::Output &out, const ContextualPath::Ref< T > &r)
template<class T >
Property *	make (const Identifier< T > &id, const T &v)
Property *	make (const Identifier< cstring > &id, const char *v)
Property *	make (const Identifier< string > &id, const char *v)
Property *	idLabel (cstring label)
Property *	idDesc (cstring desc)
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)
template<class T , class I >
io::Output &	operator<< (io::Output &out, const Ref< T, I > &ref)
template<class T , class I >
io::Output &	operator<< (io::Output &out, const ImmutableRef< T, I > &ref)
io::Output &	operator<< (io::Output &out, const AccessedAddress *addr)
io::Output &	operator<< (io::Output &out, const AccessedAddresses *aa)
io::Output &	operator<< (io::Output &out, AccessedAddresses *aa)
io::Output &	operator<< (io::Output &out, address_stat_t *stats)
template<class T >
const Type &	type (void)
io::Output &	operator<< (io::Output &out, const Type &type)
Output &	operator<< (Output &out, ContextTree *ct)
ot::size	leastGreaterLog2 (ot::size x)
	Compute the least greater logarithm of 2 for the given value. More...
io::Output &	operator<< (io::Output &out, SymAddress *addr)
Trace &	operator<< (Trace &trace, const Level &level)
p::feature	ICACHE_ACS_FEATURE ("otawa::ICACHE_ACS_FEATURE", new Maker< ACSBuilder >())
	This feature represents the availability of Abstract Cache State informations. More...
Identifier< genstruct::Vector < MUSTProblem::Domain * > * >	CACHE_ACS_MUST ("otawa::CACHE_ACS_MUST", NULL)
	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", NULL)
	This property allows us to set an entry must ACS. More...
Identifier< genstruct::Vector < PERSProblem::Domain * > * >	CACHE_ACS_PERS ("otawa::CACHE_ACS_PERS", NULL)
	This property represents the "persistence" Abstract Cache State of a basic block. More...
Identifier< bool >	PSEUDO_UNROLLING ("otawa::PSEUDO_UNROLLING", true)
	This property represents the "persistence" Abstract Cache State of a basic block. 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	ICACHE_ACS_MAY_FEATURE ("otawa::ICACHE_ACS_MAY_FEATURE", new Maker< ACSMayBuilder >())
	This feature represents the availability of MAY Abstract Cache State informations. More...
Identifier< genstruct::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< CachePenalty * >	ICACHE_PENALTY ("otawa::CACHE_PENALTY", NULL)
SilentFeature	ICACHE_CATEGORY2_FEATURE ("otawa::ICACHE_CATEGORY2_FEATURE", cat_maker)
	This feature ensures that the categories for instruction cache according to the following method has been computed: More...
Identifier< ilp::Var * >	MISS_VAR ("otawa::MISS_VAR", 0)
	Property giving the variable counting the number of misses. 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...
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...
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...
Feature< EdgeCAT2Builder >	ICACHE_EDGE_CATEGORY2_FEATURE ("otawa::ICACHE_EDGE_CATEGORY2_FEATURE")
Identifier< Vector< category_t > * >	CATEGORY_EDGE ("otawa::cactegory_edge", NULL)
Identifier< Vector< BasicBlock * > * >	CATEGORY_EDGE_HEADER ("otawa::category_edge_header", NULL)
Feature< FirstLastBuilder >	ICACHE_FIRSTLAST_FEATURE ("otawa::ICACHE_FIRSTLAST_FEATURE")
	This feature represents the availability of the LAST_LBLOCK and LBLOCK_ISFIRST properties. 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...
Feature< LBlockBuilder >	COLLECTED_LBLOCKS_FEATURE ("otawa::COLLECTED_LBLOCKS_FEATURE")
	This properties is set on the first instruction of each lblock and points to the lblock. More...
Identifier< LBlockSet ** >	LBLOCKS ("otawa::LBLOCKS", 0)
	This property is used for storing the list of L-Blocks. More...
Identifier < genstruct::AllocatedTable < LBlock * > * >	BB_LBLOCKS ("otawa::BB_LBLOCKS", 0)
	This property is used for storing the list of L-Blocks of a BasicBlock. More...
Identifier< genstruct::Vector < LBlock * > * >	LINKED_BLOCKS ("otawa::LINKED_BLOCKS", NULL)
	!!TODO!! More...
Identifier< CFG * >	ENTRY ("otawa::ENTRY", 0)
	Identifier used for storing and retrieving the CFG on its entry BB. More...
Identifier< int >	INDEX ("otawa::INDEX",-1)
	Identifier used for storing in each basic block from the CFG its index. 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...
SilentFeature	CHECKED_CFG_FEATURE ("otawa::CHECKED_CFG_FEATURE", maker)
	This feature ensures that. More...
SilentFeature	CFG_CHECKSUM_FEATURE ("otawa::CFG_CHECKSUM_FEATURE", maker)
	This feature ensures that each CFG has hooked a checksum allowing to check binary modifications between launch of an OTAWA application. 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...
Identifier< const CFGCollection * >	INVOLVED_CFGS ("otawa::INVOLVED_CFGS", 0)
	This property is used to link the current computation involved CFG on the framework. More...
Identifier< Edge * >	CALLED_BY ("otawa::CALLED_BY", 0)
	This properties are put on a CFG to get the list of edges calling it. More...
SilentFeature	COLLECTED_CFG_FEATURE ("otawa::COLLECTED_CFG_FEATURE", COLLECTED_CFG_MAKER)
	This feature asserts that all CFG involved in the current computation has been collected and accessible thanks to INVOLVED_CFGS property. More...
SilentFeature	DELAYED_CFG_FEATURE ("otawa::DELAYED_CFG_FEATURE", maker)
	This feature informs that the current microprocessor supports delayed branches and that the CFG has been changed to reflect effect of delay branches. 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...
Identifier< sys::Path >	CFG_IO_PATH ("otawa::CFG_IO_PATH")
	This property allows to configure the file used by CFGLoader and CFGSaver. 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< BasicBlock * >	ENCLOSING_LOOP_HEADER ("otawa::ENCLOSING_LOOP_HEADER", 0)
	Defined for any BasicBlock that is part of a loop. More...
Identifier< BasicBlock * >	LOOP_EXIT_EDGE ("otawa::LOOP_EXIT_EDGE", 0)
	Is defined for an Edge if this Edge is the exit-edge of any loop. More...
Identifier < elm::genstruct::Vector< Edge * > * >	EXIT_LIST ("otawa::EXIT_LIST", 0)
	Defined for any BasicBlock that is a loop header. More...
SilentFeature	REDUCED_LOOPS_FEATURE ("otawa::REDUCED_LOOPS_FEATURE", REDUCED_LOOPS_MAKER)
SilentFeature	UNROLLED_LOOPS_FEATURE ("otawa::UNROLLED_LOOPS_FEATURE", UNROLLED_LOOPS_MAKER)
	This feature that the loops have been unrolled at least once. More...
Identifier< BasicBlock * >	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...
SilentFeature	PFG_FEATURE ("otawa::PFG_FEATURE", pfg::maker)
	Feature providing the PFG of the application. More...
Identifier< pfg::PFG * >	PFG ("otawa::PFG", 0)
	PFG of the program. More...
Identifier< pfg::BB * >	PFG_BB ("otawa::PFG_BB", 0)
	Link of pfg::BB on an in instruction. More...
SilentFeature	PST_FEATURE ("otawa::PST_FEATURE", PST_MAKER)
	This feature represents the availability of the Program Structure Tree. 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< PSTree * >	PROGRAM_STRUCTURE_TREE ("otawa::PROGRAM_STRUCTURE_TREE", 0)
	This property points to the Program Structure Tree of the CFG. More...
Identifier< Address >	CFG_START ("otawa::CFG_START")
	Configuration of otawa::SubCFGBuilder specifying the start of the sub-CFG to process. More...
Identifier< Address >	CFG_STOP ("otawa::CFG_STOP")
	Configuration of otawa::SubCFGBuilder specifying a end of the sub-CFG to process. More...
p::feature	VIRTUALIZED_CFG_FEATURE ("otawa::VIRTUALIZED_CFG_FEATURE", new Maker< Virtualizer >())
	This features only show that the CFG has been virtualized. More...
Identifier< BasicBlock * >	VIRTUAL_RETURN_BLOCK ("otawa::VIRTUAL_RETURN_BLOCK", 0)
	This property is put on a BB performing a function call that has been virtualized (inlined in the current CFG). More...
Identifier< CFG * >	CALLED_CFG ("otawa::CALLED_CFG", 0)
	A property with this identifier is hooked to the edges performing virtual calls and virtual returns when inlining is used. 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...
Identifier< BasicBlock * >	RETURN_OF ("otawa::RETURN_OF", 0)
	This property is put on a returning basic block and provides the matching entry block of the function. More...
Identifier< bool >	VIRTUAL_INLINING ("otawa::VIRTUAL_INLINING", true)
	Configuration property of Virtualizer: it set the default behavior for inlining of function call during virtualization (default to true). 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...
Identifier< CFGInfo * >	CFG_INFO ("otawa::CFG_INFO", 0)
	Get the collection of CFG found in the program. More...
Feature< DeadCodeAnalysis >	DEAD_CODE_ANALYSIS_FEATURE ("otawa::DEAD_CODE_ANALYSIS_FEATURE")
Identifier< bool >	NEVER_TAKEN ("otawa::NEVER_TAKEN")
Identifier< bool >	START ("otawa.exegraph.start", false)
Identifier< String >	OUTPUT_FILE ("output file name","")
Identifier< int >	OUTPUT_LEVEL ("output level", 0)
Identifier< String >	GRAPHS_DIR ("graphs directory","")
Identifier< ContextualLoopBound * >	CONTEXTUAL_LOOP_BOUND ("otawa::CONTEXTUAL_LOOP_BOUND", 0)
	This property provides context-dependent loop bounds. More...
Identifier< string >	LOAD_PARAM ("otawa::LOAD_PARAM","")
	Identifier used for Manager::load() configuration. More...
Identifier< 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< Address >	TASK_ADDRESS ("otawa::TASK_ADDRESS", Address::null)
	This property, passed to the load configuration, select the task entry by its address. More...
Identifier< CString >	PLATFORM_NAME ("otawa::PLATFORM_NAME","")
	Identifier of the property indicating the name (CString) of the platform to use. More...
Identifier< CString >	LOADER_NAME ("otawa::LOADER_NAME","")
	Identifier of the property indicating a name (CString) of the loader to use. More...
Identifier< hard::Platform * >	PLATFORM ("otawa::PLATFORM", 0)
	Identifier of the property indicating a platform (Platform *) to use. More...
Identifier< Loader * >	LOADER ("otawa::LOADER", 0)
	Identifier of the property indicating the loader to use. More...
Identifier< int >	ARGC ("otawa::ARGC",-1)
	Argument count as passed to the program (int). More...
Identifier< char ** >	ARGV ("otawa::ARGV", 0)
	Argument values as passed to the program (char **). More...
Identifier< char ** >	ENVP ("otawa::ENVP", 0)
	Argument values as passed to the program (char **). More...
Identifier< sim::Simulator * >	SIMULATOR ("otawa::SIMULATOR", 0)
	This property defines the used the used simulator when a simulator is needed to perform simulation. More...
Identifier< elm::CString >	SIMULATOR_NAME ("otawa::SIMULATOR_NAME","")
	Name of the simulator to use. More...
Identifier < hard::CacheConfiguration * >	CACHE_CONFIG ("otawa::CACHE_CONFIG", 0)
	This property is used to pass the cache configuration directly to the platform. More...
Identifier< int >	PIPELINE_DEPTH ("otawa::PIPELINE_DEPTH",-1)
	This property is a hint to have an estimation of the pipeline depth. More...
Identifier< 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...
Identifier< bool >	NO_STACK ("otawa::NO_STACK", false)
	This property shows that no stack need to be allocated. More...
Identifier< elm::system::Path >	CONFIG_PATH ("otawa::CONFIG_PATH","")
	Path to the XML configuration file used in this computation. More...
Identifier< elm::xom::Element * >	CONFIG_ELEMENT ("otawa::CONFIG_ELEMENT", 0)
	XML element containing the configuration of the current computation. More...
Identifier< elm::system::Path >	PROCESSOR_PATH ("otawa::PROCESSOR_PATH","")
	Path to the XML configuration file of the processor. More...
Identifier< elm::xom::Element * >	PROCESSOR_ELEMENT ("otawa::PROCESSOR_ELEMENT", 0)
	XML element containing the configuration of the processor. More...
Identifier< hard::Processor * >	PROCESSOR ("otawa::PROCESSOR", 0)
	Gives the processor to use in the current computation. More...
Identifier< elm::system::Path >	CACHE_CONFIG_PATH ("otawa::CACHE_CONFIG_PATH","")
	Gives the path of file containing the cache configuration. More...
Identifier< elm::xom::Element * >	CACHE_CONFIG_ELEMENT ("otawa::CACHE_CONFIG_ELEMENT", 0)
	Gives an XML element containing the cache configuration. More...
Identifier< 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...
Identifier< elm::system::Path >	MEMORY_PATH ("otawa::MEMORY_PATH","")
	Passed to Manager::load() to give the path of the file describing the memory. More...
Identifier< elm::xom::Element * >	MEMORY_ELEMENT ("otawa::MEMORY_ELEMENT", 0)
	Passed to manager::load() to give the XML element describing the memory configuration. More...
Identifier< hard::Memory * >	MEMORY_OBJECT ("otawa::MEMORY_OBJECT", 0)
	Passed to manager::load() to set the memory configuration. More...
Identifier< String >	GRAPHS_OUTPUT_DIRECTORY ("otawa::GRAPHS_OUTPUT_DIRECTORY","")
string	escape (const string &s)
	Escape special characters in the given string. More...
Feature< PCGBuilder >	PCG_FEATURE ("otawa::PCG_FEATURE")
	This feature ensure that a PCG is provided. More...
Identifier< CFG * >	ENTRY_CFG ("otawa::entry_cfg", 0)
	This property may be used to pass the entry CFG to a CFG processor or is used by the CFG processor to record in the framework the entry CFG of the currently processed task. More...
Identifier< int >	PROCESSED_CFG ("otawa::processed_cfg", 0)
	This property is used to store statistics about the count of processed CFG. More...
Identifier< 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...
Identifier< const AbstractFeature * >	DEF_BY ("otawa::DEF_BY", 0)
	Identifier for identifier property providing ownerness of an identifier. More...
Identifier< elm::io::OutStream * >	OUTPUT ("otawa::OUTPUT",&io::out)
	This property identifier is used for setting the output stream used by the processor to write results. More...
Identifier< elm::io::OutStream * >	LOG ("otawa::LOG",&io::err)
	This property identifier is used for setting the log stream used by the processor to write messages (information, warning, error). More...
Identifier< bool >	VERBOSE ("otawa::VERBOSE", false)
	This property activates the verbose mode of the processor: information about the processor work will be displayed. More...
Identifier< 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::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...
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	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	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...
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...
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...
p::feature	VLIW_SUPPORTED ("otawa::VLIW_SUPPORTED", new Maker< NoProcessor >())
	This feature is provided on Process objects by architecture implementing VLIW facilities. 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 >	ENVP_ADDRESS ("otawa::ENVP_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< 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	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::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...
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...
Identifier< DelayedInfo * >	DELAYED_INFO ("otawa::DELAYED_INFO", 0)
	This property provides access to delayed branch information of the current program. More...
Identifier< String >	LABEL ("otawa::LABEL","", idLabel("label"), idDesc("label in assembly code"), 0)
	Property with this identifier is put on instructions or basic blocks which a symbol is known for. More...
Identifier< String >	FUNCTION_LABEL ("otawa::FUNCTION_LABEL","")
	This property is put on instruction. More...
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...
template<>
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...
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...
const AbstractIdentifier	END ("end")
	This identifier is used for marking the end of property list definition in variable arguments "...". More...
char	sign (t::int32 v)
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< AccessedAddresses * >	ADDRESSES ("otawa::ADDRESSES", 0)
	Provide the set of accesses to the memory for the current basic block. More...
Identifier< address_stat_t * >	ADDRESS_STATS ("otawa::ADDRESS_STATS", 0)
	This property provides statistics about ADDRESS_ANALYSIS_FEATURE. More...
Feature< CFGNormalizer >	NORMALIZED_CFGS_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. 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...
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...
Identifier< ContextTree * >	CONTEXT_TREE ("otawa::CONTEXT_TREE", 0)
	This property identifier provides a context tree hooked to a framework. 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...
Identifier< BitSet * >	REVERSE_DOM ("otawa::REVERSE_DOM", 0)
	Identifier of annotation containing reverse-dominance information. More...
Identifier< bool >	LOOP_HEADER ("otawa::LOOP_HEADER", false)
	Identifier for marking basic blocks that are entries of loops. More...
Identifier< bool >	BACK_EDGE ("otawa::BACK_EDGE", false)
	Identifier for marking back edges. More...
SilentFeature	DOMINANCE_FEATURE ("otawa::DOMINANCE_FEATURE", DOMINANCE_MAKER)
	This feature ensures that information about domination between nodes of a CFG is vailable. More...
SilentFeature	LOOP_HEADERS_FEATURE ("otawa::LOOP_HEADERS_FEATURE", LOOP_HEADERS_MAKER)
	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...
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...
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...
Feature< FlowFactLoader >	FLOW_FACTS_FEATURE ("otawa::FLOW_FACTS_FEATURE")
	This feature ensures that the flow facts has been loaded. More...
Feature< FlowFactLoader >	MKFF_PRESERVATION_FEATURE ("otawa::MKFF_PRESERVATION_FEATURE")
	This feature ensures that preservation information used by mkff is put on instruction. 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...
Identifier< bool >	NO_RETURN ("otawa::NO_RETURN", false)
	This annotation is put on the first instruction of functions that does not never return. More...
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...
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< 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 >	INLINING_POLICY ("otawa::INLINING_POLICY")
	Put on the first instruction of a function to set default inlining behavior during its virtualization. More...
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_SEQ ("otawa::IGNORE_SEQ", false)
	Put on a control instruction to prevent to pass in sequence. 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< Address >	CALL_TARGET ("otawa::CALL_TARGET", Address())
	Put on instruction that may call to several targets or whose target computation cannot computed. More...
Identifier< bool >	PRESERVED ("otawa::PRESERVED", false)
	Put on instruction that must preserved from the mkff special flow-fact detection. 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< 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...
Identifier< bool >	IGNORE_ENTRY ("otawa::IGNORE_ENTRY", false)
	Put on function symbol that must be ignored as function entry. More...
Identifier< Pair< Address, Address > >	ACCESS_RANGE ("otawa::ACCESS_RANGE")
	Put on a memory access instruction, provides a range of possible accesses. More...
Identifier< BitSet * >	REVERSE_POSTDOM ("otawa::REVERSE_POSTDOM", 0)
	Identifier of annotation containing reverse-postdominance information. More...
Feature< PostDominance >	POSTDOMINANCE_FEATURE ("otawa::POSTDOMINANCE_FEATURE")
	This feature ensures that information about postdomination between nodes of a CFG is vailable. More...
p::feature	STACK_ANALYSIS_FEATURE ("otawa::STACK_ANALYSIS_FEATURE", new Maker< StackAnalysis >())
	This features ensure that the stack analysis has been identified. 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)
elm::io::Output &	operator<< (elm::io::Output &output, const PERSBranch::Domain &dom)

Variables
Identifier< CachePenalty * >	ICACHE_PENALTY
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< fmlevel_t >	FIRSTMISS_LEVEL
	Specify the loop-level-precision of the First Miss computation (inner, outer, multi-level) More...
Identifier< bool >	PSEUDO_UNROLLING
	This property represents the "persistence" Abstract Cache State of a basic block. More...
Identifier< genstruct::Vector < MUSTProblem::Domain * > * >	CACHE_ACS_MUST_ENTRY
	This property allows us to set an entry must ACS. More...
Feature< EdgeACSBuilder >	ICACHE_EDGE_ACS_FEATURE
	This feature represents the availability of Abstract Cache State informations. More...
Identifier< Vector< category_t > * >	CATEGORY_EDGE
Identifier< Vector< BasicBlock * > * >	CATEGORY_EDGE_HEADER
Feature< EdgeCAT2Builder >	ICACHE_EDGE_CATEGORY2_FEATURE
p::feature	ICACHE_ACS_FEATURE
	This feature represents the availability of Abstract Cache State informations. More...
Identifier< genstruct::Vector < MUSTProblem::Domain * > * >	CACHE_ACS_MUST
	This property represents the "must" Abstract Cache State of a basic block. More...
Identifier< genstruct::Vector < PERSProblem::Domain * > * >	CACHE_ACS_PERS
	This property represents the "persistence" Abstract Cache State of a basic block. More...
Identifier< genstruct::Vector < MAYProblem::Domain * > * >	CACHE_ACS_MAY
	This property represents the "may" Abstract Cache State of a basic block. More...
Identifier< genstruct::Vector < MAYProblem::Domain * > * >	CACHE_ACS_MAY_ENTRY
	This property allows us to set an entry may ACS. More...
p::feature	ICACHE_ACS_MAY_FEATURE
	This feature represents the availability of MAY Abstract Cache State informations. More...
SilentFeature	ICACHE_CATEGORY2_FEATURE
	This feature ensures that the categories for instruction cache according to the following method has been computed: More...
p::feature	ICACHE_ONLY_CONSTRAINT2_FEATURE
	Ensures that the constraints for cache analysis by categories 2 has been built. 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...
Identifier< ilp::Var * >	MISS_VAR
	Property giving the variable counting the number of misses. More...
Identifier< genstruct::Vector < LBlock * > * >	LINKED_BLOCKS
	!!TODO!! More...
const category_t	INVALID_CATEGORY = otawa::cache::INVALID_CATEGORY
const category_t	ALWAYS_HIT = otawa::cache::ALWAYS_HIT
const category_t	FIRST_HIT = otawa::cache::FIRST_HIT
const category_t	FIRST_MISS = otawa::cache::FIRST_MISS
const category_t	ALWAYS_MISS = otawa::cache::ALWAYS_MISS
const category_t	NOT_CLASSIFIED = otawa::cache::NOT_CLASSIFIED
Identifier< category_t > &	CATEGORY = cache::CATEGORY
Identifier< BasicBlock * > &	CATEGORY_HEADER = cache::CATEGORY_HEADER
Identifier< CategoryStats * > &	CATEGORY_STATS = cache::CATEGORY_STATS
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...
Feature< FirstLastBuilder >	ICACHE_FIRSTLAST_FEATURE
	This feature represents the availability of the LAST_LBLOCK and LBLOCK_ISFIRST properties. More...
Feature< LBlockBuilder >	COLLECTED_LBLOCKS_FEATURE
	This properties is set on the first instruction of each lblock and points to the lblock. More...
Identifier< LBlockSet ** >	LBLOCKS
	This property is used for storing the list of L-Blocks. More...
Identifier < genstruct::AllocatedTable < LBlock * > * >	BB_LBLOCKS
	This property is used for storing the list of L-Blocks of a BasicBlock. More...
Identifier< int >	INDEX
	Identifier used for storing in each basic block from the CFG its index. More...
Identifier< CFG * >	ENTRY
	Identifier used for storing and retrieving the CFG on its entry BB. More...
SilentFeature	PFG_FEATURE
	Feature providing the PFG of the application. More...
Identifier< pfg::PFG * >	PFG
	PFG of the program. More...
Identifier< pfg::BB * >	PFG_BB
	Link of pfg::BB on an in instruction. More...
Identifier< CFG * >	ENTRY_CFG
	This property may be used to pass the entry CFG to a CFG processor or is used by the CFG processor to record in the framework the entry CFG of the currently processed task. More...
SilentFeature	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...
Identifier< const CFGCollection * >	INVOLVED_CFGS
	This property is used to link the current computation involved CFG on the framework. More...
Identifier< Edge * >	CALLED_BY
	This properties are put on a CFG to get the list of edges calling it. More...
p::feature	CFG_INFO_FEATURE
	Feature asserting that the CFG has been scanned in the program. More...
Identifier< CFGInfo * >	CFG_INFO
	Get the collection of CFG found in the program. More...
SilentFeature	REDUCED_LOOPS_FEATURE
SilentFeature	UNROLLED_LOOPS_FEATURE
	This feature that the loops have been unrolled at least once. More...
Identifier< BasicBlock * >	UNROLLED_FROM
	Put on the header ex-header of a loop, this property gives the BB of the unrolled loop. More...
SilentFeature	PST_FEATURE
	This feature represents the availability of the Program Structure Tree. More...
Identifier< BasicBlock * >	FROM_BB
	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
	This property is like. More...
Identifier< PSTree * >	PROGRAM_STRUCTURE_TREE
	This property points to the Program Structure Tree of the CFG. More...
p::feature	VIRTUALIZED_CFG_FEATURE
	This features only show that the CFG has been virtualized. More...
Identifier< bool >	VIRTUAL_INLINING
	Configuration property of Virtualizer: it set the default behavior for inlining of function call during virtualization (default to true). More...
Identifier< BasicBlock * >	VIRTUAL_RETURN_BLOCK
	This property is put on a BB performing a function call that has been virtualized (inlined in the current CFG). More...
Identifier< CFG * >	CALLED_CFG
	A property with this identifier is hooked to the edges performing virtual calls and virtual returns when inlining is used. More...
Identifier< bool >	RECURSIVE_LOOP
	A property with this identifier is hooked to edge performing a recursive call when inlining is used. More...
Identifier< BasicBlock * >	RETURN_OF
	This property is put on a returning basic block and provides the matching entry block of the function. More...
SilentFeature	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< unsigned long >	CHECKSUM
	This property hooked on a CFG provides a checksum build on the instruction of the CFG. More...
SilentFeature	CHECKED_CFG_FEATURE
	This feature ensures that. More...
SilentFeature	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...
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...
SilentFeature	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...
Identifier< bool >	LOOP_HEADER
	Identifier for marking basic blocks that are entries of loops. More...
Identifier< bool >	BACK_EDGE
	Identifier for marking back edges. More...
Identifier< BasicBlock * >	ENCLOSING_LOOP_HEADER
	Defined for any BasicBlock that is part of a loop. More...
Identifier< BasicBlock * >	LOOP_EXIT_EDGE
	Is defined for an Edge if this Edge is the exit-edge of any loop. More...
Identifier < elm::genstruct::Vector< Edge * > * >	EXIT_LIST
	Defined for any BasicBlock that is a loop header. More...
p::feature	LOOP_INFO_FEATURE
	This feature asserts that the loop info of the task is available in the framework. More...
Identifier< sys::Path >	CFG_IO_PATH
	This property allows to configure the file used by CFGLoader and CFGSaver. 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...
Identifier< Address >	CFG_START
	Configuration of otawa::SubCFGBuilder specifying the start of the sub-CFG to process. More...
Identifier< Address >	CFG_STOP
	Configuration of otawa::SubCFGBuilder specifying a end of the sub-CFG to process. More...
Feature< DeadCodeAnalysis >	DEAD_CODE_ANALYSIS_FEATURE
Identifier< bool >	NEVER_TAKEN
Feature< StackAnalysis >	STACK_ANALYSIS_FEATURE
	This features ensure that the stack analysis has been identified. More...
Identifier< bool >	START
Identifier< String >	OUTPUT_FILE
Identifier< int >	OUTPUT_LEVEL
Identifier< String >	GRAPHS_DIR
Identifier< ContextualLoopBound * >	CONTEXTUAL_LOOP_BOUND
	This property provides context-dependent loop bounds. More...
Manager	MANAGER
	Default manager. More...
Identifier< String >	GRAPHS_OUTPUT_DIRECTORY
Identifier< int >	TIME
Feature< PCGBuilder >	PCG_FEATURE
	This feature ensure that a PCG is provided. More...
Identifier< 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< int >	PROCESSED_CFG
	This property is used to store statistics about the count of processed CFG. More...
Identifier< const AbstractFeature * >	DEF_BY
	Identifier for identifier property providing ownerness of an identifier. More...
Identifier< elm::io::OutStream * >	OUTPUT
	This property identifier is used for setting the output stream used by the processor to write results. More...
Identifier< 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...
Identifier< bool >	VERBOSE
	This property activates the verbose mode of the processor: information about the processor work will be displayed. More...
Identifier< 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...
AbstractMaker *	null_maker = &null_inst
	Special maker for a null processor. More...
AbstractMaker *	no_maker = &no_inst
	Special maker for "no processor available". More...
Identifier< DelayedInfo * >	DELAYED_INFO
	This property provides access to delayed branch information of the current program. More...
Identifier< Address >	ARGV_ADDRESS
	This feature is put on the process object whose image supports Unix-like argument passing. More...
Identifier< Address >	ENVP_ADDRESS
	This feature is put on the process object whose image supports Unix-like argument passing. More...
Identifier< Address >	AUXV_ADDRESS
	This feature is put on the process object whose image supports Unix-like argument passing. More...
Identifier< Address >	SP_ADDRESS
	This feature is put on the process to get information about the built image. More...
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	CONTROL_DECODING_FEATURE
	This feature is usually provided by the loader providing decoding facility for control instructions. 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...
p::feature	DELAYED2_FEATURE
	This Process feature informs that the actual architecture supports delayed branch. 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	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::feature	REGISTER_USAGE_FEATURE
	This feature is usually asserted by processes that provides access to the register usage 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::feature	SEMANTICS_INFO
	This feature is present when the loader provides implementation of semantics information. More...
p::feature	SOURCE_LINE_FEATURE
	This feature asserts that a table matching program address and source (file, lines) is available. More...
p::feature	VLIW_SUPPORTED
	This feature is provided on Process objects by architecture implementing VLIW facilities. More...
Identifier< String >	LABEL
	Property with this identifier is put on instructions or basic blocks which a symbol is known for. More...
Identifier< String >	FUNCTION_LABEL
	This property is put on instruction. More...
Identifier< string >	TASK_ENTRY
	This property, passed to the load configuration, gives the name of the entry function of the current task. More...
Identifier< Address >	TASK_ADDRESS
	This property, passed to the load configuration, select the task entry by its address. More...
Identifier< hard::Platform * >	PLATFORM
	Identifier of the property indicating a platform (Platform *) to use. More...
Identifier< Loader * >	LOADER
	Identifier of the property indicating the loader to use. More...
Identifier< elm::CString >	PLATFORM_NAME
	Identifier of the property indicating the name (CString) of the platform to use. More...
Identifier< elm::CString >	LOADER_NAME
	Identifier of the property indicating a name (CString) of the loader to use. More...
Identifier< int >	ARGC
	Argument count as passed to the program (int). More...
Identifier< char ** >	ARGV
	Argument values as passed to the program (char **). More...
Identifier< char ** >	ENVP
	Argument values as passed to the program (char **). More...
Identifier< sim::Simulator * >	SIMULATOR
	This property defines the used the used simulator when a simulator is needed to perform simulation. More...
Identifier< elm::CString >	SIMULATOR_NAME
	Name of the simulator to use. More...
Identifier< int >	PIPELINE_DEPTH
	This property is a hint to have an estimation of the pipeline depth. More...
Identifier< bool >	NO_SYSTEM
	This property shows that the system does not need to by simulated when the binary image is built. More...
Identifier< bool >	NO_STACK
	This property shows that no stack need to be allocated. More...
Identifier< string >	NO_RETURN_FUNCTION
	this property may be used to pass information about the non-returning behaviour of some functions. More...
Identifier< elm::system::Path >	CONFIG_PATH
	Path to the XML configuration file used in this computation. More...
Identifier< elm::xom::Element * >	CONFIG_ELEMENT
	XML element containing the configuration of the current computation. More...
Identifier< elm::system::Path >	CACHE_CONFIG_PATH
	Gives the path of file containing the cache configuration. More...
Identifier< elm::xom::Element * >	CACHE_CONFIG_ELEMENT
	Gives an XML element containing the cache configuration. More...
Identifier < hard::CacheConfiguration * >	CACHE_CONFIG
	This property is used to pass the cache configuration directly to the platform. More...
Identifier< elm::system::Path >	MEMORY_PATH
	Passed to Manager::load() to give the path of the file describing the memory. More...
Identifier< elm::xom::Element * >	MEMORY_ELEMENT
	Passed to manager::load() to give the XML element describing the memory configuration. More...
Identifier< hard::Memory * >	MEMORY_OBJECT
	Passed to manager::load() to set the memory configuration. More...
Identifier< elm::system::Path >	PROCESSOR_PATH
	Path to the XML configuration file of the processor. More...
Identifier< elm::xom::Element * >	PROCESSOR_ELEMENT
	XML element containing the configuration of the processor. More...
Identifier< hard::Processor * >	PROCESSOR
	Gives the processor to use in the current computation. More...
Identifier< string >	LOAD_PARAM
	Identifier used for Manager::load() configuration. More...
Feature< TextDecoder >	DECODED_TEXT
	This feature ensures that text segment of the process has been decoded and, consequently, that instructions are available. 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< cstring >	IDENTIFIER_DESC
	Property of this identifier is put on identifier to give a more precise description of the identifier. More...
const AbstractIdentifier	END
	This identifier is used for marking the end of property list definition in variable arguments "...". More...
p::feature	ADDRESS_ANALYSIS_FEATURE
	This feature ensures that accessed memory information (class AccessedAddress) is provided for each basic block. More...
Identifier< AccessedAddresses * >	ADDRESSES
	Provide the set of accesses to the memory for the current basic block. More...
Identifier< address_stat_t * >	ADDRESS_STATS
	This property provides statistics about ADDRESS_ANALYSIS_FEATURE. More...
Feature< CFGNormalizer >	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...
Feature< ContextTreeBuilder >	CONTEXT_TREE_FEATURE
	This feature asserts that a context tree of the task is available in the 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...
Identifier< ContextTree * >	CONTEXT_TREE
	This property identifier provides a context tree hooked to a framework. More...
Identifier< ContextTree * >	OWNER_CONTEXT_TREE
	Annotations with this identifier are hooked to basic blocks and gives the owner context tree (ContextTree * data). More...
SilentFeature	DOMINANCE_FEATURE
	This feature ensures that information about domination between nodes of a CFG is vailable. More...
Identifier< dfa::BitSet * >	REVERSE_DOM
	Identifier of annotation containing reverse-dominance information. 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< 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< bool >	FLOW_FACTS_MANDATORY
	In configuration of the FlowFactLoader, makes it fail if no flow fact fail is available. More...
Feature< FlowFactLoader >	FLOW_FACTS_FEATURE
	This feature ensures that the flow facts has been loaded. More...
Feature< FlowFactLoader >	MKFF_PRESERVATION_FEATURE
	This feature ensures that preservation information used by mkff is put on instruction. More...
Identifier< bool >	IS_RETURN
	Put on a control flow instruction, this shows that this instruction is equivalent to a function return. More...
Identifier< bool >	NO_RETURN
	This annotation is put on the first instruction of functions that does not never return. More...
Identifier< int >	MAX_ITERATION
	Put on the first instruction of a loop, it gives the maximum number of iteration of this loop. More...
Identifier< int >	MIN_ITERATION
	Put on the first instruction of a loop, it gives the minimal number of iterations. More...
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...
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...
Identifier< bool >	INLINING_POLICY
	Put on the first instruction of a function to set default inlining behavior during its virtualization. More...
Identifier< bool >	IGNORE_CONTROL
	Put on a control instruction to prevent it to be interpreted as is. More...
Identifier< bool >	IGNORE_SEQ
	Put on a control instruction to prevent to pass in sequence. More...
Identifier< Address >	BRANCH_TARGET
	Put on instruction that may branch to several targets or whose target computation cannot computed. More...
Identifier< bool >	PRESERVED
	Put on instruction that must preserved from the mkff special flow-fact detection. More...
Identifier< bool >	IGNORE_ENTRY
	Put on function symbol that must be ignored as function entry. More...
Identifier< Address >	CALL_TARGET
	Put on instruction that may call to several targets or whose target computation cannot computed. More...
Identifier< Pair< Address, Address > >	ACCESS_RANGE
	Put on a memory access instruction, provides a range of possible accesses. More...
Feature< PostDominance >	POSTDOMINANCE_FEATURE
	This feature ensures that information about postdomination between nodes of a CFG is vailable. More...
Identifier< dfa::BitSet * >	REVERSE_POSTDOM
	Identifier of annotation containing reverse-postdominance information. 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
NullStream	null_stream
Identifier< int >	TO_DELAY ("", 0)
Identifier< bool >	IS_START ("", false)
Identifier< bool >	IS_STOP ("", false)
Identifier< bool >	IS_ON_FORWARD_PATH ("", false)
Identifier< bool >	IS_ON_BACKWARD_PATH ("", false)
otawa::NullInst	static_null
cstring	VERBOSE_ENV = "OTAWA_VERBOSE"
Identifier < hard::Platform::Identification * >	PLATFORM_IDENTFIER ("otawa::PLATFORM_IDENTFIER", 0)
	Identifier of the property indicating the identifier (PlatformId) of the loader to use. More...
Identifier< bool >	IS_FEATURE ("otawa::IS_FEATURE", false)
Feature< NoProcessor >	NULL_FEATURE ("otawa::NULL")
	Not a real feature, just a marker. More...
elm::CString	_base_displays []
int	fft_line = 0

Detailed Description

$Id$ Copyright (c) 2007, IRIT - UPS casse.nosp@m.@iri.nosp@m.t.fr

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

typedef enum otawa::action_t otawa::action_t

typedef struct otawa::address_stat_t otawa::address_stat_t

typedef Address otawa::address_t

typedef struct otawa::call_t otawa::call_t

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

typedef cache::CategoryStats otawa::CategoryStats

typedef enum otawa::code_part_t otawa::code_part_t

typedef struct otawa::default_handler_t otawa::default_handler_t

typedef enum otawa::delayed_t otawa::delayed_t

typedef Edge::kind_t otawa::edge_kind_t

typedef enum otawa::fmlevel otawa::fmlevel_t

typedef class WorkSpace otawa::FrameWork

typedef enum otawa::instruction_category_t otawa::instruction_category_t

typedef genstruct::SortedSLList<LBlock*, NumberOrder> otawa::LinkedBlockList

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

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

Enumeration Type Documentation

enum otawa::action_t

Enumerator
DO_NOTHING
DO_SWALLOW
DO_INSERT

enum otawa::code_part_t

Enumerator
PROLOGUE
BLOCK
EPILOGUE
CODE_PARTS_NUMBER

enum otawa::delayed_t

Enumeration giving the type of delayed modes used by control instruction.

Enumerator
DELAYED_None	No delayed instruction.
DELAYED_Always	The delayed instruction is ever executed, branch taken or not.
DELAYED_Taken	The delayed instruction is only executed when the branch is taken.

enum otawa::fmlevel

Enumerator
FML_INNER
FML_OUTER
FML_MULTI
FML_NONE

enum otawa::instruction_category_t

Enumerator
IALU
FALU
MEMORY
CONTROL
MUL
DIV
INST_CATEGORY_NUMBER

Function Documentation

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

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

This property provides statistics about ADDRESS_ANALYSIS_FEATURE.

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

Identifier<int> otawa::ARGC	(	"otawa::ARGC"	,
		-	1
	)

Argument count as passed to the program (int).

Identifier<char **> otawa::ARGV	(	"otawa::ARGV"	,
		0
	)

Argument values as passed to the program (char **).

Identifier<Address> otawa::ARGV_ADDRESS	(	"otawa::ARGV_ADDRESS"	,
		Address::null
	)

This feature is put on the process object whose image supports Unix-like argument passing.

It contains the image address of the argv vector. Hooks

• Process

Identifier<Address> otawa::AUXV_ADDRESS	(	"otawa::AUXV_ADDRESS"	,
		Address::null
	)

This feature is put on the process object whose image supports Unix-like argument passing.

It contains the image address of the auxv vector. Hooks

• Process

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

Identifier for marking back edges.

Hooks

• BasicBlock

Identifier<genstruct::AllocatedTable<LBlock* >* > otawa::BB_LBLOCKS	(	"otawa::BB_LBLOCKS"	,
		0
	)

This property is used for storing the list of L-Blocks of a BasicBlock.

cache.

Hooks

• BasicBlock

Identifier<genstruct::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

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

Identifier<genstruct::Vector<MUSTProblem::Domain*>* > otawa::CACHE_ACS_MUST	(	"otawa::CACHE_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

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

This property allows us to set an entry must ACS.

Hooks

• PropList

Identifier<genstruct::Vector<PERSProblem::Domain*>* > otawa::CACHE_ACS_PERS	(	"otawa::CACHE_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

Identifier<hard::CacheConfiguration *> otawa::CACHE_CONFIG	(	"otawa::CACHE_CONFIG"	,
		0
	)

This property is used to pass the cache configuration directly to the platform.

Identifier<elm::xom::Element *> otawa::CACHE_CONFIG_ELEMENT	(	"otawa::CACHE_CONFIG_ELEMENT"	,
		0
	)

Gives an XML element containing the cache configuration.

Identifier<elm::system::Path> otawa::CACHE_CONFIG_PATH	(	"otawa::CACHE_CONFIG_PATH"	,
		""
	)

Gives the path of file containing the cache configuration.

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

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

Identifier<CFG *> otawa::CALLED_CFG	(	"otawa::CALLED_CFG"	,
		0
	)

A property with this identifier is hooked to the edges performing virtual calls and virtual returns when inlining is used.

The associated value is the CFG of the called function.

Hooks

• Edge

Features

• VIRTUALIZED_CFG_FEATURE

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

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

Identifier<Address> otawa::CFG_START

(

"otawa::CFG_START"

)

Configuration of otawa::SubCFGBuilder specifying the start of the sub-CFG to process.

If not provided, the start is assumed to be the ENTRY of the CFG.

Identifier<Address> otawa::CFG_STOP

(

"otawa::CFG_STOP"

)

Configuration of otawa::SubCFGBuilder specifying a end of the sub-CFG to process.

Several properties of this type are accepted. If not provided, the stop is assumed to be the EXIT of the original CFG.

Feature<LBlockBuilder> otawa::COLLECTED_LBLOCKS_FEATURE

(

"otawa::COLLECTED_LBLOCKS_FEATURE"

)

This properties is set on the first instruction of each lblock and points to the lblock.

Hooks

• Inst This feature ensures that the L-blocks of the current task has been collected.

Properties

• LBLOCKS
• BB_LBLOCKS

Identifier<elm::xom::Element *> otawa::CONFIG_ELEMENT	(	"otawa::CONFIG_ELEMENT"	,
		0
	)

XML element containing the configuration of the current computation.

Identifier<elm::system::Path> otawa::CONFIG_PATH	(	"otawa::CONFIG_PATH"	,
		""
	)

Path to the XML configuration file used in this computation.

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

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).

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).

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

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

This feature is usually provided by the loader providing decoding facility for control instructions.

Provided Methods

• Inst::target()

Feature<DeadCodeAnalysis> otawa::DEAD_CODE_ANALYSIS_FEATURE

(

"otawa::DEAD_CODE_ANALYSIS_FEATURE"

)

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

• FUNCTION_LABEL
• LABEL

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

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

inline

References DEF_BY, and make().

Identifier<delayed_t> otawa::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.

Feature

• otawa::DELAYED_FEATURE

Hook

• otawa::Inst (control instruction)

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

This Process feature informs that the actual architecture supports delayed branch.

Properties

• DELAYED_INFO

p::feature otawa::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.

Provider

• program loader

Properties

• otawa::DELAYED

Identifier<DelayedInfo *> otawa::DELAYED_INFO	(	"otawa::DELAYED_INFO"	,
		0
	)

This property provides access to delayed branch information of the current program.

Hooks

• WorkSpace

Features

• DELAYED2_FEATURE

SilentFeature otawa::DOMINANCE_FEATURE	(	"otawa::DOMINANCE_FEATURE"	,
		DOMINANCE_MAKER
	)

This feature ensures that information about domination between nodes of a CFG is vailable.

Include

<otawa/util/Dominance.h>

Properties

• REVERSE_DOM (BasicBlock)

Identifier<BasicBlock*> 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 basicblock If the basicblock is a loop header, then, the property contains the header of the parent loop.

Hooks

• BasicBlock

Identifier<CFG *> otawa::ENTRY_CFG	(	"otawa::entry_cfg"	,
		0
	)

This property may be used to pass the entry CFG to a CFG processor or is used by the CFG processor to record in the framework the entry CFG of the currently processed task.

Identifier<char **> otawa::ENVP	(	"otawa::ENVP"	,
		0
	)

Argument values as passed to the program (char **).

Identifier<Address> otawa::ENVP_ADDRESS	(	"otawa::ENVP_ADDRESS"	,
		Address::null
	)

This feature is put on the process object whose image supports Unix-like argument passing.

It contains the image address of the envp vector. Hooks

• Process

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< T >::printFormatted().

Identifier<elm::genstruct::Vector<Edge*>*> otawa::EXIT_LIST	(	"otawa::EXIT_LIST"	,
		0
	)

Defined for any BasicBlock that is a loop header.

Contain a list of the exit edges associated with the loop (more clearly, EXIT_LIST(h) is the list of the edges for which LOOP_EXIT_EDGE(edge) == h)

Hooks

• BasicBlock

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)

p::feature otawa::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.

Provided Methods

• Process::get(Address, float&),
• Process::get(Address, double&),
• Process::get(Address, long double&),

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

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

This property is like.

• otawa::FROM_BB but for edges

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

This property is put on instruction.

An instruction may accept many properties of this type.

Identifier<String> otawa::GRAPHS_DIR	(	"graphs directory"	,
		""
	)

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

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

This feature represents the availability of Abstract Cache State informations.

Properties

• CACHE_ACS

Processors

• ACSBuilder (default)

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

SilentFeature otawa::ICACHE_CATEGORY2_FEATURE	(	"otawa::ICACHE_CATEGORY2_FEATURE"	,
		cat_maker
	)

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

• CATEGORY
• CATEGORY_HEADER

Processors

• CAT2Builder (default)

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

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

Feature<EdgeCAT2Builder> otawa::ICACHE_EDGE_CATEGORY2_FEATURE

(

"otawa::ICACHE_EDGE_CATEGORY2_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

• LAST_LBLOCK
• LBLOCK_ISFIRST

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

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

Property* otawa::idDesc ( cstring  desc )

inline

References IDENTIFIER_DESC, and make().

Property* otawa::idLabel ( cstring  label )

inline

References IDENTIFIER_LABEL, and make().

instruction_category_t otawa::instCategory

(

Inst *

inst

)

References CONTROL, FALU, IALU, otawa::Inst::kind(), kind, MEMORY, and MUL.

Referenced by otawa::ParamExeGraph::dumpSimple().

const Level otawa::L1

(

1

)

const Level otawa::L2

(

2

)

const Level otawa::L3

(

3

)

const Level otawa::L4

(

4

)

const Level otawa::L5

(

5

)

const Level otawa::L6

(

6

)

const Level otawa::L7

(

7

)

const Level otawa::L8

(

8

)

const Level otawa::L9

(

9

)

Identifier<String> otawa::LABEL	(	"otawa::LABEL"	,
		""	,
		idLabel("label")	,
		idDesc("label in assembly code")	,
		0
	)

Property with this identifier is put on instructions or basic blocks which a symbol is known for.

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

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

Identifier<LBlockSet **> otawa::LBLOCKS	(	"otawa::LBLOCKS"	,
		0
	)

This property is used for storing the list of L-Blocks.

The type of its date is LBlockSet *[] with a size equal to the line count of the instruction cache.

Hooks

• FrameWork

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.

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

!!TODO!!

Identifier<string> otawa::LOAD_PARAM	(	"otawa::LOAD_PARAM"	,
		""
	)

Identifier used for Manager::load() configuration.

For complex loading ISA, several properties with such an identifier may be put in the configuration property list. Its arguments is a string of the form ID=VALUE where ID is an identifier of the XXX-config.xml of the loader and VALUE the matching value.

Identifier<Loader *> otawa::LOADER	(	"otawa::LOADER"	,
		0
	)

Identifier of the property indicating the loader to use.

Identifier<CString> otawa::LOADER_NAME	(	"otawa::LOADER_NAME"	,
		""
	)

Identifier of the property indicating a name (CString) of the loader to use.

Identifier<elm::io::OutStream *> otawa::LOG	(	"otawa::LOG"	,
		&io::err
	)

This property identifier is used for setting the log stream used by the processor to write messages (information, warning, error).

Identifier<Monitor::log_level_t> otawa::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.

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

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

Is defined for an Edge if this Edge is the exit-edge of any loop.

If this is the case, then, the property contains the header of the loop exited by the edge. If the edge exits more than one loop, the property contains the header of the outer loop.

Hooks

• Edge

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

Identifier for marking basic blocks that are entries of loops.

Hooks

• BasicBlock

SilentFeature otawa::LOOP_HEADERS_FEATURE	(	"otawa::LOOP_HEADERS_FEATURE"	,
		LOOP_HEADERS_MAKER
	)

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>

• LOOP_HEADER (BasicBlock).
• BACK_EDGE (Edge).

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

• ENCLOSING_LOOP_HEADER (BasicBlock)
• LOOP_EXIT_EDGE (Edge)
• EXIT_LIST (BasicBlock)

template<class T >

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

inline

Referenced by defBy(), idDesc(), idLabel(), and make().

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

inline

References make().

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

inline

References make().

p::feature otawa::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.

Provided Methods

• Process::get() family of methods.

p::feature otawa::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.

Provider

• Process

Activated Methods

• otawa::sim::State::lowerRead()
• otawa::sim::State::upperRead()
• otawa::sim::State::lowerWrite()
• otawa::sim::State::upperWrite()

Identifier<elm::xom::Element *> otawa::MEMORY_ELEMENT	(	"otawa::MEMORY_ELEMENT"	,
		0
	)

Passed to manager::load() to give the XML element describing the memory configuration.

This property is often used with an XML file containing different configurations.

Identifier<hard::Memory *> otawa::MEMORY_OBJECT	(	"otawa::MEMORY_OBJECT"	,
		0
	)

Passed to manager::load() to set the memory configuration.

The user is responsible of the release of the memory occipied by the memory object.

Identifier<elm::system::Path> otawa::MEMORY_PATH	(	"otawa::MEMORY_PATH"	,
		""
	)

Passed to Manager::load() to give the path of the file describing the memory.

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

Feature<FlowFactLoader> otawa::MKFF_PRESERVATION_FEATURE

(

"otawa::MKFF_PRESERVATION_FEATURE"

)

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

Hooked Properties

• PRESERVED

Identifier<bool> otawa::NEVER_TAKEN

(

"otawa::NEVER_TAKEN"

)

Identifier<string> otawa::NO_RETURN_FUNCTION	(	"otawa::NO_RETURN_FUNCTION"	,
		""
	)

this property may be used to pass information about the non-returning behaviour of some functions.

The parameter is the name of the function. It is often used with the _exit function.

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

This property shows that no stack need to be allocated.

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

This property shows that the system does not need to by simulated when the binary image is built.

Feature<CFGNormalizer> otawa::NORMALIZED_CFGS_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.

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

References FML_NONE, and out.

Output& otawa::operator<< ( Output &  out, const PCG &  pcg  )

inline

References out.

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

inline

References out, and otawa::Symbol::print().

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

References out.

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

inline

References out, and otawa::SymAddress::print().

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

inline

References out, and otawa::ContextualStep::print().

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

References out.

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

References out.

Output & otawa::operator<<	(	Output &	out,
		const LBlock *	block
	)

References otawa::LBlock::lblockset(), otawa::LBlockSet::line(), otawa::LBlock::number(), and out.

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

inline

References out, and otawa::Property::print().

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

inline

References out.

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

inline

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

inline

References out, and otawa::AccessedAddress::print().

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

inline

References otawa::Level::_level, and otawa::Trace::checkLevel().

template<class T , class I >

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

References out.

template<class T , class I >

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

References out.

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

inline

References out, and otawa::CFG::print().

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

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

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

inline

References out, and otawa::AccessedAddresses::print().

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

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

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

inline

References out, and otawa::AccessedAddresses::print().

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

inline

References out, and otawa::PropList::print().

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

inline

References out, and otawa::PropList::print().

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

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

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

inline

References otawa::Inst::dump(), and out.

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

inline

References out.

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

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

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

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

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

inline

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

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

inline

References out, and otawa::BasicBlock::print().

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

inline

References out, and otawa::ContextualPath::print().

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

template<class T >

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

inline

References out.

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

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

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

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

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

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

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

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

Identifier<elm::io::OutStream *> otawa::OUTPUT	(	"otawa::OUTPUT"	,
		&io::out
	)

This property identifier is used for setting the output stream used by the processor to write results.

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

Identifier<String> otawa::OUTPUT_FILE	(	"output file name"	,
		""
	)

Identifier<int> otawa::OUTPUT_LEVEL	(	"output level"	,
		0
	)

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.

Feature<PCGBuilder> otawa::PCG_FEATURE

(

"otawa::PCG_FEATURE"

)

This feature ensure that a PCG is provided.

Properties

• PCG::ID (FrameWork)

Identifier<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.

Identifier<hard::Platform *> otawa::PLATFORM	(	"otawa::PLATFORM"	,
		0
	)

Identifier of the property indicating a platform (Platform *) to use.

Identifier<CString> otawa::PLATFORM_NAME	(	"otawa::PLATFORM_NAME"	,
		""
	)

Identifier of the property indicating the name (CString) of the platform to use.

Feature<PostDominance> otawa::POSTDOMINANCE_FEATURE

(

"otawa::POSTDOMINANCE_FEATURE"

)

This feature ensures that information about postdomination between nodes of a CFG is vailable.

Properties

• REVERSE_DOM (BasicBlock)

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

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

Identifier<hard::Processor *> otawa::PROCESSOR	(	"otawa::PROCESSOR"	,
		0
	)

Gives the processor to use in the current computation.

Identifier<elm::xom::Element *> otawa::PROCESSOR_ELEMENT	(	"otawa::PROCESSOR_ELEMENT"	,
		0
	)

XML element containing the configuration of the processor.

Identifier<elm::system::Path> otawa::PROCESSOR_PATH	(	"otawa::PROCESSOR_PATH"	,
		""
	)

Path to the XML configuration file of the processor.

Identifier<PSTree *> otawa::PROGRAM_STRUCTURE_TREE	(	"otawa::PROGRAM_STRUCTURE_TREE"	,
		0
	)

This property points to the Program Structure Tree of the CFG.

Hooks

• CFG

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

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

SilentFeature otawa::PST_FEATURE	(	"otawa::PST_FEATURE"	,
		PST_MAKER
	)

This feature represents the availability of the Program Structure Tree.

Properties

• otawa::PROGRAM_STRUCTURE_TREE

Identifier<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 !

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

SilentFeature otawa::REDUCED_LOOPS_FEATURE	(	"otawa::REDUCED_LOOPS_FEATURE"	,
		REDUCED_LOOPS_MAKER
	)

p::feature otawa::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.

Provided Methods

• Inst::readRegs(void);
• Inst::writtenRegs(void);

template<class T >

const AbstractRegistration& otawa::registration ( void  )

inline

Referenced by otawa::Processor::Processor().

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

This property is put on a returning basic block and provides the matching entry block of the function.

Hooks

• BasicBlock

Features

• VIRTUALIZED_CFG_FEATURE

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

Identifier of annotation containing reverse-dominance information.

Hooks

• BasicBlock

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

Identifier of annotation containing reverse-postdominance information.

Hooks

• BasicBlock

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

This feature is present when the loader provides implementation of semantics information.

Provider

• Process

Activated Methods

• otawa::Inst::semInsts() method.

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

This feature is present when the loader provides implementation of extended semantics information.

This feature ensures that the following semantics instruction are generated:

• NEG
• NOT
• AND
• OR
• XOR
• MUL
• MULU
• DIV
• DIVU
• MOD
• MODU
• SPEC

Provider

• Process

Activated Methods

• otawa::Inst::semInsts() method.

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

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

Note

This is a future feature as, currently, no floating-point instruction exists.

Provider

• Process

Activated Methods

• otawa::Inst::semInsts() method.

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

inline

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

Identifier<sim::Simulator *> otawa::SIMULATOR	(	"otawa::SIMULATOR"	,
		0
	)

This property defines the used the used simulator when a simulator is needed to perform simulation.

Identifier<elm::CString> otawa::SIMULATOR_NAME	(	"otawa::SIMULATOR_NAME"	,
		""
	)

Name of the simulator to use.

p::feature otawa::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.

Provided Methods

• Process::getSourceLine()
• Process::getAddresses()

Identifier<Address> otawa::SP_ADDRESS	(	"otawa::SP_ADDRESS"	,
		Address::null
	)

This feature is put on the process to get information about the built image.

It contains the startup address of the stack pointer. Hooks

• Process

Identifier<bool> otawa::START	(	"otawa.exegraph.start"	,
		false
	)

Identifier<Address> otawa::TASK_ADDRESS	(	"otawa::TASK_ADDRESS"	,
		Address::null
	)

This property, passed to the load configuration, select the task entry by its address.

Identifier<string> otawa::TASK_ENTRY	(	"otawa::TASK_ENTRY"	,
		"main"
	)

This property, passed to the load configuration, gives the name of the entry function of the current task.

template<class T >

const Type& otawa::type ( void  )

inline

References otawa::__type< T >::_().

Referenced by otawa::Type::equals(), otawa::Type::getBaseType(), otawa::hard::Dispatch::getType(), otawa::hard::Stage::getType(), otawa::ilp::operator<<(), otawa::sem::operator<<(), otawa::CachePenalty::penalty(), otawa::FlowFactLoader::scanMemSet(), otawa::CachePenalty::setPenalty(), otawa::sem::size(), and yyparse().

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

This property activates the verbose mode of the processor: information about the processor work will be displayed.

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

Identifier<bool> otawa::VIRTUAL_INLINING	(	"otawa::VIRTUAL_INLINING"	,
		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.

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

This property is put on a BB performing a function call that has been virtualized (inlined in the current CFG).

It gives the BB after the return of the inlined CFG. It is useful to jump over inlinved CFG.

Hooks

• BasicBlock

Features

• 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>

Properties

• CALLED_CFG
• RECURSIVE_LOOP
• VIRTUAL_RETURN_BLOCK
• RETURN_OF

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

This feature is provided on Process objects by architecture implementing VLIW facilities.

This means mainly that Inst::IS_BUNDLE and Inst::semWriteBack() are used in instructions.

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

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

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().

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

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

This property provides statistics about ADDRESS_ANALYSIS_FEATURE.

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

Referenced by otawa::dcache::BlockBuilder::processBB().

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

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

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

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

Identifier<int> otawa::ARGC("otawa::ARGC",-1)

Argument count as passed to the program (int).

Identifier<char **> otawa::ARGV("otawa::ARGV", 0)

Argument values as passed to the program (char **).

Identifier<Address> otawa::ARGV_ADDRESS("otawa::ARGV_ADDRESS", Address::null)

This feature is put on the process object whose image supports Unix-like argument passing.

It contains the image address of the argv vector. Hooks

• Process

Identifier<Address> otawa::AUXV_ADDRESS("otawa::AUXV_ADDRESS", Address::null)

This feature is put on the process object whose image supports Unix-like argument passing.

It contains the image address of the auxv vector. Hooks

• Process

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

Identifier for marking back edges.

Hooks

• BasicBlock

Referenced by otawa::LoopReductor::depthFirstSearch(), otawa::Dominance::isBackEdge(), otawa::Dominance::markLoopHeaders(), and otawa::EdgeCAT2Builder::processLBlockSet().

Identifier<genstruct::AllocatedTable<LBlock* >* > otawa::BB_LBLOCKS("otawa::BB_LBLOCKS", 0)

This property is used for storing the list of L-Blocks of a BasicBlock.

cache.

Hooks

• BasicBlock

Referenced by otawa::LBlockManager::next(), otawa::LBlockBuilder::processBB(), otawa::etime::StandardEventBuilder::processBB(), and otawa::FirstLastBuilder::processCFG().

Identifier<genstruct::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

Referenced by otawa::ACSMayBuilder::processLBlockSet(), otawa::CAT2Builder::processLBlockSet(), and otawa::ACSMayBuilder::processWorkSpace().

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().

Identifier<genstruct::Vector<MUSTProblem::Domain*>* > otawa::CACHE_ACS_MUST("otawa::CACHE_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

Referenced by otawa::ACSBuilder::processLBlockSet(), otawa::CAT2Builder::processLBlockSet(), and otawa::ACSBuilder::processWorkSpace().

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

This property allows us to set an entry must ACS.

Hooks

• PropList

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

Identifier<genstruct::Vector<PERSProblem::Domain*>* > otawa::CACHE_ACS_PERS("otawa::CACHE_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

Referenced by otawa::ACSBuilder::processLBlockSet(), otawa::CAT2Builder::processLBlockSet(), and otawa::ACSBuilder::processWorkSpace().

Identifier<hard::CacheConfiguration *> otawa::CACHE_CONFIG("otawa::CACHE_CONFIG", 0)

This property is used to pass the cache configuration directly to the platform.

Referenced by otawa::hard::Platform::configure().

Identifier<elm::xom::Element *> otawa::CACHE_CONFIG_ELEMENT("otawa::CACHE_CONFIG_ELEMENT", 0)

Gives an XML element containing the cache configuration.

Referenced by otawa::hard::Platform::configure(), and otawa::script::Script::work().

Identifier<elm::system::Path> otawa::CACHE_CONFIG_PATH("otawa::CACHE_CONFIG_PATH","")

Gives the path of file containing the cache configuration.

Referenced by otawa::hard::Platform::configure(), and otawa::GraphBBTime< G >::configure().

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

Referenced by otawa::EdgeCAT2Builder::processLBlockSet().

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

Referenced by otawa::EdgeCAT2Builder::processLBlockSet().

Identifier<CFG *> otawa::CALLED_CFG("otawa::CALLED_CFG", 0)

A property with this identifier is hooked to the edges performing virtual calls and virtual returns when inlining is used.

The associated value is the CFG of the called function.

Hooks

• Edge

Features

• VIRTUALIZED_CFG_FEATURE

Referenced by otawa::DelayedBuilder::fix(), otawa::PSTBuilder::getVCFG(), otawa::BBStatCollector::processCFG(), otawa::ContextualProcessor::processCFG(), otawa::LoopReductor::reduce(), otawa::LoopUnroller::unroll(), otawa::VirtualCFG::virtualize(), and otawa::Virtualizer::virtualize().

Identifier< category_t > & otawa::CATEGORY = cache::CATEGORY

Referenced by otawa::LBlockManager::next().

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

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

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

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

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

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

Identifier<Address> otawa::CFG_START("otawa::CFG_START")

Configuration of otawa::SubCFGBuilder specifying the start of the sub-CFG to process.

If not provided, the start is assumed to be the ENTRY of the CFG.

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

Identifier<Address> otawa::CFG_STOP("otawa::CFG_STOP")

Configuration of otawa::SubCFGBuilder specifying a end of the sub-CFG to process.

Several properties of this type are accepted. If not provided, the stop is assumed to be the EXIT of the original CFG.

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

Feature<LBlockBuilder> otawa::COLLECTED_LBLOCKS_FEATURE("otawa::COLLECTED_LBLOCKS_FEATURE")

This properties is set on the first instruction of each lblock and points to the lblock.

Hooks

• Inst This feature ensures that the L-blocks of the current task has been collected.

Properties

• LBLOCKS
• BB_LBLOCKS

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

Identifier<elm::xom::Element *> otawa::CONFIG_ELEMENT("otawa::CONFIG_ELEMENT", 0)

XML element containing the configuration of the current computation.

Referenced by otawa::WorkSpace::config(), otawa::hard::Platform::configure(), otawa::Manager::load(), otawa::WorkSpace::loadConfig(), and otawa::Manager::loadXML().

Identifier<elm::system::Path> otawa::CONFIG_PATH("otawa::CONFIG_PATH","")

Path to the XML configuration file used in this computation.

Referenced by otawa::WorkSpace::config(), and otawa::Manager::load().

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::ContextTreeByCFGBuilder::processCFG(), otawa::cat::CATConstraintBuilder::processLBlockSet(), otawa::cat::CATBuilder::processLBlockSet(), otawa::ccg::ConstraintBuilder::processLBlockSet(), and otawa::ContextTreeBuilder::processWorkSpace().

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().

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().

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

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

This feature is usually provided by the loader providing decoding facility for control instructions.

Provided Methods

• Inst::target()

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

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

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

• FUNCTION_LABEL
• LABEL

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

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().

Identifier<delayed_t> otawa::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.

Feature

• otawa::DELAYED_FEATURE

Hook

• otawa::Inst (control instruction)

Referenced by otawa::DelayedBuilder::type().

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

This Process feature informs that the actual architecture supports delayed branch.

Properties

• DELAYED_INFO

Referenced by otawa::DelayedBuilder::setup().

p::feature otawa::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.

Provider

• program loader

Properties

• otawa::DELAYED

Identifier<DelayedInfo *> otawa::DELAYED_INFO("otawa::DELAYED_INFO", 0)

This property provides access to delayed branch information of the current program.

Hooks

• WorkSpace

Features

• DELAYED2_FEATURE

Referenced by otawa::DelayedBuilder::setup().

SilentFeature otawa::DOMINANCE_FEATURE("otawa::DOMINANCE_FEATURE", DOMINANCE_MAKER)

This feature ensures that information about domination between nodes of a CFG is vailable.

Include

<otawa/util/Dominance.h>

Properties

• REVERSE_DOM (BasicBlock)

Referenced by otawa::ContextTreeBuilder::ContextTreeBuilder(), otawa::ContextTreeByCFGBuilder::ContextTreeByCFGBuilder(), otawa::Dominance::Dominance(), otawa::EdgeACSBuilder::EdgeACSBuilder(), otawa::EdgeCAT2Builder::EdgeCAT2Builder(), otawa::EdgeCAT2ConstraintBuilder::EdgeCAT2ConstraintBuilder(), otawa::FirstLastBuilder::FirstLastBuilder(), and otawa::Dominance::processCFG().

Identifier<BasicBlock*> 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 basicblock If the basicblock is a loop header, then, the property contains the header of the parent loop.

Hooks

• BasicBlock

Referenced by otawa::branch::BranchBuilder::categorize(), otawa::ContextTree::ContextTree(), otawa::etime::StandardEventBuilder::processBB(), otawa::EdgeCAT2Builder::processLBlockSet(), otawa::dcache::CATBuilder::processLBlockSet(), otawa::CAT2Builder::processLBlockSet(), and otawa::LoopUnroller::unroll().

Identifier< CFG * > otawa::ENTRY_CFG

This property may be used to pass the entry CFG to a CFG processor or is used by the CFG processor to record in the framework the entry CFG of the currently processed task.

Referenced by otawa::LoopUnroller::cleanup(), otawa::SubCFGBuilder::cleanup(), otawa::DelayedBuilder::cleanup(), otawa::Virtualizer::cleanup(), otawa::CFGCollector::configure(), otawa::Virtualizer::configure(), otawa::ccg::Problem::gen(), otawa::ccg::Builder::processLBlockSet(), otawa::PCGBuilder::processWorkSpace(), otawa::LoopReductor::processWorkSpace(), otawa::LoopUnroller::processWorkSpace(), otawa::SubCFGBuilder::processWorkSpace(), otawa::CFGCollector::processWorkSpace(), otawa::ipet::BasicConstraintsBuilder::processWorkSpace(), otawa::display::ILPSystemDisplayer::processWorkSpace(), otawa::ContextTreeBuilder::processWorkSpace(), and otawa::BBRatioDisplayer::setup().

Identifier<char **> otawa::ENVP("otawa::ENVP", 0)

Argument values as passed to the program (char **).

Identifier<Address> otawa::ENVP_ADDRESS("otawa::ENVP_ADDRESS", Address::null)

This feature is put on the process object whose image supports Unix-like argument passing.

It contains the image address of the envp vector. Hooks

• Process

Identifier<elm::genstruct::Vector<Edge*>*> otawa::EXIT_LIST("otawa::EXIT_LIST", 0)

Defined for any BasicBlock that is a loop header.

Contain a list of the exit edges associated with the loop (more clearly, EXIT_LIST(h) is the list of the edges for which LOOP_EXIT_EDGE(edge) == h)

Hooks

• BasicBlock

Referenced by otawa::dfa::hai::HalfAbsInt< FixPoint >::outputProcessing(), and otawa::LoopUnroller::unroll().

int otawa::fft_line = 0

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

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

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

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

Referenced by otawa::LBlockManager::next(), otawa::EdgeCAT2Builder::processLBlockSet(), and otawa::EdgeCAT2ConstraintBuilder::processWorkSpace().

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().

p::feature otawa::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.

Provided Methods

• Process::get(Address, float&),
• Process::get(Address, double&),
• Process::get(Address, long double&),

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

Referenced by otawa::PSTBuilder::getVCFG().

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

This property is like.

• otawa::FROM_BB but for edges

Referenced by otawa::PSTBuilder::getVCFG().

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

This property is put on instruction.

An instruction may accept many properties of this type.

Referenced by otawa::PFGBuilder::addFunction(), otawa::CFG::CFG(), otawa::display::CFGOutput::genBBLabel(), otawa::CFG::label(), otawa::display::CFGDrawer::onNode(), otawa::TextDecoder::processWorkSpace(), and otawa::CFGProcessor::str().

Identifier<String> otawa::GRAPHS_DIR("graphs directory","")

Referenced by otawa::ParamExeGraphBBTime::ParamExeGraphBBTime().

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

Referenced by otawa::GraphBBTime< G >::configure().

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

This feature represents the availability of Abstract Cache State informations.

Properties

• CACHE_ACS

Processors

• ACSBuilder (default)

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

SilentFeature otawa::ICACHE_CATEGORY2_FEATURE("otawa::ICACHE_CATEGORY2_FEATURE", cat_maker)

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

• CATEGORY
• CATEGORY_HEADER

Processors

• CAT2Builder (default)

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

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

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().

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

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

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

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

Properties

• LAST_LBLOCK
• LBLOCK_ISFIRST

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

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().

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

Referenced by otawa::GraphBBTime< G >::analyzePathContext(), and otawa::ipet::CachePenaltiesObjectFunctionBuilder::processBB().

const category_t otawa::INVALID_CATEGORY = otawa::cache::INVALID_CATEGORY

Referenced by otawa::GraphBBTime< G >::buildFMTimingContextListForICache(), otawa::GraphBBTime< G >::buildNCTimingContextListForICache(), and otawa::LBlockManager::next().

Identifier< bool > otawa::IS_FEATURE

Referenced by otawa::AbstractFeature::AbstractFeature(), and otawa::ProcessorPlugin::getFeature().

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

Referenced by otawa::SubCFGBuilder::floodBackward(), and otawa::SubCFGBuilder::processWorkSpace().

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

Referenced by otawa::SubCFGBuilder::floodForward(), and otawa::SubCFGBuilder::processWorkSpace().

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

Referenced by otawa::SubCFGBuilder::floodBackward(), and otawa::SubCFGBuilder::processWorkSpace().

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

Referenced by otawa::SubCFGBuilder::floodForward(), and otawa::SubCFGBuilder::processWorkSpace().

const Level otawa::L1(1)

const Level otawa::L2(2)

const Level otawa::L3(3)

Referenced by otawa::ParamExeGraph::cost().

const Level otawa::L4(4)

const Level otawa::L5(5)

const Level otawa::L6(6)

const Level otawa::L7(7)

const Level otawa::L8(8)

Referenced by otawa::ParamExeGraph::Delta().

const Level otawa::L9(9)

Referenced by otawa::ParamExeGraph::analyzeContentions().

Identifier<String> otawa::LABEL("otawa::LABEL","", idLabel("label"), idDesc("label in assembly code"), 0)

Property with this identifier is put on instructions or basic blocks which a symbol is known for.

Referenced by otawa::CFG::CFG(), otawa::CodeBasicBlock::CodeBasicBlock(), otawa::ets::WCETComputation::computation(), otawa::ast::FunAST::FunAST(), otawa::display::CFGOutput::genBBLabel(), otawa::CFG::label(), otawa::display::CFGDrawer::onNode(), otawa::TextDecoder::processWorkSpace(), otawa::LoopReductor::processWorkSpace(), and otawa::LoopUnroller::processWorkSpace().

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

Referenced by otawa::FirstLastBuilder::processCFG(), otawa::MUSTPERS::update(), otawa::MAYProblem::update(), and otawa::MUSTProblem::update().

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

Referenced by otawa::FirstLastBuilder::processCFG(), and otawa::CAT2Builder::processLBlockSet().

Identifier<LBlockSet **> otawa::LBLOCKS("otawa::LBLOCKS", 0)

This property is used for storing the list of L-Blocks.

The type of its date is LBlockSet *[] with a size equal to the line count of the instruction cache.

Hooks

• FrameWork

Referenced by otawa::CAT2Builder::processCFG(), otawa::EdgeCAT2Builder::processCFG(), otawa::LBlockProcessor::processWorkSpace(), otawa::EdgeCAT2ConstraintBuilder::processWorkSpace(), otawa::CAT2OnlyConstraintBuilder::processWorkSpace(), otawa::ACSMayBuilder::processWorkSpace(), otawa::LinkedBlocksDetector::processWorkSpace(), otawa::ACSBuilder::processWorkSpace(), otawa::cat::CATConstraintBuilder::processWorkSpace(), otawa::cat::CATBuilder::processWorkSpace(), otawa::CAT2ConstraintBuilder::processWorkSpace(), otawa::EdgeACSBuilder::processWorkSpace(), and otawa::LBlockBuilder::setup().

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

!!TODO!!

Referenced by otawa::CAT2OnlyConstraintBuilder::processWorkSpace(), and otawa::LinkedBlocksDetector::recordBlocks().

Identifier<string> otawa::LOAD_PARAM("otawa::LOAD_PARAM","")

Identifier used for Manager::load() configuration.

For complex loading ISA, several properties with such an identifier may be put in the configuration property list. Its arguments is a string of the form ID=VALUE where ID is an identifier of the XXX-config.xml of the loader and VALUE the matching value.

Referenced by otawa::Manager::loadBin(), and otawa::Application::run().

Identifier<Loader *> otawa::LOADER("otawa::LOADER", 0)

Identifier of the property indicating the loader to use.

Referenced by otawa::Manager::loadBin().

Identifier<CString> otawa::LOADER_NAME("otawa::LOADER_NAME","")

Identifier of the property indicating a name (CString) of the loader to use.

Referenced by otawa::Manager::loadBin().

Identifier<elm::io::OutStream *> otawa::LOG("otawa::LOG",&io::err)

This property identifier is used for setting the log stream used by the processor to write messages (information, warning, error).

Identifier<Monitor::log_level_t> otawa::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.

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

Is defined for an Edge if this Edge is the exit-edge of any loop.

If this is the case, then, the property contains the header of the loop exited by the edge. If the edge exits more than one loop, the property contains the header of the outer loop.

Hooks

• Edge

Referenced by otawa::dfa::hai::HalfAbsInt< FixPoint >::isEdgeDone(), otawa::EdgeCAT2Builder::processLBlockSet(), and otawa::LoopUnroller::unroll().

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

Identifier for marking basic blocks that are entries of loops.

Hooks

• BasicBlock

Referenced by otawa::ContextTree::ContextTree(), otawa::LoopReductor::depthFirstSearch(), otawa::dfa::hai::HalfAbsInt< FixPoint >::inputProcessing(), otawa::Dominance::isLoopHeader(), otawa::ForwardCFGAdapter::isLoopHeader(), otawa::BackwardCFGAdapter::isLoopHeader(), otawa::Dominance::markLoopHeaders(), otawa::dfa::hai::HalfAbsInt< FixPoint >::outputProcessing(), otawa::ipet::FlowFactLoader::processBB(), otawa::ipet::FlowFactConstraintBuilder::processBB(), otawa::EdgeCAT2Builder::processLBlockSet(), otawa::dcache::CATBuilder::processLBlockSet(), otawa::CAT2Builder::processLBlockSet(), otawa::dfa::hai::HalfAbsInt< FixPoint >::tryAddToWorkList(), and otawa::LoopUnroller::unroll().

SilentFeature otawa::LOOP_HEADERS_FEATURE("otawa::LOOP_HEADERS_FEATURE", LOOP_HEADERS_MAKER)

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>

• LOOP_HEADER (BasicBlock).
• BACK_EDGE (Edge).

Referenced by otawa::ContextTreeBuilder::ContextTreeBuilder(), otawa::ContextTreeByCFGBuilder::ContextTreeByCFGBuilder(), otawa::Dominance::Dominance(), otawa::EdgeACSBuilder::EdgeACSBuilder(), otawa::EdgeCAT2Builder::EdgeCAT2Builder(), otawa::FirstLastBuilder::FirstLastBuilder(), otawa::ipet::FlowFactConstraintBuilder::FlowFactConstraintBuilder(), and otawa::LoopReductor::LoopReductor().

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

• ENCLOSING_LOOP_HEADER (BasicBlock)
• LOOP_EXIT_EDGE (Edge)
• EXIT_LIST (BasicBlock)

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

Manager otawa::MANAGER

Default manager.

Avoid to declare one in the main.

Referenced by otawa::script::Script::declareGlobals(), otawa::ProcessorPlugin::init(), and otawa::Application::run().

p::feature otawa::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.

Provided Methods

• Process::get() family of methods.

Referenced by otawa::Process::get().

p::feature otawa::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.

Provider

• Process

Activated Methods

• otawa::sim::State::lowerRead()
• otawa::sim::State::upperRead()
• otawa::sim::State::lowerWrite()
• otawa::sim::State::upperWrite()

Referenced by otawa::SimState::lowerRead(), otawa::SimState::lowerWrite(), otawa::SimState::upperRead(), and otawa::SimState::upperWrite().

Identifier<elm::xom::Element *> otawa::MEMORY_ELEMENT("otawa::MEMORY_ELEMENT", 0)

Passed to manager::load() to give the XML element describing the memory configuration.

This property is often used with an XML file containing different configurations.

Referenced by otawa::hard::Platform::configure(), and otawa::script::Script::work().

Identifier<hard::Memory *> otawa::MEMORY_OBJECT("otawa::MEMORY_OBJECT", 0)

Passed to manager::load() to set the memory configuration.

The user is responsible of the release of the memory occipied by the memory object.

Referenced by otawa::hard::Platform::configure().

Identifier<elm::system::Path> otawa::MEMORY_PATH("otawa::MEMORY_PATH","")

Passed to Manager::load() to give the path of the file describing the memory.

Referenced by otawa::hard::Platform::configure().

Feature<FlowFactLoader> otawa::MKFF_PRESERVATION_FEATURE("otawa::MKFF_PRESERVATION_FEATURE")

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

Hooked Properties

• PRESERVED

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

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

AbstractMaker * otawa::no_maker = &no_inst

Special maker for "no processor available".

Referenced by otawa::p::feature::~feature().

Identifier<string> otawa::NO_RETURN_FUNCTION("otawa::NO_RETURN_FUNCTION","")

this property may be used to pass information about the non-returning behaviour of some functions.

The parameter is the name of the function. It is often used with the _exit function.

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

This property shows that no stack need to be allocated.

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

This property shows that the system does not need to by simulated when the binary image is built.

Feature<CFGNormalizer> otawa::NORMALIZED_CFGS_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.

Referenced by otawa::CFGNormalizer::CFGNormalizer().

const category_t otawa::NOT_CLASSIFIED = otawa::cache::NOT_CLASSIFIED

Referenced by otawa::cache::CategoryStats::add(), otawa::cache::CategoryStats::get(), otawa::EdgeCAT2Builder::processLBlockSet(), and otawa::EdgeCAT2ConstraintBuilder::processWorkSpace().

Feature<NoProcessor> otawa::NULL_FEATURE("otawa::NULL")

Not a real feature, just a marker.

AbstractMaker * otawa::null_maker = &null_inst

Special maker for a null processor.

Referenced by otawa::p::feature::~feature().

NullStream otawa::null_stream

Referenced by otawa::Trace::checkLevel().

Identifier<elm::io::OutStream *> otawa::OUTPUT("otawa::OUTPUT",&io::out)

This property identifier is used for setting the output stream used by the processor to write results.

Identifier<String> otawa::OUTPUT_FILE("output file name","")

Referenced by otawa::ParamExeGraphBBTime::ParamExeGraphBBTime().

Identifier<int> otawa::OUTPUT_LEVEL("output level", 0)

Referenced by otawa::ParamExeGraphBBTime::ParamExeGraphBBTime().

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.

Referenced by otawa::ContextTree::ContextTree().

Feature<PCGBuilder> otawa::PCG_FEATURE("otawa::PCG_FEATURE")

This feature ensure that a PCG is provided.

Properties

• PCG::ID (FrameWork)

Referenced by otawa::PCGBuilder::PCGBuilder().

Identifier<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.

Referenced by otawa::hard::Platform::configure().

Identifier<hard::Platform *> otawa::PLATFORM("otawa::PLATFORM", 0)

Identifier of the property indicating a platform (Platform *) to use.

Identifier<hard::Platform::Identification *> otawa::PLATFORM_IDENTFIER("otawa::PLATFORM_IDENTFIER", 0)

Identifier of the property indicating the identifier (PlatformId) of the loader to use.

Identifier<CString> otawa::PLATFORM_NAME("otawa::PLATFORM_NAME","")

Identifier of the property indicating the name (CString) of the platform to use.

Feature<PostDominance> otawa::POSTDOMINANCE_FEATURE("otawa::POSTDOMINANCE_FEATURE")

This feature ensures that information about postdomination between nodes of a CFG is vailable.

Properties

• REVERSE_DOM (BasicBlock)

Referenced by otawa::PostDominance::PostDominance().

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().

Identifier<hard::Processor *> otawa::PROCESSOR("otawa::PROCESSOR", 0)

Gives the processor to use in the current computation.

Referenced by otawa::hard::Platform::configure(), and otawa::ExeGraphBBTime< G >::processWorkSpace().

Identifier<elm::xom::Element *> otawa::PROCESSOR_ELEMENT("otawa::PROCESSOR_ELEMENT", 0)

XML element containing the configuration of the processor.

Referenced by otawa::hard::Platform::configure(), and otawa::script::Script::work().

Identifier<elm::system::Path> otawa::PROCESSOR_PATH("otawa::PROCESSOR_PATH","")

Path to the XML configuration file of the processor.

Referenced by otawa::hard::Platform::configure().

Identifier<PSTree *> otawa::PROGRAM_STRUCTURE_TREE("otawa::PROGRAM_STRUCTURE_TREE", 0)

This property points to the Program Structure Tree of the CFG.

Hooks

• CFG

Referenced by otawa::PSTBuilder::buildTree(), and otawa::PSTBuilder::processCFG().

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().

SilentFeature otawa::PST_FEATURE("otawa::PST_FEATURE", PST_MAKER)

This feature represents the availability of the Program Structure Tree.

Properties

• otawa::PROGRAM_STRUCTURE_TREE

Referenced by otawa::PSTBuilder::PSTBuilder().

Identifier<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::CFGCollector::configure(), and otawa::ipet::VarAssignment::configure().

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

Referenced by otawa::DelayedBuilder::fix(), otawa::VirtualCFG::virtualize(), and otawa::Virtualizer::virtualize().

SilentFeature otawa::REDUCED_LOOPS_FEATURE("otawa::REDUCED_LOOPS_FEATURE", REDUCED_LOOPS_MAKER)

Referenced by otawa::LoopReductor::LoopReductor().

p::feature otawa::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.

Provided Methods

• Inst::readRegs(void);
• Inst::writtenRegs(void);

Referenced by otawa::Inst::readRegs(), and otawa::Inst::writtenRegs().

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

This property is put on a returning basic block and provides the matching entry block of the function.

Hooks

• BasicBlock

Features

• VIRTUALIZED_CFG_FEATURE

Referenced by otawa::Virtualizer::virtualize().

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

Identifier of annotation containing reverse-dominance information.

Hooks

• BasicBlock

Referenced by otawa::Dominance::dominates(), otawa::Dominance::ensure(), otawa::Dominance::processCFG(), and otawa::LoopUnroller::unroll().

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

Identifier of annotation containing reverse-postdominance information.

Hooks

• BasicBlock

Referenced by otawa::PostDominance::ensure(), otawa::PostDominance::postDominates(), and otawa::PostDominance::processCFG().

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

This feature is present when the loader provides implementation of semantics information.

Provider

• Process

Activated Methods

• otawa::Inst::semInsts() method.

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

This feature is present when the loader provides implementation of extended semantics information.

This feature ensures that the following semantics instruction are generated:

• NEG
• NOT
• AND
• OR
• XOR
• MUL
• MULU
• DIV
• DIVU
• MOD
• MODU
• SPEC

Provider

• Process

Activated Methods

• otawa::Inst::semInsts() method.

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

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

Note

This is a future feature as, currently, no floating-point instruction exists.

Provider

• Process

Activated Methods

• otawa::Inst::semInsts() method.

Identifier<sim::Simulator *> otawa::SIMULATOR("otawa::SIMULATOR", 0)

This property defines the used the used simulator when a simulator is needed to perform simulation.

Referenced by otawa::Process::simulator().

Identifier<elm::CString> otawa::SIMULATOR_NAME("otawa::SIMULATOR_NAME","")

Name of the simulator to use.

Referenced by otawa::Process::simulator().

p::feature otawa::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.

Provided Methods

• Process::getSourceLine()
• Process::getAddresses()

Referenced by otawa::Process::getAddresses(), otawa::Process::getSourceLine(), otawa::FlowFactLoader::processWorkSpace(), otawa::ipet::FlowFactLoader::setup(), and otawa::BBRatioDisplayer::setup().

Identifier<Address> otawa::SP_ADDRESS("otawa::SP_ADDRESS", Address::null)

This feature is put on the process to get information about the built image.

It contains the startup address of the stack pointer. Hooks

• Process

Identifier<bool> otawa::START("otawa.exegraph.start", false)

otawa::NullInst otawa::static_null

Identifier<Address> otawa::TASK_ADDRESS("otawa::TASK_ADDRESS", Address::null)

This property, passed to the load configuration, select the task entry by its address.

Referenced by otawa::CFGCollector::configure(), and otawa::Application::work().

Identifier<string> otawa::TASK_ENTRY("otawa::TASK_ENTRY","main")

This property, passed to the load configuration, gives the name of the entry function of the current task.

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

Identifier<int> otawa::TIME

Referenced by otawa::ParamExeGraphBBTime::processBB(), and otawa::LiExeGraphBBTime::processBB().

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

Referenced by otawa::DelayedBuilder::buildBB(), and otawa::DelayedBuilder::mark().

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

This property activates the verbose mode of the processor: information about the processor work will be displayed.

cstring otawa::VERBOSE_ENV = "OTAWA_VERBOSE"

Referenced by otawa::Monitor::configure(), and otawa::Manager::setVerbosity().

Identifier<bool> otawa::VIRTUAL_INLINING("otawa::VIRTUAL_INLINING", 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().

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

This property is put on a BB performing a function call that has been virtualized (inlined in the current CFG).

It gives the BB after the return of the inlined CFG. It is useful to jump over inlinved CFG.

Hooks

• BasicBlock

Features

• VIRTUALIZED_CFG_FEATURE

Referenced by otawa::DelayedBuilder::fix(), otawa::BBStatCollector::processCFG(), otawa::ContextualProcessor::processCFG(), otawa::SubCFGBuilder::processWorkSpace(), otawa::LoopUnroller::unroll(), and otawa::Virtualizer::virtualize().

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>

Properties

• CALLED_CFG
• RECURSIVE_LOOP
• VIRTUAL_RETURN_BLOCK
• RETURN_OF

Referenced by otawa::SubCFGBuilder::cleanup(), and otawa::Virtualizer::cleanup().

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

This feature is provided on Process objects by architecture implementing VLIW facilities.

This means mainly that Inst::IS_BUNDLE and Inst::semWriteBack() are used in instructions.

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().

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