CFG (Control Flow Graph)

This module allows to represents program as a Control Flow Graph (CFG). More...

Classes
class	otawa::BasicBlock::Bundle
	A bundle, in a VLIW processors, is a group of instructions executed in parallel. More...
class	otawa::BasicBlock::BundleIter
	Iterator on bundles composing a basic block. More...
class	otawa::CFG
	Control Flow Graph representation. More...
class	otawa::CFGBuilder
	This processor is used for building the CFG from the binary program representation. More...
class	otawa::CFGChecker
	The analysis does not produce anything but simply check some properties on the involved CFG: More...
class	otawa::CFGCheckSummer
	Add to each involved CFG a checksum build on the instruction of the CFG. More...
class	otawa::CFGCollection
	Contains a collection of CFGs (used with INVOLVED_CFGS property). More...
class	otawa::CFGCollector
	This processor is used to collect all CFG implied in a computation. More...
class	otawa::DelayedBuilder
	This processor handle the delayed branch information provided by otawa::DELAYED_FEATURE to transform the CFG to let other processor ignore the delayed branch effects. More...
class	otawa::CFGSaver
	Save the CFGs of the current task to a file. More...
class	otawa::LoopReductor
class	otawa::LoopUnroller
	This processor unrolls the first iteration of each loop. More...
class	otawa::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. More...
class	otawa::CFGInfo
	This allows storing all CFG available in a workspace. More...

Functions
Identifier< CFG * >	otawa::ENTRY ("otawa::ENTRY", 0)
	Identifier used for storing and retrieving the CFG on its entry BB. More...
Identifier< int >	otawa::INDEX ("otawa::INDEX",-1)
	Identifier used for storing in each basic block from the CFG its index. More...
p::feature	otawa::CFG_INFO_FEATURE ("otawa::CFG_INFO_FEATURE", new Maker< CFGBuilder >())
	Feature asserting that the CFG has been scanned in the program. More...
SilentFeature	otawa::CHECKED_CFG_FEATURE ("otawa::CHECKED_CFG_FEATURE", maker)
	This feature ensures that. More...
SilentFeature	otawa::CFG_CHECKSUM_FEATURE ("otawa::CFG_CHECKSUM_FEATURE", maker)
	This feature ensures that each CFG has hooked a checksum allowing to check binary modifications between launch of an OTAWA application. More...
Identifier< unsigned long >	otawa::CHECKSUM ("otawa::CHECKSUM", 0)
	This property hooked on a CFG provides a checksum build on the instruction of the CFG. More...
Identifier< const CFGCollection * >	otawa::INVOLVED_CFGS ("otawa::INVOLVED_CFGS", 0)
	This property is used to link the current computation involved CFG on the framework. More...
Identifier< Edge * >	otawa::CALLED_BY ("otawa::CALLED_BY", 0)
	This properties are put on a CFG to get the list of edges calling it. More...
SilentFeature	otawa::COLLECTED_CFG_FEATURE ("otawa::COLLECTED_CFG_FEATURE", COLLECTED_CFG_MAKER)
	This feature asserts that all CFG involved in the current computation has been collected and accessible thanks to INVOLVED_CFGS property. More...
SilentFeature	otawa::DELAYED_CFG_FEATURE ("otawa::DELAYED_CFG_FEATURE", maker)
	This feature informs that the current microprocessor supports delayed branches and that the CFG has been changed to reflect effect of delay branches. More...
Identifier< bool >	otawa::DELAYED_INST ("otawa::DELAYED_INST", false)
	This property is set on instruction of a delayed branch. More...
Identifier< bool >	otawa::DELAYED_NOP ("otawa::DELAYED_NOP", false)
	This property is true on NOP instructions insserted due to branch delay. More...
Identifier< sys::Path >	otawa::CFG_IO_PATH ("otawa::CFG_IO_PATH")
	This property allows to configure the file used by CFGLoader and CFGSaver. More...
SilentFeature	otawa::UNROLLED_LOOPS_FEATURE ("otawa::UNROLLED_LOOPS_FEATURE", UNROLLED_LOOPS_MAKER)
	This feature that the loops have been unrolled at least once. More...
