| ►Nelm | |
| CHashKey< otawa::Address > | |
| Ctype_info< otawa::ilp::format_t > | |
| ►Notawa | $Id$ Copyright (c) 2007, IRIT - UPS casse.nosp@m.@iri.nosp@m.t.fr |
| ►Nai | |
| CArrayStore | Stockage of output values as an array |
| ►CCFGGraph | BiDiGraph implementation for CFG |
| CIterator | |
| CPredecessor | |
| CSuccessor | |
| CDomain | Domain concept for ai module |
| CEdgeStore | State storage on the edges |
| ►CGraph | Graph concept for ai module |
| CIterator | Iterator on the vertices of the graph |
| CPredecessor | Iterator on the entering edges on the given vertex |
| CSuccessor | Iterator on the leaving edges of the given vertex |
| CInputIter | Iterator on input of a vertex |
| COutputIter | Iterator to set output values |
| CWorkListDriver | Driver of abstract interpretation with a simple to-do list |
| ►Narm | |
| CInfo | |
| CIOManager | |
| ►Nast | |
| CAST | This is the base class for the representation of programs as Abstract Syntax Trees |
| ►CASTInfo | This class stores all the function known for the current framework |
| CIterator | |
| CASTLoader | This class may be used for loading AST from an external file using the Heptane format (see doc/ directory for more details) |
| CASTProcessor | This is a specialization of the processor class dedicated to AST processing |
| CBlockAST | This class represents the leafs of the AST |
| CCallAST | This class is a specialized block AST ended by a function call |
| CDoWhileAST | Representation of C do{ .. |
| CForAST | Representation of C language FOR loop |
| CFunAST | This class represents functions in the AST representation |
| CFunProcessor | This is a specialization of the processor class dedicated to function processing |
| CIfAST | AST for representing selections |
| CSeqAST | This AST represents sequences |
| CWhileAST | Representation of an iteration with test at start of the loop |
| ►Nbpred | |
| CBPredProcessor | This is a specialization of the CFGProcessor class dedicated to branch prediction |
| ►Nbranch | |
| CBranchBuilder | Compute the categories for branch prediction |
| CCondNumber | Associate numbers to each branch relatively to their BHT set |
| CConsBuilder | This processor add to the current ILP the constraint requires to model the behaviour of the BHT |
| COnlyConsBuilder | This processor add to the current ILP the constraint requires to model the behavior of the BHT |
| ►Ncache | |
| CCategoryStats | This class is used to store statistics about the categories about cache accesses |
| ►Ncat | |
| CCATBuilder | Create a new CATBuilder processor |
| CCATConstraintBuilder | 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 |
| CCATDomain | |
| CCATNode | |
| CCATProblem | |
| ►Nccg | |
| CBuilder | This processor builds the Cache Conflict Graph of the current task |
| CCollection | |
| CConstraintBuilder | This processor allows handling timing effects of the instruction cache in the IPET approach |
| CDomain | |
| CEdge | This class represents edges in the CCG representation |
| CGraph | |
| CLBlock | 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 |
| CLBlockBuilder | This processor builds the list of l-blocks for each lines of instruction cache and stores it in the CFG |
| ►CLBlockSet | This class represents the list of l-blocks of a task for a chosen cache row |
| CIterator | |
| CNode | Node of a CCG (Cache Conflict Graph) |
| CProblem | |
| ►Ncfgio | |
| COutput | Output the current CFG collection in XML matching the DTA ${OTAWA_HOME}/share/Otawa/dtd/cfg.dtd |
| ►Nclp | |
| CAnalysis | |
| ►CClpStatePack | A pack of CLP states inside a BasicBlock |
| CContext | A context allows to share a CLP problem through different constructions of ClpStatePack |
| CInstPack | A pack of CLP states inside a machine instruction |
| CManager | This class allows to exploit the result of a CLP analysis |
| ►CState | The abstract state of the computer (abstract domain) |
| CIter | |
| CNode | A node in the memory list |
| CValue | A set of values represented by a Circular Linear Progression |
| ►Nconcept | |
| CAbstractDomain | Concept used to implements AbsIntLite domain |
| ►CBiDiGraph | Concept of directed graph with predecessor available |
| CPredecessor | Entering-in edge iterator on a node |
| ►CDiGraph | This concept attempts to provide a representation of a digraph that may only be traversed in the edge direction |
| CEdge | Opaque type for the edges |
| CSuccessor | Outing edge iterator on a node |
| CVertex | Vertex class |
| ►CDiGraphWithEdgeMap | Concept of directed graph providing an edge map |
| CEdgeMap | Efficient map for the edges |
| CDiGraphWithEntry | Directed graph with a unique entry point |
| CDiGraphWithExit | Directed graph with a unique entry and exit points |
| CDiGraphWithIndexedVertex | This kind of digraph contain indexed graph |
| CDiGraphWithLoop | A digraph that supports loop identification |
| ►CDiGraphWithVertexMap | Concept of directed graph providing a vertex map |
| CVertexMap | Efficient map for the nodes |
| ►CInstBlock | An iterable block of instruction |
| CInstIter | Iterator on the instruction of the block |
| CIterativeDFAProblem | Concept used to implements IterativeDFA problems |
| ►Ncpp | |
| CUnmangler | |
| CUnmanglingException | |
| ►Ndcache | |
| CACS | Representation of an Abstract Cache State where each data cache block is represented by its age |
| CACSBuilder | This builder performs analysis of the L1 data cache and produces ACS for MUST and, according to the configuration proerties, persistence |
| CACSMayBuilder | This processor computes the ACS for the MAY cache analysis |
| CBlock | Represents a single block used by the data cache |
| CBlockAccess | A block access represents a data memory access of an instruction |
| CBlockBuilder | Build the list of blocks used for L1 data cache analysis and decorate each basic block with the list of performed accesses |
| CBlockCollection | A block collections stores the list of data blocks used in a task for a specific line |
| CCATBuilder | Processor to get the categories for each block access of a data cache |
| CCatConstraintBuilder | This processor allocates the variable to count misses of a data cache and makes the constraints for these variables |
| CCLPBlockBuilder | 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 |
| ►CDirtyManager | A dirty manager allows to exploit the results of the dirty analysis (DIRTY_FEATURE) |
| Ct | |
| ►CMAYProblem | |
| CDomain | |
| ►CMUSTPERS | |
| CDomain | ACS of the MUSTPERS problem |
| ►CMUSTProblem | The MUST problem provides the abstract interpretation of L1 data cache for the MUST case |
| CDomain | |
| ►CPERSProblem | Problem for computing the PERS ACS of L-blocks |
| CDomain | |
| CItem | ACS for the multi-level data cache persistence analysis |
| CWCETFunctionBuilder | Default implementation of feature WCET_FUNCTION_FEATURE |
| ►Ndfa | |
| ►Nhai | |
| ►CDefaultFixPoint | |
| CFixPointState | |
| CDefaultListener | This listener gathers in an array the LUB of the in-states for all analyzed basic blocks |
| ►CFirstUnrollingFixPoint | FixPoint class for HalfAbsInt The DefaultFixPoint manages loops in a simple way |
| CFixPointState | State info class for FirstUnrollingFixPoint This FixPoint needs to remember: |
| CHalfAbsInt | Implements abstract interpretation |
| CUnrollingListener | This listener gathers in an array the LUB of the in-states for all analyzed basic blocks |
| ►CWideningFixPoint | |
| CFixPointState | |
| CWideningListener | This listener gathers in an array the LUB of the in-states for all analyzed basic blocks |
| CAbsIntLite | This class provides a light implementation for abstract interpretation |
| ►CAbsIntLiteEx | |
| CDomainIter | |
| CAbsIntLiteExtender | |
| ►CBitSet | This class implements a set as a bit vector |
| CIterator | Iterator on the item contained in a bit set |
| ►CFastState | Fast implementation of abstract domain on the functional state of a microprocessor including the registers and the memory content |
| Cnode_t | |
| Cstate_t | |
| CIterativeDFA | 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" |
| CMemCell | |
| CPredecessor | This iterator is used to traverse forward a CFG in an iterative DFA analysis |
| ►CState | Represents a value of the data state |
| CMemIter | |
| CRegIter | |
| CSuccessor | This iterator is used to traverse backward a CFG in an iterative DFA analysis |
| CValue | |
| ►CXCFGVisitor | This class implements the visitor concept of XIterativeDFA class and allows applying an analysis on a collection of CFG in a flow-insensitive way |
| Cnode_t | |
| CXIterativeDFA | The DFAEngine implements an extended Iterative Data Flow Algorithm, that is, it work on graphs with any forms |
| ►Ndisplay | |
| ►CAbstractDrawer | Provides facilities to draw a graph |
| CEdge | An edge in a AbstractDrawer |
| CVertex | This class represents vertices in the AbstractDrawer |
| ►CCFGAdapter | This adapter implements the otawa::concept::DiGraphWithNodeMap and allows to use apply the GenDrawer to a CFG |
| CEdge | |
| CIterator | |
| CSuccessor | |
| CVertex | |
| CVertexMap | |
| CCFGDrawer | |
| CCFGOutput | |
| CColor | A color description |
| CDecorator | A decorator is a concept that provides static functions used to display a graph |
| CDefaultDecorator | Default decorator that just output the given edges and vertices |
| CDisplayException | This exception is thrown during the display of a graph if there is an error |
| CDriver | A driver provides facilities to display a graph |
| CEdge | |
| CException | |
| CFillStyle | The style of a filled area |
| ►CGenDrawer | A simple engine to draw graphs |
| CEdge | |
| CVertex | |
| ►CGenGraphAdapter | |
| CEdge | |
| CIterator | |
| CSuccessor | |
| CVertex | |
| CVertexMap | |
| CGraph | A graph provides facilities to display a graph |
| CGraphVizDriver | |
| CGraphVizEdge | |
| CGraphVizGraph | |
| CGraphVizGraphElement | |
| CGraphVizItem | |
| CGraphVizNode | |
| CILPSystemAddon | This class is an interface for ILPSystemDisplayer to add to its output specialized information about ILP variables and constraints generators |
| CILPSystemDisplayer | This processor may be used to generate an HTML output of an ILP system used to compute the WCET of a task |
| CItem | This class is the base of Graph, Node and Edge |
| CLineStyle | |
| CNode | |
| CPlugin | A plugin to provide driver to display graphs |
| CShapeStyle | Shape style |
| CTextStyle | Description of the style of text |
| ►Netime | |
| CConfig | Represents a configuration for computing cost of a BB |
| ►CConfigSet | Set of configurations with the same or with a maximum of time |
| CIter | |
| ►CEdgeTimeBuilder | Compute execution time by edge using the parametric exegraph approach |
| CEventComparator | |
| CEvent | An event represents a time variation in the execution of an instruction |
| CEventCollector | Collects variables linking events with blocks in ILP |
| CStandardEventBuilder | Build standard events |
| ►Nets | |
| CAbstractCacheState | This class is used to represent an abstract cache line state |
| CACSComputation | This processor is used to simule cache states |
| CCacheFirstMissComputation | This processor is used for computing the First Misses accesses after the cache simulating |
| CCacheHitComputation | This processor is used for computing the Hit accesses after the cache simulating |
| CCacheMissComputation | This processor is used for computing the Miss accesses after the cache simulating |
| CFlowFactLoader | This processor allows using extern flow facts in ETS |
| CTrivialAstBlockTime | 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 |
| CWCETComputation | This processor is used for computing the WCET with the Extended Timing Schema |
| ►Ngliss | |
| CInfo | This class provides access to the stay-behind GLISS data structures and code provided by the GLISS v2 utility used by some loaders |
| ►Ngraph | |
| CEdge | This class represents a directed edge between two nodes |
| ►CGraph | This class represents a full graph with nodes and edges |
| CInIterator | |
| CIterator | A simple iterator on the nodes contained in a graph |
| COutIterator | |
| ►CNode | The node from a directed graph |
| CPredecessor | This class allows to iterates on the predecessors of a node |
| CSuccessor | This class allows to iterates on the successors of a node |
| CPreorderIterator | An iterator allowing to traverse the graph using preorder, that is, a node is only traversed when its predecessors has been traversed |
| ►Nhard | |
| CBank | A bank in the memory |
| CBHT | This class contains all information about the Branch History Predictor, that is, |
| CBus | A bus that tie together several memory banks |
| ►CCache | This class contains the configuration of a level of cache of processor |
| Cinfo_t | |
| CCacheConfiguration | This class represents the full configuration of caches of a processor |
| CDispatch | A dispatch object allows to map some kinds of instructions to a functional unit |
| CDumper | Dump to output the hardware configuration details |
| CFunctionalUnit | A functional unit is specialized in the computation of some kinds of instructions |
| CFunctionalUnitBuilder | |
| CMeltedBank | A melted bank may contains registers with different sizes and kinds |
| CMemory | Class to represent the whole memory of the platform |
| CMode | A working mode for the hardware memory |
| CModeTransition | Representation of a memory bank transition |
| CPipelineUnit | |
| CPlainBank | A plain bank is a register bank whose registers have the same size and the same type |
| ►CPlatform | This class records information about the architecture where the processed program will run |
| CIdentification | |
| CProcessor | Description of a processor pipeline |
| CProcessorBuilder | |
| CPureCache | |
| CQueue | The instructions queues stores instruction that come from one stage to another one |
| CQueueBuilder | |
| CRegBank | This class represents a bank of registers |
| CRegister | Objects of this class are simple machine register, more accurately unbreakable atomic registers |
| CStage | This class represents a stage in a pipeline |
| CStageBuilder | |
| ►Nilp | |
| ►CAbstractConstraint | Constraint generated by AbstractSystem |
| CTermIter | |
| ►CAbstractSystem | This class provides a convenient way to handle ILP systems in OTAWA |
| CAbstractVar | |
| CConstIter | |
| CVarIter | |
| CAlias | An alias is a specific variable that represents an expressions |
| Ccons | Encapsulation for ilp::Constraint pointers for {ilp} expr user-fiendly interface |
| ►CConstraint | This class is used to represent constraints in an ILP system with the following form: |
| CTermIterator | |
| CConstraintImpl | Provide a simple implementation of a constraint using expression |
| ►CExpression | An expression allows to represent a sum of terms and may be used to represent the value of an aliased variable |
| CIterator | |
| CILPPlugin | This interface must be implemented by plugins providing ILP processors |
| Cmodel | Encapsulation for ilp::System pointers for {ilp} expr user-fiendly interface |
| COutput | This processor provides an output of the built ILP system |
| ►CSystem | An ILP system is a colletion of ILP constraint that may maximize or minimize some object function |
| CConstIterator | |
| CObjTermIterator | |
| CTerm | |
| CVar | A variable is an identifier used for performing ILP computation |
| Cvar | Encapsulation for ilp::Var pointers for {ilp} expr user-fiendly interface |
| CVarImpl | Very trivial implementation of the Var class |
| ►Nipet | |
| CBasicConstraintsBuilder | |
| CBasicObjectFunctionBuilder | 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 + .. |
| CCachePenaltiesObjectFunctionBuilder | This processor is used for building the basic object function function in case of a L1 instruction cache |
| CConstraintLoader | This code processor allows loading IPET constraint from an external file |
| CFlowFactConstraintBuilder | This processor allows using extern flow facts in an IPET system |
| CFlowFactLoader | This processor allows using extern flow facts in an IPET system |
| CILPSystemGetter | This processor looks for an ILP plugin and build a new system that will be used by other IPET processor |
| CTrivialBBTime | 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 |
| CTrivialDataCacheManager | This processor apply a simple method for managing data cache in IPET method |
| CTrivialInstCacheManager | This processor is a trivial manager of instruction cache for IPET approach |
| CVarAssignment | This processor ensures that each basic block and each edge of the CFG has a variable associated with a ipet::VAR annotation |
| CWCETComputation | This class is used for computing the WCET from the system found in the root CFG |
| CWCETCountRecorder | 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 |
| ►Nloader | |
| ►Nnew_gliss | |
| CBranchInst | |
| CInst | |
| CProcess | |
| ►Nold_gliss | |
| CBranchInst | |
| CInst | |
| CProcess | |
| ►Np | |
| Cdeclare | Class to declare simple a processor |
| Cfeature | Shortcut to create a feature with a maker (without the mess of SilentFeature) |
| Cinit | |
| ►Npfg | |
| ►CBB | A basic block in a otawa::pfg::PFG |
| CInstIter | Iterator on the instructions of a basic block |
| CEdge | This class represents the control transfer between basic block (BB) |
| CPFG | 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 |
| ►Nscript | |
| CNamedObject | Named are used by script to locate a data structure passed as argument to a code processor |
| ►CScript | A script processor allows to interpret a file that performs a WCET computation |
| CItemIter | |
| CScriptItem | These objects represents the item of the configuration of a script |
| ►Nse | |
| CFilterBuilder | |
| CSEAdd | Addition |
| CSEAddr | Memory reference |
| CSECmp | 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) |
| CSEConst | Constants |
| CSENeg | Negation |
| CSEReg | Register |
| CSymbExpr | Symbolic expression |
| ►Nsem | |
| ►CBlock | A block represents a sequence of semantic instructions inst |
| CInstIter | |
| Cinst | This structure class represents an instruction in the semantics representation of machine instruction |
| CPathIter | This iterator allows easily to traverse all execution paths of a block of semantic instructions |
| CPrinter | Printer class for semantic instructions (resolve the generic register value to the their real platform name) |
| ►Nsim | |
| CAbstractCacheDriver | This is an abstract implementation of the cache driver allowing to customize only the cache replacement policy |
| CBasicBlockDriver | This class is a simulator Driver that executes the instruction sequence found in a basic block |
| CBBPathDriver | |
| CCacheDriver | This class provides a simple interface to drive the cache management unit of a simulator |
| CDirectMappedCacheDriver | This class provide a cache driver implementing direct mapped cache driver |
| CDriver | This class is used to drive a simulator |
| CException | Exception generated by a simulator |
| CFIFOCacheDriver | This class provide a cache driver implementing a FIFO policy |
| CLRUCacheDriver | This class provide a cache driver implementing the LRU replacement policy |
| CSimulator | This class represents a plugin to use facilities provided by a simulator |
| CState | This class represents a running simulator |
| CTrivialSimulator | The trivial simulator is a simplistic simulator with a fixed execution time for each instruction (defined by otawa::sim::INSTRUCTION_TIME) |
| ►Nstack | |
| CIter | Iterator on the result of stack analysis |
| CValue | Values in the StackAnalysis |
| ►Ntsim | |
| ►CBBPath | |
| CBBIterator | |
| CBBTimeSimulator | |
| CDelta | |
| CTimeDeltaObjectFunctionModifier | 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 |
| ►CTreePath | |
| CIterator | |
| C__type | |
| C__type< bool > | |
| C__type< char > | |
| C__type< double > | |
| C__type< elm::CString > | |
| C__type< elm::String > | |
| C__type< float > | |
| C__type< int > | |
| C__type< long > | |
| C__type< long double > | |
| C__type< long long > | |
| C__type< short > | |
| C__type< signed char > | |
| C__type< unsigned char > | |
| C__type< unsigned int > | |
| C__type< unsigned long > | |
| C__type< unsigned long long > | |
| C__type< unsigned short > | |
| C__type< void > | |
| CAbsAddress | Subclass of AccessedAddress, this class represents an absolute address access, to a global variable or to an input/output register for example |
| CAbsoluteAddress | Symbolic address as an absolute address |
| CAbstractAccessor | |
| CAbstractFeature | See Feature |
| CAbstractIdentifier | Represents a unique identifier used by the annotation system |
| CAbstractMaker | |
| CAbstractParamIdentifier | A parametric identifier allows to instantiate identifier depending on a parametric feature |
| CAbstractParamProcessor | Abstract form of a parametric processor |
| CAbstractRegistration | Abstract class to represent the registered processors |
| CAccessedAddress | Parent class of classes representing accesses to memory |
| CAccessedAddresses | For each basic block, provide the list of performed memory accesses and their addresses |
| CAccessedAddressFromStack | |
| CAccessor | |
| CACSBuilder | This processor builds the MUST and PERS cache states before each basic block |
| CACSMayBuilder | This processor produces the Abstract Cache States (ACS), for the MAY ACS |
| CActualFeature | An actual feature is the result of the instantiation of a parametric feature |
| CAddress | The representation of an address in OTAWA |
| Caddress_stat_t | |
| CAddressOption | An option allowing to read an address, currently, only an unsigned decimal, hexadecimal and so one value |
| ►CAlternativeProcessor | With OTAWA classic scheduler, the list of required feature if fixed in the registration data structure |
| CAlternative | Represent an alternetive in the requirement of an AlternativeProcessor, i.e., a list of required or used features |
| CAlternativeSet | Set of alternatives for an AlternativeProcessor |
| CAmbiguousBoundException | |
| CApplication | A class making easier the use of applications built on OTAWA |
| ►CBackwardCFGAdapter | Adapter of CFG to the concept of otawa::concept::DiGraphWithIndexedVertex but with backward traversal of edges |
| CIterator | |
| CPredecessor | |
| CSuccessor | |
| CBag | |
| CBaseType | This class provides a representation for the base type |
| ►CBasicBlock | This is the minimal definition of a basic block |
| CBundle | A bundle, in a VLIW processors, is a group of instructions executed in parallel |
| CBundleIter | Iterator on bundles composing a basic block |
| CEdgeIterator | |
| CInIterator | |
| CInstIter | Iterator for instructions in the basic block |
| COutIterator | |
| CBasicGraphBBTime | This property is used to pass the microprocessor description to the code processor |
| CBBCleaner | Efficient implementation of a cleaner for properties found on a basic block |
| CBBDeletor | Basic block cleaner removing an identifier and deleting its content |
| CBBProcessor | This processor is dedicated to the basic block process thru proccessBB() method |
| CBBRatioDisplayer | This class output statistics for each basic block in the WCET as a table in a textual form on the standard output |
| CBBRemover | |
| CBBStatCollector | This class alleviates the work of building a statistics collector |
| ►CBranchProblem | |
| CDomain | |
| CCachePenalty | This class can be used to express the penalties due to the instruction cache |
| CCAT2Builder | This processor produces categorization information for each l-block |
| CCAT2ConstraintBuilder | 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 |
| CCAT2NCBuilder | This processor produces categorization information for each l-block |
| CCAT2OnlyConstraintBuilder | Build the constraints to support categories of cat2 module |
| CCEClass | |
| ►CCFG | Control Flow Graph representation |
| CBBIterator | |
| CCFGBuilder | This processor is used for building the CFG from the binary program representation |
| CCFGChecker | The analysis does not produce anything but simply check some properties on the involved CFG: |
| CCFGCheckSummer | Add to each involved CFG a checksum build on the instruction of the CFG |
| ►CCFGCollection | Contains a collection of CFGs (used with INVOLVED_CFGS property) |
| CBBIterator | |
| CIterator | Iterator on the CFG contained in a CFGCollection |
| CCFGCollector | This processor is used to collect all CFG implied in a computation |
| ►CCFGInfo | This allows storing all CFG available in a workspace |
| CIter | |
| CCFGNormalizer | This processor check and transform the CFG to make it normalized, that is, it performs the following checks and transformation: |
| CCFGProcessor | This is a specialization of the processor class dedicated to CFG processing |
| CCFGSaver | Save the CFGs of the current task to a file |
| CCodeBasicBlock | 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 |
| CConfigIter | Iterator on the configurations of a processor |
| CContextPath | This class is a stack to store call chain in the program call graph |
| ►CContextTree | |
| CBBIterator | |
| CChildrenIterator | Iterator for the children of a context tree |
| CContextTreeBuilder | This processor produces context tree information |
| CContextTreeByCFGBuilder | Build a context tree for each CFG involved in the current computation |
| ►CContextualLoopBound | 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 |
| Cdata_t | |
| ►CContextualPath | |
| CRef | |
| CContextualProcessor | A contextual processor allows to process basic block in a call-aware way even with a virtual CFG (where called CFG are inlined) |
| ►CContextualProperty | A contextual property is a special property that allows to retrieve a property value by its contextual path (ContextualPath) |
| CNode | |
| CContextualStep | |
| CDeadCodeAnalysis | This analyzer add the NEVER_TAKEN identifer on edges which are never taken |
| CDecodingException | This exception is thrown by a loader to inform about problems during decoding |
| Cdefault_handler_t | |
| CDelayedBuilder | 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 |
| CDelayedInfo | Provide information on delayed branches |
| CDeletableProperty | A deletable property is a genericproperty whose value will be deleted when the property is destroyed |
| CDominance | This CFG processor computes and hook to the CFG the dominance relation that, then, may be tested with Dominance::dominate() function |
| CDuplicateIdentifierException | This exception is thrown when two identifier with the same name are declared |
| CDynFeature | This class is used to resolve feature found in plugins using ProcessorPlugin::getFeature() method |
| CDynIdentifier | An identifier dynamically resolved |
| CDynProcessor | This pseudo-processor allows to call processor based on their name |
| CEdge | This class represents edges in the CFG representation |
| CEdgeACSBuilder | This processor builds the MUST and PERS cache states before each basic block |
| CEdgeCAT2Builder | This processor produces categorization information for each l-block |
| CEdgeCAT2ConstraintBuilder | This processor produces constraints, using the categorization of the lblocks |
| CEdgeProcessor | Abstract processor providing simple traversal of edges of the CFG |
| CEndBasicBlock | |
| CException | Base class of Otawa exceptions |
| ►CExeGraph | An execution graph that expresses precedence constraints on the execution of a sequence of instructions in a pipelined processor |
| CExeEdge | |
| ►CExeNode | |
| CContenderIterator | |
| CFunctionalUnitIterator | |
| CFunctionalUnitPipelineIterator | |
| CInstIterator | |
| CInstNodeIterator | |
| CPipelineIterator | |
| CPredecessor | |
| CPreorderIterator | |
| Crename_table_t | |
| CStageNodeIterator | |
| CSuccessor | |
| CExeGraphBBTime | |
| ►CExeInst | An instruction represented in an ExeGraph |
| CNodeIterator | Iterator on the list of nodes related to the instruction |
| ►CExeSequence | A sequence of instructions (ExeInst) |
| CInstIterator | Iterator on the list of instructions of the sequence |
| CExpNode | |
| CFeature | A feature is a set of facilities, usually provided using properties, available on a framework |
| ►CFeatureDependency | A feature dependency represents the dependencies used to implement a feature and is a node of the dependency graph |
| CDependent | |
| CFeatureIter | Iterator on the features used by the processor |
| CFeatureNotFound | |
| CFeatureRequirer | This class provided feature requirement for non-program processor classes |
| CFeatureUsage | |
| ►CFile | This class represents a file involved in the building of a process |
| CSegIter | |
| CSymIter | |
| CFirstLastBuilder | |
| CFixedTextDecoder | Decode the text instruction for a simple RISC architecture, requiring fixed size and fixed alignement instructions |
| CFlowFactLoader | This class is an abstract class to monitor the load of flow facts |
| ►CForwardCFGAdapter | Adapter of CFG to the concept of otawa::concept::DiGraphWithIndexedVertex |
| CIterator | |
| CPredecessor | |
| CSuccessor | |
| CFunAccessor | |
| CFunProcessor | This is a specialization of the processor class dedicated to function processing |
| CGenericProperty | This generic class allows attaching any type of data to a property |
| ►CGenGraph | |
| CGenEdge | |
| CGenNode | |
| CInIterator | |
| CIterator | |
| COutIterator | |
| CGive | |
| CGraphBBTime | This basic block processor computes the basic block execution time using the execution graph method described in the following papers: |
| ►CIdentifier | This class represents identifier with a typed associated value |
| C__class | |
| C__simple | |
| CGetter | |
| CImmutableRef | |
| CInst | This class represents assembly instruction of a piece of code |
| CLabelAddress | A label address formed by a label and a possible signed offset |
| CLBlock | 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 |
| CLBlockBuilder | This processor builds the list of l-blocks for each lines of instruction cache and stores it in the CFG |
| CLBlockManager | |
| CLBlockProcessor | This is a specialization of the processor class dedicated to LBlock |
| ►CLBlockSet | This class represents the list of l-blocks of a task for a chosen cache row |
| CIterator | |
| CLevel | |
| CLiExeGraph | |
| ►CLiExeGraphBBTime | |
| CInstIterator | |
| CSeqIterator | |
| CLiExeNode | |
| CLinkedBlocksDetector | |
| CLoader | This interface is implemented by all objects that may build and provide a process |
| CLoadException | Exception thrown when a loader encounters an error during load |
| CLockedProperty | This class is used for building a lock property, that is, for taking pointer values implementing the elm::Locked class |
| CLogOption | Defines a command line option supporting log level thanks to strings 'proc', 'cfg' or 'bb' |
| CLoopReductor | |
| CLoopUnroller | This processor unrolls the first iteration of each loop |
| CMaker | Template to make a processor from its class passed as template parameter |
| CManager | The manager class providesfacilities for storing, grouping and retrieving shared resources like loaders and platforms |
| ►CMAYBranch | |
| CDomain | |
| ►CMAYProblem | |
| CDomain | |
| CMemArea | Utility class representing an area in the memory defined by a base address and a size |
| ►CMemBlockMap | This class is used to retrieve quickly blocks from their containing address |
| Cnode_t | |
| CMetaRegistration | |
| ►CMicroprocessor | |
| CPipelineIterator | |
| CQueueIterator | |
| CMonitor | This class provide a unified interface to interact with external user |
| ►CMUSTBranch | |
| CDomain | |
| ►CMUSTPERS | |
| CDomain | |
| ►CMUSTProblem | |
| CDomain | |
| CNodeLatency | |
| CNoProcessor | A processor whise execution cause an exception throw |
| CNoProcessorException | |
| CNoType | Null value for types |
| CNullProcessor | A simple processor that does nothing |
| CNullRegistration | |
| CNullStream | |
| COutOfSegmentException | 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 |
| ►CParamExeGraph | |
| CExternalConflictIterator | |
| CExternalConflictResource | |
| CFuResource | |
| Cinput_t | |
| CInternalConflictIterator | |
| CInternalConflictResource | |
| CQueueResource | |
| ►CRegResource | |
| CUsingInstIterator | |
| CResource | |
| CResourceIterator | |
| CStageResource | |
| CStartResource | |
| ►CParamExeGraphBBTime | |
| CInstIterator | |
| CParamExeNode | |
| CParamFeature | A parametric feature is a feature that may be instantiated according to some parameters passed in a property list |
| CParamIdentifier | Implementation of AbstractParamIdentifier for an Identifier |
| ►CParamProcessor | A parametric processor allows to generate processor for parametric feature |
| CAbstractMaker | |
| CMaker | |
| CParExeEdge | An edge in a ParExeGraph |
| CParExeException | Exception thrown if there is an error during the build and the computation of |
| ►CParExeGraph | Representation of a parametric execution graph (Parametric Execution Graph) |
| CInstIterator | |
| CInstNodeIterator | |
| CPredecessor | |
| CPreorderIterator | |
| Crename_table_t | |
| CStageIterator | |
| CStageNodeIterator | |
| CSuccessor | |
| ►CParExeInst | Instruction as presented in the ParExeGraph |
| CNodeIterator | |
| CProducingInstIterator | |
| CParExeNode | A node of the ParExeGraph, that represents the crossing of an instruction inside a microprocessor stage |
| ►CParExePipeline | Representation of a pipeline (list of stages) |
| CStageIterator | |
| ►CParExeProc | Représentation of a processor (to be used to build a ParExeGraph) |
| CQueueIterator | Iterator for the instruction queues |
| CParExeQueue | Representation of a hardware instruction queue to be used to build a ParExeGraph |
| ►CParExeSequence | A sequence of ParExeInstruction for which a ParExeGraph will be built |
| CInstIterator | |
| ►CParExeStage | Representation of a pipeline stage to be used to build a ParExeGraph |
| CNodeIterator | Iterator for the graph nodes related to the pipeline stage |
| ►CPathContext | |
| CBasicBlockIterator | |
| ►CPCG | |
| CPCGIterator | |
| ►CPCGBlock | |
| CPCGBlockInIterator | |
| CPCGBlockOutIterator | |
| ►CPCGBuilder | |
| Cstack_t | |
| ►CPERSBranch | |
| CDomain | |
| CItem | |
| ►CPERSProblem | Problem for computing the PERS ACS of L-blocks |
| CDomain | |
| CItem | |
| CPFGBuilder | |
| ►CPipelineStage | |
| CExeNodeIterator | |
| ►CFunctionalUnit | |
| Cfu_info_t | |
| CPipelineIterator | |
| Cpipeline_info_t | |
| CPostDominance | This CFG processor computes and hook to the CFG the postdominance relation that, tehn, may be tested with PostDominance::postDominate() function |
| ►CProcess | A process is the realization of a program on a platform |
| CFileIter | |
| CProcessException | An exception generated from a process |
| ►CProcessor | The processor class is implemented by all code processor |
| CDeletor | |
| CRemover | |
| CProcessorException | This class is used for returning exceptions from the processors |
| CProcessorNotFound | This exception is thrown when a code processor can not be found |
| CProcessorPlugin | This class must implemented by plugins containing processor, features and identifiers |
| CProgItem | Base class of the components of a program file segment |
| CProgress | This class is an interface to get progress information about execution of a processor |
| CProperty | A property associates a data with an identifier |
| ►CPropList | This a list of properties |
| CGetter | This class is used for accessing all properties of property list with a given identifier |
| CIter | This iterator is used for reading all properties of a property list |
| CPSTBuilder | This processor computes the Program Structure Tree of the CFG |
| CQueue | |
| CQueueResource | |
| CRef | |
| CRegistration | |
| ►CRegistry | Class dedicated to the registering of the processors |
| CIter | |
| CRegIter | |
| ►CRegResource | |
| CUsingInstIterator | |
| ►CResource | |
| Cinput_t | |
| ►CResourceList | |
| CResourceIterator | |
| ►CSegment | In usual file format like ELF, COFF and so on, the program file is divided in segment according platform needs or memory propertes |
| CItemIter | |
| ►CSESERegion | |
| CBBIterator | |
| ►CSilentFeature | 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) |
| CMaker | |
| CSimState | |
| CSPAddress | Subclass of AccessedAddress, this class represents address with a constant offset relative to the stack pointer |
| CSpanningTreeBuilder | |
| CStackAnalysis | This analyzer computes accessed addresses |
| CStageResource | |
| CStartResource | |
| ►CStatCollector | A statistics collector allows to access statistics produced by an analysis |
| CCollector | This interface class must be implemented by any program that wants to collect statistics for the current statistics information |
| ►CStatInfo | Aggregator of statistics put on the workspace |
| CIter | |
| CSubCFGBuilder | Build a sub-CFG starting at the given otawa::START address and ending at the multiple otawa::STOP addresses |
| CSymAddress | Abstraction of a program address that may be expressed using several ways: absolute address, label + offset, source file:line, etc |
| CSymbol | A symbol is a name of a location in a program |
| CTextDecoder | A default text decoder: try to find the most adapted text decoder |
| ►CTimingContext | |
| CNodeLatencyIterator | |
| CTrace | |
| CTrivialBBLBlockTime | |
| CType | This class describes the type of the data in the program |
| CUnavailableFeatureException | This exception is thrown when an feature can not be computed |
| CUnsupportedFeatureException | This class is used to throw an exception when a process does not support an invoked feature |
| CVarTextDecoder | This text decoder may be used for most processor with fixed or variable length instructions |
| CVirtualBasicBlock | |
| CVirtualCFG | 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 |
| CVirtualizer | This processor inlines the function calls |
| CWorkSpace | A workspace represents a program, its run-time and all information about WCET computation or any other analysis |
| CXSLTScript | This class provides a simple way to implement OTAWA script |
| CBitSetManager | |
| 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 |
1.8.7