Class Hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:

[detail level 123456]

Cotawa::Identifier< T >::__class
Cotawa::Identifier< T >::__simple
Cotawa::__type< T >
Cotawa::__type< bool >
Cotawa::__type< char >
Cotawa::__type< double >
Cotawa::__type< elm::CString >
Cotawa::__type< elm::String >
Cotawa::__type< float >
Cotawa::__type< int >
Cotawa::__type< long >
Cotawa::__type< long double >
Cotawa::__type< long long >
Cotawa::__type< short >
Cotawa::__type< signed char >
Cotawa::__type< unsigned char >
Cotawa::__type< unsigned int >
Cotawa::__type< unsigned long >
Cotawa::__type< unsigned long long >
Cotawa::__type< unsigned short >
Cotawa::__type< void >
Cotawa::dfa::AbsIntLiteEx< G, T >
►Cotawa::dfa::AbsIntLiteEx< G, AbsIntLiteExtender< G, T > >
Cotawa::dfa::AbsIntLite< G, T >	This class provides a light implementation for abstract interpretation
Cotawa::dfa::AbsIntLiteExtender< G, D >
Cotawa::dfa::AbsIntLiteExtender< G, T >
Cotawa::ets::AbstractCacheState	This class is used to represent an abstract cache line state
Cotawa::concept::AbstractDomain< T, G >	Concept used to implements AbsIntLite domain
►Cotawa::display::AbstractDrawer	Provides facilities to draw a graph
Cotawa::display::GenDrawer< G, D >	A simple engine to draw graphs
►Celm::genstruct::DLList< T, class >::AbstractIterator [external]
►Celm::genstruct::DLList< T, class >::Iterator [external]
►Cotawa::ExeInst< N >::NodeIterator	Iterator on the list of nodes related to the instruction
Cotawa::ExeGraph< N >::InstNodeIterator
►Cotawa::ExeSequence< N >::InstIterator	Iterator on the list of instructions of the sequence
Cotawa::ExeGraph< N >::InstIterator
Cotawa::LiExeGraphBBTime::SeqIterator
►Cotawa::ParExeSequence::InstIterator
Cotawa::ParExeGraph::InstIterator
►Cotawa::ParamProcessor::AbstractMaker
Cotawa::ParamProcessor::Maker< T >
►Cotawa::AbstractMaker
Cotawa::Maker< C >	Template to make a processor from its class passed as template parameter
Cotawa::SilentFeature::Maker< C >
►Cotawa::AbstractRegistration	Abstract class to represent the registered processors
Cotawa::MetaRegistration
Cotawa::NullRegistration
Cotawa::p::declare	Class to declare simple a processor
Cotawa::Registration< T >
Cotawa::Registration< BHTGetter >
Cotawa::Registration< otawa::CAT2Builder >
Cotawa::Registration< otawa::CFGChecker >
Cotawa::Registration< otawa::DelayedBuilder >
Cotawa::Registration< otawa::display::ILPSystemDisplayer >
Cotawa::Registration< otawa::FixedTextDecoder >
Cotawa::Registration< otawa::GraphBBTime< G > >
Cotawa::Registration< otawa::GraphBBTime< ParExeGraph > >
Cotawa::Registration< otawa::hard::Dumper >
Cotawa::Registration< otawa::ipet::CachePenaltiesObjectFunctionBuilder >
Cotawa::Registration< otawa::ipet::ConstraintLoader >
Cotawa::Registration< otawa::ipet::VarAssignment >
Cotawa::Registration< otawa::script::Script >
Cotawa::Registration< otawa::SubCFGBuilder >
Cotawa::Registration< otawa::tsim::BBTimeSimulator >
Cotawa::Registration< otawa::tsim::Delta >
►Cotawa::AccessedAddress	Parent class of classes representing accesses to memory
Cotawa::AbsAddress	Subclass of AccessedAddress, this class represents an absolute address access, to a global variable or to an input/output register for example
Cotawa::SPAddress	Subclass of AccessedAddress, this class represents address with a constant offset relative to the stack pointer
Cotawa::AccessedAddresses	For each basic block, provide the list of performed memory accesses and their addresses
►Cotawa::dcache::ACS	Representation of an Abstract Cache State where each data cache block is represented by its age
Cotawa::dcache::MAYProblem::Domain
Cotawa::dcache::MUSTProblem::Domain
Cotawa::dcache::PERSProblem::Item	ACS for the multi-level data cache persistence analysis
Cotawa::Address	The representation of an address in OTAWA
Cotawa::address_stat_t
Cotawa::AlternativeProcessor::Alternative	Represent an alternetive in the requirement of an AlternativeProcessor, i.e., a list of required or used features
Cotawa::ai::ArrayStore< D, G >	Stockage of output values as an array
Cotawa::BackwardCFGAdapter	Adapter of CFG to the concept of otawa::concept::DiGraphWithIndexedVertex but with backward traversal of edges
Cotawa::Bag< T >
Cotawa::hard::Bank	A bank in the memory
►Cotawa::dfa::BitSet	This class implements a set as a bit vector
Cotawa::cat::CATDomain
Cotawa::ccg::Domain
CBitSetManager
Cotawa::dcache::Block	Represents a single block used by the data cache
Cotawa::dcache::BlockCollection	A block collections stores the list of data blocks used in a task for a specific line
Cotawa::BranchProblem
Cotawa::BasicBlock::Bundle	A bundle, in a VLIW processors, is a group of instructions executed in parallel
Cotawa::hard::Bus	A bus that tie together several memory banks
Cotawa::hard::Cache	This class contains the configuration of a level of cache of processor
Cotawa::hard::CacheConfiguration	This class represents the full configuration of caches of a processor
►Cotawa::sim::CacheDriver	This class provides a simple interface to drive the cache management unit of a simulator
►Cotawa::sim::AbstractCacheDriver	This is an abstract implementation of the cache driver allowing to customize only the cache replacement policy
Cotawa::sim::DirectMappedCacheDriver	This class provide a cache driver implementing direct mapped cache driver
Cotawa::sim::FIFOCacheDriver	This class provide a cache driver implementing a FIFO policy
Cotawa::sim::LRUCacheDriver	This class provide a cache driver implementing the LRU replacement policy
Cotawa::CachePenalty	This class can be used to express the penalties due to the instruction cache
Cotawa::cache::CategoryStats	This class is used to store statistics about the categories about cache accesses
Cotawa::cat::CATProblem
Cotawa::CEClass
Cotawa::display::CFGAdapter	This adapter implements the otawa::concept::DiGraphWithNodeMap and allows to use apply the GenDrawer to a CFG
Cotawa::CFGCollection	Contains a collection of CFGs (used with INVOLVED_CFGS property)
Cotawa::display::CFGDrawer
Cotawa::ai::CFGGraph	BiDiGraph implementation for CFG
►Celm::Cleaner [external]
►Cotawa::BBCleaner	Efficient implementation of a cleaner for properties found on a basic block
►Cotawa::BBRemover< T >
Cotawa::BBDeletor< T >	Basic block cleaner removing an identifier and deleting its content
Cotawa::Processor::Remover< T >
►Cotawa::Processor::Remover< T * >
Cotawa::Processor::Deletor< T >
►Celm::CleanList [external]
Cotawa::FeatureDependency	A feature dependency represents the dependencies used to implement a feature and is a node of the dependency graph
Cotawa::clp::ClpStatePack	A pack of CLP states inside a BasicBlock
Cotawa::ccg::Collection
►Celm::concept::Collection< Vertex > [external]
►Cotawa::concept::DiGraph	This concept attempts to provide a representation of a digraph that may only be traversed in the edge direction
►Cotawa::concept::BiDiGraph	Concept of directed graph with predecessor available
Cotawa::concept::DiGraphWithExit	Directed graph with a unique entry and exit points
Cotawa::concept::DiGraphWithEdgeMap	Concept of directed graph providing an edge map
Cotawa::concept::DiGraphWithEntry	Directed graph with a unique entry point
Cotawa::concept::DiGraphWithIndexedVertex	This kind of digraph contain indexed graph
Cotawa::concept::DiGraphWithLoop	A digraph that supports loop identification
Cotawa::concept::DiGraphWithVertexMap	Concept of directed graph providing a vertex map
Cotawa::StatCollector::Collector	This interface class must be implemented by any program that wants to collect statistics for the current statistics information
Cotawa::display::Color	A color description
Cotawa::etime::Config	Represents a configuration for computing cost of a BB
Cotawa::etime::ConfigSet	Set of configurations with the same or with a maximum of time
Cotawa::ilp::cons	Encapsulation for ilp::Constraint pointers for {ilp} expr user-fiendly interface
►Cotawa::ilp::Constraint	This class is used to represent constraints in an ILP system with the following form:
Cotawa::ilp::AbstractConstraint	Constraint generated by AbstractSystem
Cotawa::ilp::ConstraintImpl	Provide a simple implementation of a constraint using expression
Cotawa::clp::ClpStatePack::Context	A context allows to share a CLP problem through different constructions of ClpStatePack
Cotawa::ContextPath< T >	This class is a stack to store call chain in the program call graph
Cotawa::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
Cotawa::ContextualPath
Cotawa::ContextualStep
Cotawa::ContextualLoopBound::data_t
Cotawa::display::Decorator< G >	A decorator is a concept that provides static functions used to display a graph
Cotawa::default_handler_t
►Celm::default_t [external]
►Celm::scalar_t [external]
►Celm::enum_t [external]
►Celm::enum_info< otawa::ilp::format_t > [external]
Celm::type_info< otawa::ilp::format_t >
Cotawa::display::DefaultDecorator< G >	Default decorator that just output the given edges and vertices
Cotawa::dfa::hai::DefaultFixPoint< Listener >
Cotawa::dfa::hai::DefaultListener< P >	This listener gathers in an array the LUB of the in-states for all analyzed basic blocks
Cotawa::DelayedInfo	Provide information on delayed branches
Cotawa::dcache::DirtyManager	A dirty manager allows to exploit the results of the dirty analysis (DIRTY_FEATURE)
Cotawa::hard::Dispatch	A dispatch object allows to map some kinds of instructions to a functional unit
►Celm::genstruct::DLList< ExeInst< LiExeNode > * > [external]
Cotawa::ExeSequence< LiExeNode >
►Celm::genstruct::DLList< ExeInst< N > * > [external]
Cotawa::ExeSequence< N >	A sequence of instructions (ExeInst)
►Celm::genstruct::DLList< ExeInst< otawa::ParamExeNode > * > [external]
Cotawa::ExeSequence< otawa::ParamExeNode >
►Celm::genstruct::DLList< ExeInst< ParamExeNode > * > [external]
Cotawa::ExeSequence< ParamExeNode >
►Celm::genstruct::DLList< ParExeInst * > [external]
Cotawa::ParExeSequence	A sequence of ParExeInstruction for which a ParExeGraph will be built
►Celm::inhstruct::DLNode [external]
Cotawa::cat::CATNode
Cotawa::ccg::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
Cotawa::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
►Cotawa::ProgItem	Base class of the components of a program file segment
►Cotawa::Inst	This class represents assembly instruction of a piece of code
►Cotawa::loader::new_gliss::Inst
Cotawa::loader::new_gliss::BranchInst
►Cotawa::loader::old_gliss::Inst
Cotawa::loader::old_gliss::BranchInst
Cotawa::ai::Domain	Domain concept for ai module
Cotawa::dcache::MUSTPERS::Domain	ACS of the MUSTPERS problem
Cotawa::dcache::PERSProblem::Domain
Cotawa::MUSTBranch::Domain
Cotawa::MAYBranch::Domain
Cotawa::PERSBranch::Domain
Cotawa::BranchProblem::Domain
Cotawa::MUSTPERS::Domain
Cotawa::MAYProblem::Domain
Cotawa::MUSTProblem::Domain
Cotawa::PERSProblem::Domain
►Cotawa::display::Driver	A driver provides facilities to display a graph
►Cotawa::display::Plugin	A plugin to provide driver to display graphs
Cotawa::display::GraphVizDriver
►Cotawa::sim::Driver	This class is used to drive a simulator
Cotawa::sim::BasicBlockDriver	This class is a simulator Driver that executes the instruction sequence found in a basic block
Cotawa::sim::BBPathDriver
Cotawa::DynFeature	This class is used to resolve feature found in plugins using ProcessorPlugin::getFeature() method
Cotawa::DynIdentifier< T >	An identifier dynamically resolved
Cotawa::DynProcessor	This pseudo-processor allows to call processor based on their name
Cotawa::concept::DiGraph::Edge	Opaque type for the edges
►Cotawa::display::AbstractDrawer::Edge	An edge in a AbstractDrawer
Cotawa::display::GenDrawer< G, D >::Edge
Cotawa::display::CFGAdapter::Edge
Cotawa::display::GenGraphAdapter< G >::Edge
►Cotawa::graph::Edge	This class represents a directed edge between two nodes
►Cotawa::GenGraph< N, E >::GenEdge
Cotawa::ccg::Edge	This class represents edges in the CCG representation
Cotawa::ExeGraph< N >::ExeEdge
Cotawa::ParExeEdge	An edge in a ParExeGraph
Cotawa::pfg::Edge	This class represents the control transfer between basic block (BB)
Cotawa::ai::EdgeStore< D, G >	State storage on the edges
►Celm::ErrorHandler [external]
Cotawa::script::Script	A script processor allows to interpret a file that performs a WCET computation
Cotawa::etime::EventCollector	Collects variables linking events with blocks in ILP
Cotawa::etime::EdgeTimeBuilder::EventComparator
►Celm::Exception [external]
►Celm::MessageException [external]
Cotawa::AmbiguousBoundException
Cotawa::cpp::UnmanglingException
Cotawa::DecodingException	This exception is thrown by a loader to inform about problems during decoding
►Cotawa::Exception	Base class of Otawa exceptions
►Cotawa::display::Exception
Cotawa::display::DisplayException	This exception is thrown during the display of a graph if there is an error
Cotawa::DuplicateIdentifierException	This exception is thrown when two identifier with the same name are declared
Cotawa::FeatureNotFound
Cotawa::NoProcessorException
Cotawa::ParExeException	Exception thrown if there is an error during the build and the computation of
►Cotawa::ProcessException	An exception generated from a process
Cotawa::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
Cotawa::UnsupportedFeatureException	This class is used to throw an exception when a process does not support an invoked feature
►Cotawa::ProcessorException	This class is used for returning exceptions from the processors
Cotawa::UnavailableFeatureException	This exception is thrown when an feature can not be computed
Cotawa::ProcessorNotFound	This exception is thrown when a code processor can not be found
Cotawa::sim::Exception	Exception generated by a simulator
Cotawa::LoadException	Exception thrown when a loader encounters an error during load
Cotawa::ExeGraph< N >	An execution graph that expresses precedence constraints on the execution of a sequence of instructions in a pipelined processor
►Cotawa::ExeGraph< LiExeNode >
Cotawa::LiExeGraph
Cotawa::ExeGraph< otawa::ParamExeNode >
►Cotawa::ExeGraph< ParamExeNode >
Cotawa::ParamExeGraph
Cotawa::ExeInst< N >	An instruction represented in an ExeGraph
Cotawa::ExeInst< otawa::ParamExeNode >
Cotawa::ExpNode
Cotawa::ilp::Expression	An expression allows to represent a sum of terms and may be used to represent the value of an aliased variable
Cotawa::dfa::FastState< D >	Fast implementation of abstract domain on the functional state of a microprocessor including the registers and the memory content
Cotawa::FeatureRequirer	This class provided feature requirement for non-program processor classes
Cotawa::FeatureUsage
Cotawa::display::FillStyle	The style of a filled area
Cotawa::se::FilterBuilder
Cotawa::dfa::hai::FirstUnrollingFixPoint< Listener >	FixPoint class for HalfAbsInt The DefaultFixPoint manages loops in a simple way
Cotawa::dfa::hai::DefaultFixPoint< Listener >::FixPointState
Cotawa::dfa::hai::FirstUnrollingFixPoint< Listener >::FixPointState	State info class for FirstUnrollingFixPoint This FixPoint needs to remember:
Cotawa::dfa::hai::WideningFixPoint< Listener >::FixPointState
Cotawa::ForwardCFGAdapter	Adapter of CFG to the concept of otawa::concept::DiGraphWithIndexedVertex
Cotawa::PipelineStage< N >::FunctionalUnit::fu_info_t
Cotawa::PipelineStage< N >::FunctionalUnit
Cotawa::hard::FunctionalUnitBuilder
Cotawa::display::GenGraphAdapter< G >
Cotawa::Give< T >
Cotawa::ai::Graph	Graph concept for ai module
►Cotawa::graph::Graph	This class represents a full graph with nodes and edges
Cotawa::GenGraph< LiExeNode, otawa::ExeGraph::ExeEdge >
Cotawa::GenGraph< N, otawa::ExeGraph::ExeEdge >
►Cotawa::GenGraph< Node, Edge >
Cotawa::ccg::Graph
Cotawa::GenGraph< otawa::ParamExeNode, otawa::ExeGraph::ExeEdge >
Cotawa::GenGraph< otawa::ParExeNode, otawa::ParExeEdge >
Cotawa::GenGraph< ParamExeNode, otawa::ExeGraph::ExeEdge >
►Cotawa::GenGraph< ParExeNode, ParExeEdge >
Cotawa::ParExeGraph	Representation of a parametric execution graph (Parametric Execution Graph)
►Cotawa::GenGraph< N, E >
Cotawa::pfg::PFG	A PFG (Program Flow Graph) is built from the binary form of the program to represent all possible pathes of the program from its entry point
►Cotawa::display::GraphVizItem
Cotawa::display::GraphVizGraph
►Cotawa::display::GraphVizGraphElement
Cotawa::display::GraphVizEdge
Cotawa::display::GraphVizNode
Cotawa::dfa::hai::HalfAbsInt< FixPoint >	Implements abstract interpretation
Cotawa::dfa::hai::HalfAbsInt< otawa::dfa::hai::DefaultFixPoint >
Cotawa::dfa::hai::HalfAbsInt< otawa::dfa::hai::FirstUnrollingFixPoint >
Cotawa::dfa::hai::HalfAbsInt< otawa::dfa::hai::WideningFixPoint >
Celm::HashKey< otawa::Address >
Cotawa::hard::Platform::Identification
Cotawa::display::ILPSystemAddon	This class is an interface for ILPSystemDisplayer to add to its output specialized information about ILP variables and constraints generators
►Cotawa::ImmutableRef< T, I >
Cotawa::Ref< T, I >
Cotawa::gliss::Info	This class provides access to the stay-behind GLISS data structures and code provided by the GLISS v2 utility used by some loaders
Cotawa::arm::Info
Cotawa::hard::Cache::info_t
Cotawa::p::init
►Celm::Initializer< AbstractRegistration > [external]
Cotawa::Registry	Class dedicated to the registering of the processors
Cotawa::ParamExeGraph::input_t
Cotawa::Resource::input_t
Cotawa::ai::InputIter	Iterator on input of a vertex
Cotawa::sem::inst	This structure class represents an instruction in the semantics representation of machine instruction
Cotawa::concept::InstBlock	An iterable block of instruction
►CInstIterator
Cotawa::LiExeGraphBBTime::InstIterator
►CInstIterator
Cotawa::ParamExeGraphBBTime::InstIterator
Cotawa::clp::ClpStatePack::InstPack	A pack of CLP states inside a machine instruction
Cotawa::arm::IOManager
Cotawa::PERSBranch::Item
Cotawa::PERSProblem::Item
Cotawa::dfa::IterativeDFA< Problem, Set, Iter >	This class provides a generic facility to implement iterative Data Flow Analysis (DFA) as presented in "Aho, Sethi, Ullman, Compilers: Principles, Techniques, and Tools, Addison Wesley 1986"
Cotawa::concept::IterativeDFAProblem	Concept used to implements IterativeDFA problems
Cotawa::ai::Graph::Iterator	Iterator on the vertices of the graph
►CIterator
Cotawa::concept::BiDiGraph::Predecessor	Entering-in edge iterator on a node
Cotawa::concept::InstBlock::InstIter	Iterator on the instruction of the block
Cotawa::sem::Block::InstIter
►CIterator
Cotawa::dfa::State::MemIter
►CIterator
Cotawa::File::SymIter
►CIterator
Cotawa::concept::DiGraph::Successor	Outing edge iterator on a node
►CIterator
►Cotawa::CFG::BBIterator
Cotawa::ai::CFGGraph::Iterator
Cotawa::BackwardCFGAdapter::Iterator
Cotawa::ForwardCFGAdapter::Iterator
Cotawa::LBlockManager
Cotawa::LBlockSet	This class represents the list of l-blocks of a task for a chosen cache row
Cotawa::ccg::LBlockSet	This class represents the list of l-blocks of a task for a chosen cache row
Cotawa::Level
Cotawa::display::LineStyle
►Celm::Lock [external]
►Cotawa::ast::AST	This is the base class for the representation of programs as Abstract Syntax Trees
►Cotawa::ast::BlockAST	This class represents the leafs of the AST
Cotawa::ast::CallAST	This class is a specialized block AST ended by a function call
Cotawa::ast::DoWhileAST	Representation of C do{ ..
Cotawa::ast::ForAST	Representation of C language FOR loop
Cotawa::ast::IfAST	AST for representing selections
Cotawa::ast::SeqAST	This AST represents sequences
Cotawa::ast::WhileAST	Representation of an iteration with test at start of the loop
Cotawa::ast::FunAST	This class represents functions in the AST representation
Cotawa::CFGInfo	This allows storing all CFG available in a workspace
►Cotawa::Process	A process is the realization of a program on a platform
Cotawa::loader::new_gliss::Process
Cotawa::loader::old_gliss::Process
►Celm::option::Manager [external]
Cotawa::Application	A class making easier the use of applications built on OTAWA
Cotawa::Manager	The manager class providesfacilities for storing, grouping and retrieving shared resources like loaders and platforms
Cotawa::clp::Manager	This class allows to exploit the result of a CLP analysis
►CMap
Cotawa::concept::DiGraphWithEdgeMap::EdgeMap< T >	Efficient map for the edges
Cotawa::concept::DiGraphWithVertexMap::VertexMap< T >	Efficient map for the nodes
Cotawa::MAYBranch
Cotawa::dcache::MAYProblem
Cotawa::MAYProblem
Cotawa::MemArea	Utility class representing an area in the memory defined by a base address and a size
Cotawa::MemBlockMap< T >	This class is used to retrieve quickly blocks from their containing address
Cotawa::MemBlockMap< otawa::BasicBlock >
Cotawa::dfa::MemCell
Cotawa::hard::Memory	Class to represent the whole memory of the platform
Cotawa::Microprocessor< N >
Cotawa::Microprocessor< ExeNode >
Cotawa::Microprocessor< LiExeNode >
Cotawa::Microprocessor< otawa::ParamExeNode >
Cotawa::Microprocessor< ParamExeNode >
Cotawa::hard::Mode	A working mode for the hardware memory
Cotawa::ilp::model	Encapsulation for ilp::System pointers for {ilp} expr user-fiendly interface
Cotawa::hard::ModeTransition	Representation of a memory bank transition
►Celm::io::Monitor [external]
Cotawa::XSLTScript	This class provides a simple way to implement OTAWA script
►Cotawa::Monitor	This class provide a unified interface to interact with external user
►Cotawa::Processor	The processor class is implemented by all code processor
Cotawa::ACSBuilder	This processor builds the MUST and PERS cache states before each basic block
Cotawa::ACSMayBuilder	This processor produces the Abstract Cache States (ACS), for the MAY ACS
Cotawa::AlternativeProcessor	With OTAWA classic scheduler, the list of required feature if fixed in the registration data structure
Cotawa::ast::ASTLoader	This class may be used for loading AST from an external file using the Heptane format (see doc/ directory for more details)
►Cotawa::ast::FunProcessor	This is a specialization of the processor class dedicated to function processing
►Cotawa::ast::ASTProcessor	This is a specialization of the processor class dedicated to AST processing
Cotawa::ets::ACSComputation	This processor is used to simule cache states
Cotawa::ets::CacheFirstMissComputation	This processor is used for computing the First Misses accesses after the cache simulating
Cotawa::ets::CacheHitComputation	This processor is used for computing the Hit accesses after the cache simulating
Cotawa::ets::CacheMissComputation	This processor is used for computing the Miss accesses after the cache simulating
Cotawa::ets::FlowFactLoader	This processor allows using extern flow facts in ETS
Cotawa::ets::TrivialAstBlockTime	This processor is used for computing execution of ast blocks in a trivial way, that is, the multiplication of ast block instruction count by the pipeline depth
Cotawa::ets::WCETComputation	This processor is used for computing the WCET with the Extended Timing Schema
Cotawa::branch::BranchBuilder	Compute the categories for branch prediction
►Cotawa::CAT2OnlyConstraintBuilder	Build the constraints to support categories of cat2 module
Cotawa::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
Cotawa::cat::CATBuilder	Create a new CATBuilder processor
Cotawa::cat::CATConstraintBuilder	This processor uses categories assigned to L-block of the instruction cache to add contraints and to modify maximized function to support the instruction cache
Cotawa::ccg::Builder	This processor builds the Cache Conflict Graph of the current task
Cotawa::ccg::ConstraintBuilder	This processor allows handling timing effects of the instruction cache in the IPET approach
Cotawa::CFGBuilder	This processor is used for building the CFG from the binary program representation
Cotawa::CFGCollector	This processor is used to collect all CFG implied in a computation
►Cotawa::CFGProcessor	This is a specialization of the processor class dedicated to CFG processing
►Cotawa::BBProcessor	This processor is dedicated to the basic block process thru proccessBB() method
►Cotawa::ExeGraphBBTime< LiExeGraph >
Cotawa::LiExeGraphBBTime
►Cotawa::ExeGraphBBTime< ParamExeGraph >
Cotawa::ParamExeGraphBBTime
►Cotawa::GraphBBTime< ParExeGraph >
Cotawa::BasicGraphBBTime	This property is used to pass the microprocessor description to the code processor
Cotawa::etime::EdgeTimeBuilder	Compute execution time by edge using the parametric exegraph approach
Cotawa::AccessedAddressFromStack
Cotawa::BBRatioDisplayer	This class output statistics for each basic block in the WCET as a table in a textual form on the standard output
Cotawa::branch::CondNumber	Associate numbers to each branch relatively to their BHT set
Cotawa::branch::ConsBuilder	This processor add to the current ILP the constraint requires to model the behaviour of the BHT
Cotawa::branch::OnlyConsBuilder	This processor add to the current ILP the constraint requires to model the behavior of the BHT
Cotawa::ccg::LBlockBuilder	This processor builds the list of l-blocks for each lines of instruction cache and stores it in the CFG
Cotawa::CFGChecker	The analysis does not produce anything but simply check some properties on the involved CFG:
Cotawa::cfgio::Output	Output the current CFG collection in XML matching the DTA ${OTAWA_HOME}/share/Otawa/dtd/cfg.dtd
Cotawa::CFGSaver	Save the CFGs of the current task to a file
Cotawa::dcache::BlockBuilder	Build the list of blocks used for L1 data cache analysis and decorate each basic block with the list of performed accesses
Cotawa::dcache::CLPBlockBuilder	Build the list of blocks used for L1 data cache analysis and decorate each basic block with the list of performed accesses, based on a CLP analysis
Cotawa::dcache::WCETFunctionBuilder	Default implementation of feature WCET_FUNCTION_FEATURE
Cotawa::etime::StandardEventBuilder	Build standard events
Cotawa::ExeGraphBBTime< G >
Cotawa::GraphBBTime< G >	This basic block processor computes the basic block execution time using the execution graph method described in the following papers:
Cotawa::ipet::BasicConstraintsBuilder
Cotawa::ipet::BasicObjectFunctionBuilder	This processor is used for building the basic object function function to maximize for resolving the IPET system, that is, Then, it set the object function as maximizing the following expression: t1 * n1 + t2 * n2 + ..
Cotawa::ipet::CachePenaltiesObjectFunctionBuilder	This processor is used for building the basic object function function in case of a L1 instruction cache
Cotawa::ipet::FlowFactConstraintBuilder	This processor allows using extern flow facts in an IPET system
Cotawa::ipet::TrivialBBTime	This processor is used for computing execution of basic blocks in a trivial way, that is, the multiplication of basic block instruction count by the pipeline depth
Cotawa::ipet::TrivialDataCacheManager	This processor apply a simple method for managing data cache in IPET method
Cotawa::ipet::TrivialInstCacheManager	This processor is a trivial manager of instruction cache for IPET approach
Cotawa::ipet::VarAssignment	This processor ensures that each basic block and each edge of the CFG has a variable associated with a ipet::VAR annotation
Cotawa::ipet::WCETCountRecorder	This class may be used to record back in the CFG the execution count of each basic block and of each edge for the WCET path
Cotawa::LBlockBuilder	This processor builds the list of l-blocks for each lines of instruction cache and stores it in the CFG
Cotawa::TrivialBBLBlockTime
Cotawa::tsim::BBTimeSimulator
Cotawa::tsim::TimeDeltaObjectFunctionModifier	This processor is used for modify the object function to maximize for resolving the IPET system, that is, For each edge where a TIME_DELTA is found, it adds: tdelta * ei,j where
Cotawa::bpred::BPredProcessor	This is a specialization of the CFGProcessor class dedicated to branch prediction
►Cotawa::CAT2Builder	This processor produces categorization information for each l-block
Cotawa::CAT2NCBuilder	This processor produces categorization information for each l-block
Cotawa::CFGCheckSummer	Add to each involved CFG a checksum build on the instruction of the CFG
Cotawa::CFGNormalizer	This processor check and transform the CFG to make it normalized, that is, it performs the following checks and transformation:
Cotawa::ContextTreeByCFGBuilder	Build a context tree for each CFG involved in the current computation
►Cotawa::ContextualProcessor	A contextual processor allows to process basic block in a call-aware way even with a virtual CFG (where called CFG are inlined)
Cotawa::ipet::FlowFactLoader	This processor allows using extern flow facts in an IPET system
Cotawa::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
Cotawa::display::CFGOutput
Cotawa::Dominance	This CFG processor computes and hook to the CFG the dominance relation that, then, may be tested with Dominance::dominate() function
Cotawa::EdgeCAT2Builder	This processor produces categorization information for each l-block
Cotawa::EdgeProcessor	Abstract processor providing simple traversal of edges of the CFG
Cotawa::FirstLastBuilder
Cotawa::ipet::ConstraintLoader	This code processor allows loading IPET constraint from an external file
Cotawa::PostDominance	This CFG processor computes and hook to the CFG the postdominance relation that, tehn, may be tested with PostDominance::postDominate() function
Cotawa::PSTBuilder	This processor computes the Program Structure Tree of the CFG
Cotawa::tsim::Delta
Cotawa::clp::Analysis
Cotawa::ContextTreeBuilder	This processor produces context tree information
Cotawa::dcache::ACSBuilder	This builder performs analysis of the L1 data cache and produces ACS for MUST and, according to the configuration proerties, persistence
Cotawa::dcache::ACSMayBuilder	This processor computes the ACS for the MAY cache analysis
Cotawa::dcache::CATBuilder	Processor to get the categories for each block access of a data cache
Cotawa::dcache::CatConstraintBuilder	This processor allocates the variable to count misses of a data cache and makes the constraints for these variables
Cotawa::DeadCodeAnalysis	This analyzer add the NEVER_TAKEN identifer on edges which are never taken
Cotawa::display::ILPSystemDisplayer	This processor may be used to generate an HTML output of an ILP system used to compute the WCET of a task
Cotawa::EdgeACSBuilder	This processor builds the MUST and PERS cache states before each basic block
Cotawa::EdgeCAT2ConstraintBuilder	This processor produces constraints, using the categorization of the lblocks
Cotawa::FixedTextDecoder	Decode the text instruction for a simple RISC architecture, requiring fixed size and fixed alignement instructions
Cotawa::FlowFactLoader	This class is an abstract class to monitor the load of flow facts
Cotawa::FunProcessor	This is a specialization of the processor class dedicated to function processing
Cotawa::hard::Dumper	Dump to output the hardware configuration details
Cotawa::ilp::Output	This processor provides an output of the built ILP system
Cotawa::ipet::ILPSystemGetter	This processor looks for an ILP plugin and build a new system that will be used by other IPET processor
Cotawa::ipet::WCETComputation	This class is used for computing the WCET from the system found in the root CFG
Cotawa::LBlockProcessor	This is a specialization of the processor class dedicated to LBlock
Cotawa::LinkedBlocksDetector
►Cotawa::LoopReductor
Cotawa::SpanningTreeBuilder
Cotawa::LoopUnroller	This processor unrolls the first iteration of each loop
Cotawa::NoProcessor	A processor whise execution cause an exception throw
Cotawa::NullProcessor	A simple processor that does nothing
Cotawa::PCGBuilder
Cotawa::PFGBuilder
Cotawa::script::Script	A script processor allows to interpret a file that performs a WCET computation
Cotawa::StackAnalysis	This analyzer computes accessed addresses
Cotawa::StackAnalysis	This analyzer computes accessed addresses
Cotawa::SubCFGBuilder	Build a sub-CFG starting at the given otawa::START address and ending at the multiple otawa::STOP addresses
Cotawa::TextDecoder	A default text decoder: try to find the most adapted text decoder
Cotawa::VarTextDecoder	This text decoder may be used for most processor with fixed or variable length instructions
Cotawa::Virtualizer	This processor inlines the function calls
Cotawa::MUSTBranch
Cotawa::dcache::MUSTPERS
Cotawa::MUSTPERS
Cotawa::dcache::MUSTProblem	The MUST problem provides the abstract interpretation of L1 data cache for the MUST case
Cotawa::MUSTProblem
Cotawa::script::NamedObject	Named are used by script to locate a data structure passed as argument to a code processor
►Cotawa::graph::Node	The node from a directed graph
►Cotawa::GenGraph< N, E >::GenNode
Cotawa::ccg::Node	Node of a CCG (Cache Conflict Graph)
►Cotawa::ExeGraph< N >::ExeNode
Cotawa::LiExeNode
Cotawa::ParamExeNode
Cotawa::ParExeNode	A node of the ParExeGraph, that represents the crossing of an instruction inside a microprocessor stage
Cotawa::pfg::BB	A basic block in a otawa::pfg::PFG
Cotawa::clp::State::Node	A node in the memory list
Cotawa::dfa::FastState< D >::node_t
Cotawa::dfa::XCFGVisitor< P >::node_t
Cotawa::MemBlockMap< T >::node_t
Cotawa::NodeLatency
►Celm::option::Option [external]
►Celm::option::AbstractValueOption [external]
Cotawa::AddressOption	An option allowing to read an address, currently, only an unsigned decimal, hexadecimal and so one value
Cotawa::LogOption	Defines a command line option supporting log level thanks to strings 'proc', 'cfg' or 'bb'
►Celm::io::Output [external]
Cotawa::Trace
Cotawa::ai::OutputIter	Iterator to set output values
►Celm::io::OutStream [external]
Cotawa::NullStream
►CPairIterator
Cotawa::dfa::State::RegIter
Cotawa::ParExeInst	Instruction as presented in the ParExeGraph
Cotawa::ParExePipeline	Representation of a pipeline (list of stages)
Cotawa::ParExeProc	Représentation of a processor (to be used to build a ParExeGraph)
Cotawa::ParExeQueue	Representation of a hardware instruction queue to be used to build a ParExeGraph
Cotawa::ParExeStage	Representation of a pipeline stage to be used to build a ParExeGraph
Cotawa::PathContext
Cotawa::PERSBranch
Cotawa::dcache::PERSProblem	Problem for computing the PERS ACS of L-blocks
Cotawa::PERSProblem	Problem for computing the PERS ACS of L-blocks
Cotawa::PipelineStage< N >::pipeline_info_t
Cotawa::PipelineStage< N >
Cotawa::PipelineStage< ExeNode >
Cotawa::PipelineStage< LiExeNode >
Cotawa::PipelineStage< otawa::ParamExeNode >
Cotawa::PipelineStage< ParamExeNode >
►Cotawa::hard::PipelineUnit
Cotawa::hard::FunctionalUnit	A functional unit is specialized in the computation of some kinds of instructions
Cotawa::hard::Stage	This class represents a stage in a pipeline
Cotawa::hard::Platform	This class records information about the architecture where the processed program will run
►CPlugin
Cotawa::display::Plugin	A plugin to provide driver to display graphs
Cotawa::ilp::ILPPlugin	This interface must be implemented by plugins providing ILP processors
Cotawa::Loader	This interface is implemented by all objects that may build and provide a process
►Cotawa::ProcessorPlugin	This class must implemented by plugins containing processor, features and identifiers
Cotawa::display::Plugin	A plugin to provide driver to display graphs
►Cotawa::sim::Simulator	This class represents a plugin to use facilities provided by a simulator
Cotawa::sim::TrivialSimulator	The trivial simulator is a simplistic simulator with a fixed execution time for each instruction (defined by otawa::sim::INSTRUCTION_TIME)
Cotawa::ai::Graph::Predecessor	Iterator on the entering edges on the given vertex
►Celm::PreIterator< BBIterator, BasicBlock * > [external]
Cotawa::CFGCollection::BBIterator
Cotawa::tsim::BBPath::BBIterator
►Celm::PreIterator< BundleIter, Bundle > [external]
Cotawa::BasicBlock::BundleIter	Iterator on bundles composing a basic block
►Celm::PreIterator< ConfigIter, AbstractIdentifier * > [external]
Cotawa::ConfigIter	Iterator on the configurations of a processor
►Celm::PreIterator< DomainIter, T::t & > [external]
Cotawa::dfa::AbsIntLiteEx< G, T >::DomainIter
►Celm::PreIterator< FeatureIter, const FeatureUsage * > [external]
Cotawa::FeatureIter	Iterator on the features used by the processor
►Celm::PreIterator< Getter, const T & > [external]
Cotawa::Identifier< T >::Getter
►Celm::PreIterator< Getter, Property * > [external]
Cotawa::PropList::Getter	This class is used for accessing all properties of property list with a given identifier
►Celm::PreIterator< InIterator, E * > [external]
Cotawa::GenGraph< N, E >::InIterator
►Celm::PreIterator< InIterator, graph::Edge * > [external]
Cotawa::graph::Graph::InIterator
►Celm::PreIterator< InstIter, Inst * > [external]
Cotawa::BasicBlock::InstIter	Iterator for instructions in the basic block
Cotawa::pfg::BB::InstIter	Iterator on the instructions of a basic block
►Celm::PreIterator< ItemIter, ProgItem * > [external]
Cotawa::Segment::ItemIter
►Celm::PreIterator< Iter, const Value & > [external]
Cotawa::clp::State::Iter
►Celm::PreIterator< Iter, Property * > [external]
Cotawa::PropList::Iter	This iterator is used for reading all properties of a property list
►Celm::PreIterator< Iter, sem::inst > [external]
Cotawa::stack::Iter	Iterator on the result of stack analysis
►Celm::PreIterator< Iterator, const T & > [external]
Celm::genstruct::DLList< T, class >::Iterator [external]
►Celm::genstruct::FragTable< T >::Iterator [external]
Cotawa::CFGCollection::Iterator	Iterator on the CFG contained in a CFGCollection
Cotawa::CFGInfo::Iter
Cotawa::graph::Graph::Iterator	A simple iterator on the nodes contained in a graph
Cotawa::ilp::AbstractSystem::ConstIter
Cotawa::ilp::AbstractSystem::VarIter
►Celm::genstruct::SLList< T, E >::Iterator [external]
►Cotawa::BasicBlock::EdgeIterator
►Cotawa::BasicBlock::InIterator
Cotawa::ai::CFGGraph::Predecessor
►Cotawa::BasicBlock::OutIterator
Cotawa::ai::CFGGraph::Successor
Cotawa::FeatureDependency::Dependent
►Cotawa::ilp::Expression::Iterator
Cotawa::ilp::AbstractConstraint::TermIter
Cotawa::ParExeGraph::StageIterator
Cotawa::PathContext::BasicBlockIterator
Cotawa::TimingContext::NodeLatencyIterator
►Celm::genstruct::Vector< T >::Iterator [external]
Cotawa::ast::ASTInfo::Iterator
Cotawa::ccg::LBlockSet::Iterator
Cotawa::ContextTree::BBIterator
Cotawa::ContextTree::ChildrenIterator	Iterator for the children of a context tree
Cotawa::etime::ConfigSet::Iter
Cotawa::ExeGraph< N >::ExeNode::ContenderIterator
Cotawa::ExeGraph< N >::FunctionalUnitIterator
Cotawa::File::SegIter
Cotawa::LBlockSet::Iterator
►Cotawa::Microprocessor< N >::PipelineIterator
Cotawa::ExeGraph< N >::PipelineIterator
Cotawa::Microprocessor< N >::QueueIterator
Cotawa::ParamExeGraph::ExternalConflictIterator
Cotawa::ParamExeGraph::InternalConflictIterator
Cotawa::ParamExeGraph::RegResource::UsingInstIterator
Cotawa::ParamExeGraph::ResourceIterator
►Cotawa::ParExeInst::NodeIterator
Cotawa::ParExeGraph::InstNodeIterator
Cotawa::ParExeInst::ProducingInstIterator
Cotawa::ParExePipeline::StageIterator
Cotawa::ParExeProc::QueueIterator	Iterator for the instruction queues
►Cotawa::ParExeStage::NodeIterator	Iterator for the graph nodes related to the pipeline stage
Cotawa::ParExeGraph::StageNodeIterator
►Cotawa::PipelineStage< N >::ExeNodeIterator
Cotawa::ExeGraph< N >::StageNodeIterator
►Cotawa::PipelineStage< N >::FunctionalUnit::PipelineIterator
Cotawa::ExeGraph< N >::FunctionalUnitPipelineIterator
Cotawa::Process::FileIter
Cotawa::RegResource::UsingInstIterator
Cotawa::ResourceList::ResourceIterator
Cotawa::script::Script::ItemIter
Cotawa::SESERegion::BBIterator
Cotawa::StatInfo::Iter
Cotawa::tsim::TreePath< T1, T2 >::Iterator
►Celm::PreIterator< Iterator, N * > [external]
Cotawa::GenGraph< N, E >::Iterator
►Celm::PreIterator< Iterator, T > [external]
►Celm::genstruct::HashTable< K, T, H >::Iterator [external]
Cotawa::Registry::Iter
►Celm::PreIterator< Iterator, Vertex > [external]
Cotawa::display::CFGAdapter::Iterator
Cotawa::display::GenGraphAdapter< G >::Iterator
►Celm::PreIterator< Iterator< T >, T > [external]
►Celm::datastruct::Iterator< Constraint * > [external]
Cotawa::ilp::System::ConstIterator
►Celm::datastruct::Iterator< Constraint::Term > [external]
Cotawa::ilp::System::ObjTermIterator
►Celm::datastruct::Iterator< Term > [external]
Cotawa::ilp::Constraint::TermIterator
►Celm::PreIterator< OneIterator, int > [external]
►Celm::BitVector::OneIterator [external]
Cotawa::dfa::BitSet::Iterator	Iterator on the item contained in a bit set
►Celm::PreIterator< OutIterator, E * > [external]
Cotawa::GenGraph< N, E >::OutIterator
►Celm::PreIterator< OutIterator, graph::Edge * > [external]
Cotawa::graph::Graph::OutIterator
►Celm::PreIterator< PathIter, sem::inst > [external]
Cotawa::sem::PathIter	This iterator allows easily to traverse all execution paths of a block of semantic instructions
►Celm::PreIterator< PCGBlockInIterator, PCGBlock * > [external]
Cotawa::PCGBlock::PCGBlockInIterator
►Celm::PreIterator< PCGBlockOutIterator, PCGBlock * > [external]
Cotawa::PCGBlock::PCGBlockOutIterator
►Celm::PreIterator< PCGIterator, PCGBlock * > [external]
Cotawa::PCG::PCGIterator
►Celm::PreIterator< Predecessor, BasicBlock * > [external]
Cotawa::dfa::Predecessor	This iterator is used to traverse forward a CFG in an iterative DFA analysis
►Celm::PreIterator< Predecessor, Edge > [external]
Cotawa::BackwardCFGAdapter::Predecessor
Cotawa::ForwardCFGAdapter::Predecessor
►Celm::PreIterator< Predecessor, N * > [external]
Cotawa::ExeGraph< N >::Predecessor
►Celm::PreIterator< Predecessor, Node * > [external]
Cotawa::graph::Node::Predecessor	This class allows to iterates on the predecessors of a node
►Celm::PreIterator< Predecessor, ParExeNode * > [external]
Cotawa::ParExeGraph::Predecessor
►Celm::PreIterator< PreorderIterator< G >, G::Vertex > [external]
Cotawa::graph::PreorderIterator< G >	An iterator allowing to traverse the graph using preorder, that is, a node is only traversed when its predecessors has been traversed
►Celm::PreIterator< PreorderIterator< Graph >, Graph::Vertex > [external]
►Cotawa::graph::PreorderIterator< Graph >
Cotawa::ExeGraph< N >::PreorderIterator
►Celm::PreIterator< PreorderIterator< ParExeGraph >, ParExeGraph::Vertex > [external]
►Cotawa::graph::PreorderIterator< ParExeGraph >
Cotawa::ParExeGraph::PreorderIterator
►Celm::PreIterator< RegIter, const hard::Register * > [external]
Cotawa::RegIter
►Celm::PreIterator< Successor, BasicBlock * > [external]
Cotawa::dfa::Successor	This iterator is used to traverse backward a CFG in an iterative DFA analysis
►Celm::PreIterator< Successor, Edge > [external]
Cotawa::BackwardCFGAdapter::Successor
Cotawa::display::CFGAdapter::Successor
Cotawa::display::GenGraphAdapter< G >::Successor
Cotawa::ForwardCFGAdapter::Successor
►Celm::PreIterator< Successor, N * > [external]
Cotawa::ExeGraph< N >::Successor
►Celm::PreIterator< Successor, Node * > [external]
Cotawa::graph::Node::Successor	This class allows to iterates on the successors of a node
►Celm::PreIterator< Successor, ParExeNode * > [external]
Cotawa::ParExeGraph::Successor
►Celm::PreIterator< WorkListDriver< D, G, S >, G::vertex_t > [external]
Cotawa::ai::WorkListDriver< D, G, S >	Driver of abstract interpretation with a simple to-do list
Cotawa::sem::Printer	Printer class for semantic instructions (resolve the generic register value to the their real platform name)
Cotawa::ccg::Problem
Cotawa::hard::Processor	Description of a processor pipeline
Cotawa::hard::ProcessorBuilder
Cotawa::Progress	This class is an interface to get progress information about execution of a processor
►Cotawa::Property	A property associates a data with an identifier
Cotawa::ContextualProperty	A contextual property is a special property that allows to retrieve a property value by its contextual path (ContextualPath)
►Cotawa::GenericProperty< T >	This generic class allows attaching any type of data to a property
Cotawa::DeletableProperty< T >	A deletable property is a genericproperty whose value will be deleted when the property is destroyed
Cotawa::LockedProperty< T >	This class is used for building a lock property, that is, for taking pointer values implementing the elm::Locked class
►Cotawa::PropList	This a list of properties
►Cotawa::AbstractIdentifier	Represents a unique identifier used by the annotation system
►Cotawa::Identifier< AbstractIdentifier * >
►Cotawa::AbstractParamIdentifier	A parametric identifier allows to instantiate identifier depending on a parametric feature
Cotawa::ParamIdentifier< T >	Implementation of AbstractParamIdentifier for an Identifier
►Cotawa::Identifier< AbstractParamProcessor * >
Cotawa::ParamFeature	A parametric feature is a feature that may be instantiated according to some parameters passed in a property list
Cotawa::Identifier< bool >
Cotawa::Identifier< dfa::BitSet * >
Cotawa::Identifier< display::kind_t >
Cotawa::Identifier< Domain * >
Cotawa::Identifier< double >
Cotawa::Identifier< elm::CString >
Cotawa::Identifier< elm::genstruct::DLList * >
Cotawa::Identifier< elm::io::elm::io::Output * >
Cotawa::Identifier< elm::io::elm::io::OutStream * >
Cotawa::Identifier< elm::Pair >
Cotawa::Identifier< elm::String >
Cotawa::Identifier< elm::sys::Path >
Cotawa::Identifier< elm::system::elm::sys::Path >
Cotawa::Identifier< elm::system::time_t >
Cotawa::Identifier< int >
Cotawa::Identifier< log_level_t >
Cotawa::Identifier< otawa::AbstractParamIdentifier * >
Cotawa::Identifier< otawa::arm::Info * >
Cotawa::Identifier< otawa::ast::AST * >
Cotawa::Identifier< otawa::BasicBlock * >
Cotawa::Identifier< otawa::ccg::Collection * >
Cotawa::Identifier< otawa::ccg::Node * >
Cotawa::Identifier< otawa::CEClass * >
Cotawa::Identifier< otawa::CFG * >
Cotawa::Identifier< otawa::CFGInfo * >
Cotawa::Identifier< otawa::display::ILPSystemAddon * >
Cotawa::Identifier< otawa::Microprocessor< ExeNode > * >
Cotawa::Identifier< otawa::PCG * >
Cotawa::Identifier< otawa::Progress * >
Cotawa::Identifier< otawa::PropList * >
Cotawa::Identifier< otawa::StatInfo * >
Cotawa::Identifier< otawa::Symbol * >
Cotawa::Identifier< otawa::tsim::TreePath< otawa::BasicBlock *, otawa::tsim::BBPath * > * >
►Cotawa::Identifier< Processor * >
►Cotawa::AbstractFeature	See Feature
Cotawa::ActualFeature	An actual feature is the result of the instantiation of a parametric feature
Cotawa::Feature< T, C >	A feature is a set of facilities, usually provided using properties, available on a framework
Cotawa::p::feature	Shortcut to create a feature with a maker (without the mess of SilentFeature)
Cotawa::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)
Cotawa::Identifier< T * >
Cotawa::Identifier< typename FixPoint::FixPointState * >
Cotawa::Identifier< typename otawa::dfa::hai::DefaultFixPoint::FixPointState * >
Cotawa::Identifier< typename otawa::dfa::hai::FirstUnrollingFixPoint::FixPointState * >
Cotawa::Identifier< typename otawa::dfa::hai::WideningFixPoint::FixPointState * >
Cotawa::Identifier< typename P::Domain * >
Cotawa::Identifier< typename Problem::Domain * >
►Cotawa::AbstractAccessor
►Cotawa::Accessor< T >
Cotawa::FunAccessor< T >
►Cotawa::AbstractParamProcessor	Abstract form of a parametric processor
Cotawa::ParamProcessor	A parametric processor allows to generate processor for parametric feature
Cotawa::Identifier< T >	This class represents identifier with a typed associated value
Cotawa::ast::AST	This is the base class for the representation of programs as Abstract Syntax Trees
Cotawa::ast::ASTInfo	This class stores all the function known for the current framework
►Cotawa::BasicBlock	This is the minimal definition of a basic block
Cotawa::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
Cotawa::EndBasicBlock
Cotawa::VirtualBasicBlock
Cotawa::cat::CATNode
Cotawa::ccg::Edge	This class represents edges in the CCG representation
Cotawa::ccg::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
►Cotawa::CFG	Control Flow Graph representation
Cotawa::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
Cotawa::ContextTree
Cotawa::ContextualProperty::Node
Cotawa::dcache::BlockAccess	A block access represents a data memory access of an instruction
►Cotawa::display::Item	This class is the base of Graph, Node and Edge
►Cotawa::display::Edge
Cotawa::display::GraphVizEdge
►Cotawa::display::Graph	A graph provides facilities to display a graph
Cotawa::display::GraphVizGraph
►Cotawa::display::Node
Cotawa::display::GraphVizNode
Cotawa::Edge	This class represents edges in the CFG representation
Cotawa::etime::Event	An event represents a time variation in the execution of an instruction
Cotawa::File	This class represents a file involved in the building of a process
Cotawa::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
Cotawa::PCG
Cotawa::PCGBlock
Cotawa::Process	A process is the realization of a program on a platform
Cotawa::ProgItem	Base class of the components of a program file segment
Cotawa::Segment	In usual file format like ELF, COFF and so on, the program file is divided in segment according platform needs or memory propertes
Cotawa::SESERegion
Cotawa::sim::State	This class represents a running simulator
Cotawa::Symbol	A symbol is a name of a location in a program
Cotawa::tsim::BBPath
Cotawa::WorkSpace	A workspace represents a program, its run-time and all information about WCET computation or any other analysis
►Cotawa::hard::PureCache
Cotawa::hard::BHT	This class contains all information about the Branch History Predictor, that is,
Cotawa::hard::Queue	The instructions queues stores instruction that come from one stage to another one
Cotawa::Queue< N >
Cotawa::Queue< otawa::ParamExeNode >
Cotawa::hard::QueueBuilder
Cotawa::ContextualPath::Ref< T >
►Cotawa::hard::RegBank	This class represents a bank of registers
Cotawa::hard::MeltedBank	A melted bank may contains registers with different sizes and kinds
Cotawa::hard::PlainBank	A plain bank is a register bank whose registers have the same size and the same type
Cotawa::hard::Register	Objects of this class are simple machine register, more accurately unbreakable atomic registers
Cotawa::ParExeGraph::rename_table_t
Cotawa::ExeGraph< N >::rename_table_t
►Cotawa::ParamExeGraph::Resource
Cotawa::ParamExeGraph::ExternalConflictResource
Cotawa::ParamExeGraph::FuResource
Cotawa::ParamExeGraph::InternalConflictResource
Cotawa::ParamExeGraph::QueueResource
Cotawa::ParamExeGraph::RegResource
Cotawa::ParamExeGraph::StageResource
Cotawa::ParamExeGraph::StartResource
►Cotawa::Resource
Cotawa::QueueResource
Cotawa::RegResource
Cotawa::StageResource
Cotawa::StartResource
Cotawa::ResourceList
CResult	Class to hold the results (for each basic block) of the abstract interpretation
CResult	Class to hold the results (for each basic block) of the abstract interpretation
CResult	Class to hold the results (for each basic block) of the abstract interpretation
CResult	Class to hold the results (for each basic block) of the abstract interpretation
Cotawa::script::ScriptItem	These objects represents the item of the configuration of a script
Cotawa::display::ShapeStyle	Shape style
Cotawa::SimState
Cotawa::PCGBuilder::stack_t
Cotawa::hard::StageBuilder
►Cotawa::StatCollector	A statistics collector allows to access statistics produced by an analysis
Cotawa::BBStatCollector	This class alleviates the work of building a statistics collector
Cotawa::clp::State	The abstract state of the computer (abstract domain)
Cotawa::dfa::State	Represents a value of the data state
Cotawa::dfa::FastState< D >::state_t
Cotawa::StatInfo	Aggregator of statistics put on the workspace
Cotawa::ai::Graph::Successor	Iterator on the leaving edges of the given vertex
►Cotawa::SymAddress	Abstraction of a program address that may be expressed using several ways: absolute address, label + offset, source file:line, etc
Cotawa::AbsoluteAddress	Symbolic address as an absolute address
Cotawa::LabelAddress	A label address formed by a label and a possible signed offset
►Cotawa::se::SymbExpr	Symbolic expression
Cotawa::se::SEAdd	Addition
Cotawa::se::SEAddr	Memory reference
Cotawa::se::SECmp	Compare symbolic expression This class define three type of compare expression: condition (if): SECmp(operator, expression) undetermined compare: SECmp(CMP, exp1, exp2) determined compare: SECmp(operator, exp1, exp2)
Cotawa::se::SEConst	Constants
Cotawa::se::SENeg	Negation
Cotawa::se::SEReg	Register
►Cotawa::ilp::System	An ILP system is a colletion of ILP constraint that may maximize or minimize some object function
Cotawa::ilp::AbstractSystem	This class provides a convenient way to handle ILP systems in OTAWA
Cotawa::dcache::DirtyManager::t
Cotawa::ilp::Term
Cotawa::display::TextStyle	Description of the style of text
Cotawa::TimingContext
►Celm::inhstruct::Tree [external]
Cotawa::ContextualProperty::Node
Cotawa::tsim::TreePath< T1, T2 >
Cotawa::tsim::TreePath< otawa::BasicBlock *, otawa::tsim::BBPath * >
►Cotawa::Type	This class describes the type of the data in the program
Cotawa::BaseType	This class provides a representation for the base type
Cotawa::NoType	Null value for types
Cotawa::cpp::Unmangler
Cotawa::dfa::hai::UnrollingListener< P >	This listener gathers in an array the LUB of the in-states for all analyzed basic blocks
Cotawa::clp::Value	A set of values represented by a Circular Linear Progression
Cotawa::stack::Value	Values in the StackAnalysis
Cotawa::dfa::Value
►Cotawa::ilp::Var	A variable is an identifier used for performing ILP computation
Cotawa::ilp::AbstractSystem::AbstractVar
Cotawa::ilp::Alias	An alias is a specific variable that represents an expressions
Cotawa::ilp::VarImpl	Very trivial implementation of the Var class
Cotawa::ilp::var	Encapsulation for ilp::Var pointers for {ilp} expr user-fiendly interface
►Celm::genstruct::Vector< const Alternative * > [external]
Cotawa::AlternativeProcessor::AlternativeSet	Set of alternatives for an AlternativeProcessor
►Celm::genstruct::Vector< inst > [external]
Cotawa::sem::Block	A block represents a sequence of semantic instructions inst
Cotawa::display::CFGAdapter::Vertex
►Cotawa::display::AbstractDrawer::Vertex	This class represents vertices in the AbstractDrawer
Cotawa::display::GenDrawer< G, D >::Vertex
Cotawa::display::GenGraphAdapter< G >::Vertex
Cotawa::concept::DiGraph::Vertex	Vertex class
Cotawa::display::CFGAdapter::VertexMap< T >
Cotawa::display::GenGraphAdapter< G >::VertexMap< T >
Cotawa::dfa::hai::WideningFixPoint< Listener >
Cotawa::dfa::hai::WideningListener< P >	This listener gathers in an array the LUB of the in-states for all analyzed basic blocks
Cotawa::dfa::XCFGVisitor< P >	This class implements the visitor concept of XIterativeDFA class and allows applying an analysis on a collection of CFG in a flow-insensitive way
Cotawa::dfa::XIterativeDFA< V >	The DFAEngine implements an extended Iterative Data Flow Algorithm, that is, it work on graphs with any forms