Identifier< BasicBlock * >	otawa::UNROLLED_FROM ("otawa::UNROLLED_FROM", 0)
	Put on the header ex-header of a loop, this property gives the BB of the unrolled loop. More...
SilentFeature	otawa::PFG_FEATURE ("otawa::PFG_FEATURE", pfg::maker)
	Feature providing the PFG of the application. More...
Identifier< pfg::PFG * >	otawa::PFG ("otawa::PFG", 0)
	PFG of the program. More...
Identifier< pfg::BB * >	otawa::PFG_BB ("otawa::PFG_BB", 0)
	Link of pfg::BB on an in instruction. More...
Identifier< CFGInfo * >	otawa::CFG_INFO ("otawa::CFG_INFO", 0)
	Get the collection of CFG found in the program. More...
	otawa::BasicBlock::Bundle::Bundle (void)
	Simple bundle constructor. More...

Variables
Identifier< CFG * >	otawa::ENTRY
	Identifier used for storing and retrieving the CFG on its entry BB. More...
Identifier< int >	otawa::INDEX
	Identifier used for storing in each basic block from the CFG its index. More...
p::feature	otawa::CFG_INFO_FEATURE
	Feature asserting that the CFG has been scanned in the program. More...
SilentFeature	otawa::CHECKED_CFG_FEATURE
	This feature ensures that. More...
SilentFeature	otawa::CFG_CHECKSUM_FEATURE
	This feature ensures that each CFG has hooked a checksum allowing to check binary modifications between launch of an OTAWA application. More...
Identifier< unsigned long >	otawa::CHECKSUM
	This property hooked on a CFG provides a checksum build on the instruction of the CFG. More...
Identifier< const CFGCollection * >	otawa::INVOLVED_CFGS
	This property is used to link the current computation involved CFG on the framework. More...
Identifier< Edge * >	otawa::CALLED_BY
	This properties are put on a CFG to get the list of edges calling it. More...
SilentFeature	otawa::COLLECTED_CFG_FEATURE
	This feature asserts that all CFG involved in the current computation has been collected and accessible thanks to INVOLVED_CFGS property. More...
SilentFeature	otawa::DELAYED_CFG_FEATURE
	This feature informs that the current microprocessor supports delayed branches and that the CFG has been changed to reflect effect of delay branches. More...
Identifier< bool >	otawa::DELAYED_INST
	This property is set on instruction of a delayed branch. More...
Identifier< bool >	otawa::DELAYED_NOP
	This property is true on NOP instructions insserted due to branch delay. More...
Identifier< sys::Path >	otawa::CFG_IO_PATH
	This property allows to configure the file used by CFGLoader and CFGSaver. More...
SilentFeature	otawa::UNROLLED_LOOPS_FEATURE
	This feature that the loops have been unrolled at least once. More...
Identifier< BasicBlock * >	otawa::UNROLLED_FROM
	Put on the header ex-header of a loop, this property gives the BB of the unrolled loop. More...
SilentFeature	otawa::PFG_FEATURE
	Feature providing the PFG of the application. More...
Identifier< pfg::PFG * >	otawa::PFG
	PFG of the program. More...
Identifier< pfg::BB * >	otawa::PFG_BB
	Link of pfg::BB on an in instruction. More...
Identifier< CFGInfo * >	otawa::CFG_INFO
	Get the collection of CFG found in the program. More...
static Identifier< bool >	otawa::CFGChecker::NO_EXCEPTION
	In configuration of otawa::CFGChecker . More...
static Identifier< CFG * >	otawa::CFGCollector::ADDED_CFG
	This configuration property allows to add unlinked CFG to the used CFG collection. More...
static Identifier< CString >	otawa::CFGCollector::ADDED_FUNCTION
	This configuration property allows to add unlinked functions to the used CFG collection. More...
static Identifier< CFGInfo * > &	otawa::CFGInfo::ID = CFG_INFO
	This property allows to get the CFG information from the current CFG is member of. More...

Detailed Description

This module allows to represents program as a Control Flow Graph (CFG).

The CFG is graph representation of the execution path of the program where nodes, BasicBlock, represents blocks of sequential instructions and edges, Edge, the control flow transitions between blocks.

Using the CFG

Most analyses only read the CFG structure and either use the properties of the CFG, or creates new properties. They only need to understand the structure of the CFG.

Most classes, features and identifier are accessible in the header file:

#include <otawa/cfg/features.h>

A CFG is made mainly of 3 classes:

• CFG – the CFG itself providing entry and exit virtual nodes and the list of BB,
• BasicBlock – a BB in the CFG with an address, a size, list of input edges and list of output edges,
• Edge – an edge in the CFG linking a source BB with a target BB.

These classes are subclasses of PropList and therefore support properties.

To visit a CFG, one has to start from either the entry, or the exit BB (that are not virtual blocks and does not match any code in the program) and follows the edges (be aware that a CFG may contain loops !). To get the outputting edges of a BB, the following code based on the iterator BasicBlock::OutIterator may apply:

for(BasicBlock::OutIterator edge(bb); edge; edge++)
                process(edge);

Another way to work CFG is to make the analysis class to inherit from one of the following standard processors:

• CFGProcessor – call method CFGProcessor::processCFG() for each CFG in the task,
• BBProcessor – call method BBProcessor::processBB() for each BB of the CFGs of the task,
• EdgeProcessor – call method EdgeProcessor::processEdge() for each edge of the CFGs of the task.

They will avoid the hassle work of traversing the different CFGs of the task and BB and edges inside the CFGs.

As an example, the following analysis outputs the CFG and disassemble the instructions in the BB.

class Disassembler: public BBProcessor {
protected:
        virtual void processCFG(WorkSpace *ws, CFG *cfg) {
                cout << "CFG " << cfg->label() << io::endl;
                BBProcessor::processCFG(ws, cfg);
        }

        virtual void processBB(WorkSpace *ws, CFG *cfg, BasicBlock *bb) {
                if(bb->isEnd())
                        return;
        cout << "\t" << bb << io::endl;
        for(BasicBlock::InstIterator inst(bb); inst; inst++)
                cout << "\t\t" << inst->address() << "\t" << *inst << io::endl;
        }
};

The traversal of the graph following edges requires the understanding of the kind of the edges:

• Edge::NONE – unused kind,
• Edge::TAKEN – represents a branch instruction that is taken (conditional or not),
• Edge::NOT_TAKEN – represents a branch instruction that is not-taken (only conditional),
• Edge::CALL – represents a sub-program (do not use the Edge::target() but Edge::calledCFG() to get the called CFG),
• Edge::VIRTUAL – one of special edges starting from the entry BB or leading to the exit BB,
• Edge::VIRTUAL_CALL – represents a sub-program call whose CFG has been inlined,
• Edge::VIRTUAL_RETURN – represents a sub-program return whose CFG has been inlined,
• Edge::EXN_CALL – represents an exception call whose CFG has been inlined,
• Edge::EXN_RETURN represents an exception return whose CFG has been inlined,

Notice that you shouldn't use the Edge::target() method for an edge of type Edge::CALL but instead the Edge::calledCFG() that gives the CFG of the called sub-program.

One may also observe that the CFG representation fully supports transformations like inlining of called sub-program or the representation of a possible exception raise. As shown in the section on the transformation of CFG, these transformations does not duplicate code or changes the original program. Only the representation is modified and aims at improving the precision in some particular cases. Whatevern the Edge::VIRTUAL_CALL, Edge::VIRTUAL_RETURN, Edge::EXN_CALL and Edge::EXN_RETURN provides more information on the transformed CFG:

• CALLED_CFG – put on virtual call and return edges, gives the original global CFG,
• RECURSIVE_LOOP – put on the edge representing the recursive call of an inlined sub-program,
• VIRTUAL_RETURN_BLOCK – put on the block performing the sub-program call, gives the basic block the sub-program returns to (useful to skip an inlined CFG).

Finally, a CFG may be called at different points in the other CFGs of the program, the properties CALLED_BY hooked to the CFG allows to get the matching calling edges:

for(Identifier<Edge *>::Getter edge(cfg, CALLED_BY); edge; edge++)
                processCaller(cfg, edge);

Building the CFGs

Once a program is loaded, OTAWA has only two information item on the structure of the program: the block of bytes representing the program and the startup address of the program. In addition, according to the option of linkage, other symbols may be available like the entry points of the functions composing the program.

From this, OTAWA must decode the instructions from these entry points and follows all execution paths until fully decoding the program. This first phase is performed the CFGBuilder analysis that produces as an output, a CFGInfo, the collection of all CFGs (one by function) of the program. This phase is relatively complex and may fail because of:

• errors in decoding the instructions (in this case, the error is signaled to the user and the execution path is aborted),
• unresolved branches (mainly because of computed branch target as found in function pointer call or in some switch compilation schemes).

For the latter case, you can help CFGBuilder by providing information on the possible branches using the properties below:

• IS_RETURN – consider the marked instruction as a return,
• NO_RETURN – mark the function as not returning,
• NO_CALL – avoid to involve in the CFGs the function whose first instruction is marked,
• IGNORE_CONTROL – ignore the control effect of the marked instruction,
• IGNORE_SEQ – only on a conditional branching instruction, ignore the sequential path,
• BRANCH_TARGET – gives the target(s) of an indirect branch instruction,
• CALL_TARGET – gives the target(s) of an indirect call instruction.

This properties are usually set by the FlowFactLoader from textual or XML files. Once may also observe that this properties allows also to change artificially the control flow according to the needs of a user. For example, one can avoid the "printf" function to be called by putting a property NO_CALL on its entry instruction.

Once the global CFGs of the program are built, the user is usually interested only in a subset of CFGS corresponding to the task the WCET is computed for. This subset is gathered by the CFGCollector analysis from one of the following properties:

• TASK_ENTRY (in the configuration properties)
• ENTRY_CFG (in the configuration properties or on the workspace)
• CFGCollector::ADDED_CFG – CFG to add to the collection,
• CFGCollection::ADD_FUNCTION – function to add to the collection.

As a result, the INVOLVED_CFGS (type CFGCollection) hooked to the workspace provides this list of functions that is used by the following analyses to perform the WCET computation. Notices that the first CFG of the collection is the entry point of the task. Remark also that the obtained CFG are a copy of the original CFG of the global decoding of the program: this means that you add as many properties to the collected CFG without impacting the CFGs of the global analysis.

Loops in the CFGs

Loops are a common shared issue when handling CFG. OTAWA provides several way to cope with loops. First two features allows to identify loops: LOOP_HEADERS_FEATURE and LOOP_INFO_FEATURE.

The LOOP_HEADERS_FEATURE allows to identify the loops in the CFG. Basically, it finds the back-edges (edges causing the looping) and, from these, the header of the loops. Each loop is defined by its header basic block that is the first basic block traversed when entering a loop. An header basic block is the header of only one loop and is a good way to identify the loop. The following properties are set:

• LOOP_HEADER – evaluates to true when the hooked basic block is a loop header,
• BACK_EDGE – evaluates to true on a back-edge (the target of the edge is the loop header).

This feature is implemented by the Dominance analysis or SpanningTreeBuilder.

If LOOP_HEADERS_FEATURE provides minimal information on a loop, LOOP_INFO_FEATURE allows to get full details sometimes for some analyses. The following properties are set:

• ENCLOSING_LOOP_HEADER – gives the header of the loop enclosing the linked BB,
• LOOP_EXIT_EDGE – on an edge, informs it is an exit edgen,
• EXIT_LIST – put on the loop header, get the list of edges exiting the loop.

As shown above, the loop handled by OTAWA supports only one entry point and header. This is a classic definition of so-called "regular" loops. Even if this is the most common loop found, some programs exhibit "irregular" loops (at least, two possible entry point). A usual way to support such a loop is to choose one entry point and to duplicate the code of the other entry points: this may be done in OTAWA using the analysis LoopReductor.

Transforming the CFG

CFGs in OTAWA are designed to be light representation of the program, that is, they support duplication with a minimal cost in term of memory footprint. This means, for example, that the precision of the computed WCET may be improved by duplicating some parts of the CFG to cope more precisely with the context of the code. Several OTAWA code processors provide such transformations.

The Virtualizer allows to inline the called function at the location they are called. Therefore, if a function is called at several locations, this allows to duplicate the BB and the edges representing the function and, instead to melt the context information, to have a context as precise as possible. Yet, such a transformation may be costly in terms of number of BB and must be used carefully. To prevent such a size explosion, you can mark a CFG as DONT_INLINE to prevent the inlining.

Unrolling loops is another way to improve precision. As many loop body have a different behavior between the first iteration and the other one (cache load, etc), it may be interesting to unroll loops once. This may be performed using the code processor LoopUnroller.

Finally, some transformations are required by a particular architecture. This is the case of instruction sets with delayed branches. Delayed branches executes the instruction following the branch instruction before performing actually the control flow change. As an outcome, the instruction following a branch is really part of the basic block the branch is contained in. This policy is different from the usual way OTAWA builds CFGs and a transformation must be done to fix the basic blocks: this is performed by DelayedBuilder.

Input / Output in XML

This modules provides two code processors allowing to perform input / output on CFG. CFGSaver save the CFG of the current task to a file while CFGLoader allows to load it back.

Both processors uses the same XML format defined below:

<?xml version="1.0" ?>
<otawa-workspace>

                <cfg id="ID" entry="ID" exit="ID">
                        <bb id="ID" address="ADDRESS"? size="INT"?/>*
                        <edge kind="KIND" source="ID" target="ID"? cfg="ID"?/>*
        </cfg>*

</otawa-workspace>

The OTAWA workspace is viewed, in the CFG representation, as a set of CFG that, in turn, is made of several basic blocks linked by edges. Each CFG and BB is identified with the attribute "id", any textual unique value, allowing to reference them.

The cfg element must reference two specific BB (using the unique "id"), an entry BB and an exit BB. The BB is defined by its address and its size (in bytes). The edges are defined by their kind, the source BB and, depending on the type, the target BB or the called CFG (Edge::CALL). The latter attribute "cfg" must give the identifier of an existing CFG.

Function Documentation

otawa::BasicBlock::Bundle::Bundle ( void  )

inlineprivate

Simple bundle constructor.

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

This properties are put on a CFG to get the list of edges calling it.

Hooks

• CFG

SilentFeature otawa::CFG_CHECKSUM_FEATURE	(	"otawa::CFG_CHECKSUM_FEATURE"	,
		maker
	)

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

Properties

• CHECKSUM

Identifier<CFGInfo *> otawa::CFG_INFO	(	"otawa::CFG_INFO"	,
		0
	)

Get the collection of CFG found in the program.

Feature

• CFG_INFO_FEATURE

Hooks

WorkSpace

p::feature otawa::CFG_INFO_FEATURE	(	"otawa::CFG_INFO_FEATURE"	,
		new Maker< CFGBuilder >	()
	)

Feature asserting that the CFG has been scanned in the program.

The result is put the CFGInfo::ID.

• CFGInfo::ID (FrameWork)

Identifier<sys::Path> otawa::CFG_IO_PATH

(

"otawa::CFG_IO_PATH"

)

This property allows to configure the file used by CFGLoader and CFGSaver.

SilentFeature otawa::CHECKED_CFG_FEATURE	(	"otawa::CHECKED_CFG_FEATURE"	,
		maker
	)

This feature ensures that.

• there exists at least one path from the entry to the exit,
• no branch is unresolved.

Default Processor

• CFGChecker

Identifier<unsigned long > otawa::CHECKSUM	(	"otawa::CHECKSUM"	,
		0
	)

This property hooked on a CFG provides a checksum build on the instruction of the CFG.

SilentFeature otawa::COLLECTED_CFG_FEATURE	(	"otawa::COLLECTED_CFG_FEATURE"	,
		COLLECTED_CFG_MAKER
	)

This feature asserts that all CFG involved in the current computation has been collected and accessible thanks to INVOLVED_CFGS property.

Properties

ENTRY_CFG (WorkSpace). INVOLVED_CFGS (WorkSpace). INDEX (CFG) CALLED_BY (CFG)

SilentFeature otawa::DELAYED_CFG_FEATURE	(	"otawa::DELAYED_CFG_FEATURE"	,
		maker
	)

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

Default Processor

• otawa::DelayedBuilder

Properties

• otawa::DELAYED_INST
• otawa::DELAYED_NOP

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

This property is set on instruction of a delayed branch.

Features

• otawa::DELAYED_CFG_FEATURE

Hooks

• otawa::Inst

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

This property is true on NOP instructions insserted due to branch delay.

Features

• otawa::DELAYED_CFG_FEATURE

Hooks

• otawa::Inst

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

Identifier used for storing and retrieving the CFG on its entry BB.

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

Identifier used for storing in each basic block from the CFG its index.

Also used for storing each CFG's index.

Hooks

• BasicBlock
• CFG

Identifier<const CFGCollection *> otawa::INVOLVED_CFGS	(	"otawa::INVOLVED_CFGS"	,
		0
	)

This property is used to link the current computation involved CFG on the framework.

Hooks

• WorkSpace

Identifier<pfg::PFG *> otawa::PFG	(	"otawa::PFG"	,
		0
	)

PFG of the program.

Default value: null

Hooks

• WorkSpace

Provider

• PFG_FEATURE

Identifier<pfg::BB *> otawa::PFG_BB	(	"otawa::PFG_BB"	,
		0
	)

Link of pfg::BB on an in instruction.

Hooks

• otawa::Inst

SilentFeature otawa::PFG_FEATURE	(	"otawa::PFG_FEATURE"	,
		pfg::maker
	)

Feature providing the PFG of the application.

default processor: PFGBuilder

Provided properties

• PFG – PFG of the application.
• PFG_BB – link of a pfg::BB on the first instruction.

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

Put on the header ex-header of a loop, this property gives the BB of the unrolled loop.

Hooks

• BasicBlock

SilentFeature otawa::UNROLLED_LOOPS_FEATURE	(	"otawa::UNROLLED_LOOPS_FEATURE"	,
		UNROLLED_LOOPS_MAKER
	)

This feature that the loops have been unrolled at least once.

Variable Documentation

Identifier< CFG * > otawa::CFGCollector::ADDED_CFG

static

This configuration property allows to add unlinked CFG to the used CFG collection.

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

Identifier< CString > otawa::CFGCollector::ADDED_FUNCTION

static

This configuration property allows to add unlinked functions to the used CFG collection.

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

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

This properties are put on a CFG to get the list of edges calling it.

Hooks

• CFG

Referenced by otawa::DelayedBuilder::cloneEdge(), otawa::DelayedBuilder::insert(), otawa::etime::EdgeTimeBuilder::processEdge(), otawa::CFGCollector::processWorkSpace(), otawa::LoopUnroller::unroll(), and otawa::Virtualizer::virtualize().

SilentFeature otawa::CFG_CHECKSUM_FEATURE("otawa::CFG_CHECKSUM_FEATURE", maker)

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

Properties

• CHECKSUM

Referenced by otawa::CFGCheckSummer::CFGCheckSummer().

Identifier<CFGInfo *> otawa::CFG_INFO("otawa::CFG_INFO", 0)

Get the collection of CFG found in the program.

Feature

• CFG_INFO_FEATURE

Hooks

WorkSpace

p::feature otawa::CFG_INFO_FEATURE("otawa::CFG_INFO_FEATURE", new Maker< CFGBuilder >())

Feature asserting that the CFG has been scanned in the program.

The result is put the CFGInfo::ID.

• CFGInfo::ID (FrameWork)

Referenced by otawa::AbsoluteAddress::cfg(), otawa::LabelAddress::cfg(), otawa::CFGBuilder::CFGBuilder(), otawa::CFGCollector::CFGCollector(), and otawa::CFGBuilder::processWorkSpace().

Identifier<sys::Path> otawa::CFG_IO_PATH("otawa::CFG_IO_PATH")

This property allows to configure the file used by CFGLoader and CFGSaver.

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

SilentFeature otawa::CHECKED_CFG_FEATURE("otawa::CHECKED_CFG_FEATURE", maker)

This feature ensures that.

• there exists at least one path from the entry to the exit,
• no branch is unresolved.

Default Processor

• CFGChecker

Referenced by otawa::ContextualProcessor::ContextualProcessor().

Identifier<unsigned long > otawa::CHECKSUM("otawa::CHECKSUM", 0)

This property hooked on a CFG provides a checksum build on the instruction of the CFG.

Referenced by otawa::CFGCheckSummer::processCFG(), and while().

SilentFeature otawa::COLLECTED_CFG_FEATURE("otawa::COLLECTED_CFG_FEATURE", COLLECTED_CFG_MAKER)

This feature asserts that all CFG involved in the current computation has been collected and accessible thanks to INVOLVED_CFGS property.

Properties

ENTRY_CFG (WorkSpace). INVOLVED_CFGS (WorkSpace). INDEX (CFG) CALLED_BY (CFG)

Referenced by otawa::CFGCollector::CFGCollector(), otawa::CFGNormalizer::CFGNormalizer(), otawa::DelayedBuilder::cleanup(), otawa::Virtualizer::cleanup(), otawa::ipet::FlowFactConstraintBuilder::FlowFactConstraintBuilder(), otawa::LoopReductor::LoopReductor(), otawa::PCGBuilder::PCGBuilder(), otawa::CFGCollector::processWorkSpace(), otawa::PSTBuilder::PSTBuilder(), and otawa::ipet::TrivialDataCacheManager::TrivialDataCacheManager().

SilentFeature otawa::DELAYED_CFG_FEATURE("otawa::DELAYED_CFG_FEATURE", maker)

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

Default Processor

• otawa::DelayedBuilder

Properties

• otawa::DELAYED_INST
• otawa::DELAYED_NOP

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

This property is set on instruction of a delayed branch.

Features

• otawa::DELAYED_CFG_FEATURE

Hooks

• otawa::Inst

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

This property is true on NOP instructions insserted due to branch delay.

Features

• otawa::DELAYED_CFG_FEATURE

Hooks

• otawa::Inst

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

Identifier used for storing and retrieving the CFG on its entry BB.

Referenced by otawa::CFGBuilder::addCFG(), otawa::DelayedBuilder::buildEdges(), otawa::Edge::calledCFG(), otawa::CFGInfo::findCFG(), otawa::LoopReductor::processWorkSpace(), otawa::CFG::scan(), otawa::LoopUnroller::unroll(), and otawa::Virtualizer::virtualizeCFG().

Identifier< CFGInfo * > & otawa::CFGInfo::ID = CFG_INFO

static

This property allows to get the CFG information from the current CFG is member of.

Hooks

• CFG

See also

CFG_INFO

Referenced by otawa::AbsoluteAddress::cfg(), otawa::LabelAddress::cfg(), otawa::WorkSpace::getCFGInfo(), otawa::CFGBuilder::processWorkSpace(), and otawa::CFGCollector::processWorkSpace().

Identifier< int > otawa::INDEX

Identifier used for storing in each basic block from the CFG its index.

Also used for storing each CFG's index.

Hooks

• BasicBlock
• CFG

Referenced by otawa::CFGCollection::add(), otawa::VirtualCFG::addBB(), otawa::dfa::XCFGVisitor< P >::index(), otawa::CFG::number(), otawa::BasicBlock::number(), otawa::CFG::numberBB(), otawa::VirtualCFG::numberBBs(), otawa::display::CFGDrawer::onInit(), otawa::ipet::FlowFactConstraintBuilder::processBB(), otawa::LoopUnroller::processWorkSpace(), otawa::LoopReductor::processWorkSpace(), otawa::LoopReductor::reduce(), otawa::VirtualCFG::removeBB(), otawa::VirtualCFG::scan(), otawa::CFG::scan(), and otawa::LoopUnroller::unroll().

Identifier<const CFGCollection *> otawa::INVOLVED_CFGS("otawa::INVOLVED_CFGS", 0)

This property is used to link the current computation involved CFG on the framework.

Hooks

• WorkSpace

Referenced by otawa::BBCleaner::clean(), otawa::CFGCollector::cleanup(), otawa::dcache::CATBuilder::cleanup(), otawa::LoopUnroller::cleanup(), otawa::DelayedBuilder::cleanup(), otawa::Virtualizer::cleanup(), otawa::BBStatCollector::collect(), otawa::dfa::hai::DefaultListener< P >::DefaultListener(), otawa::CFGProcessor::doCleanUp(), otawa::ipet::ConstraintLoader::getBB(), otawa::BBStatCollector::process(), otawa::dcache::CATBuilder::processLBlockSet(), otawa::ACSMayBuilder::processLBlockSet(), otawa::ACSBuilder::processLBlockSet(), otawa::cat::CATBuilder::processLBlockSet(), otawa::ccg::Builder::processLBlockSet(), otawa::dcache::ACSMayBuilder::processLBlockSet(), otawa::dcache::ACSBuilder::processLBlockSet(), otawa::DeadCodeAnalysis::processWorkSpace(), otawa::dcache::CatConstraintBuilder::processWorkSpace(), otawa::ACSMayBuilder::processWorkSpace(), otawa::ACSBuilder::processWorkSpace(), otawa::LoopReductor::processWorkSpace(), otawa::LoopUnroller::processWorkSpace(), otawa::StackAnalysis::processWorkSpace(), otawa::CFGCollector::processWorkSpace(), otawa::DelayedBuilder::processWorkSpace(), otawa::branch::BranchBuilder::processWorkSpace(), otawa::CFGProcessor::processWorkSpace(), otawa::Virtualizer::processWorkSpace(), otawa::clp::Analysis::processWorkSpace(), otawa::dcache::ACSMayBuilder::processWorkSpace(), otawa::dcache::ACSBuilder::processWorkSpace(), otawa::BBStatCollector::total(), otawa::dfa::hai::UnrollingListener< P >::UnrollingListener(), otawa::dfa::hai::WideningListener< P >::WideningListener(), otawa::dfa::hai::DefaultListener< P >::~DefaultListener(), otawa::dfa::hai::UnrollingListener< P >::~UnrollingListener(), and otawa::dfa::hai::WideningListener< P >::~WideningListener().

Identifier< bool > otawa::CFGChecker::NO_EXCEPTION

static

In configuration of otawa::CFGChecker .

Inform the CFG checker that it must not issue an exception when an error is found: only a warning.

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

Identifier<pfg::PFG *> otawa::PFG("otawa::PFG", 0)

PFG of the program.

Default value: null

Hooks

• WorkSpace

Provider

• PFG_FEATURE

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

Identifier<pfg::BB *> otawa::PFG_BB("otawa::PFG_BB", 0)

Link of pfg::BB on an in instruction.

Hooks

• otawa::Inst

Referenced by otawa::PFGBuilder::addFunction(), and otawa::PFGBuilder::finalizeBB().

SilentFeature otawa::PFG_FEATURE("otawa::PFG_FEATURE", pfg::maker)

Feature providing the PFG of the application.

default processor: PFGBuilder

Provided properties

• PFG – PFG of the application.
• PFG_BB – link of a pfg::BB on the first instruction.

Referenced by otawa::PFGBuilder::PFGBuilder().

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

Put on the header ex-header of a loop, this property gives the BB of the unrolled loop.

Hooks

• BasicBlock

Referenced by otawa::ipet::FlowFactConstraintBuilder::processBB(), and otawa::LoopUnroller::unroll().

SilentFeature otawa::UNROLLED_LOOPS_FEATURE("otawa::UNROLLED_LOOPS_FEATURE", UNROLLED_LOOPS_MAKER)

This feature that the loops have been unrolled at least once.