StaticProgramAnalyzer Class Reference

#include <StaticProgramAnalyzer.hh>

Collaboration diagram for StaticProgramAnalyzer:

Public Member Functions
	StaticProgramAnalyzer ()
virtual	~StaticProgramAnalyzer ()
void	addProgram (const TTAProgram::Program &program)
std::set< std::string >	operationsUsed () const
std::set< SIntWord >	integerRegisterIndexes () const
std::map< int, int >	immediateBitWidths () const
InstructionAddress	biggestAddress () const
void	resetCounters ()

Private Attributes
std::set< SIntWord >	integerVariables_
	Set of integer variables used in the applications. More...
std::set< std::string >	operations_
	Set of operations used in the applications. More...
std::map< int, int >	immediates_
	Set of immediate widths used in the applications. More...
unsigned int	biggestAddress_
	Memory used by programs. More...

Detailed Description

Analyzes sequential programs operation use, register needs and immediate widths.

Definition at line 49 of file StaticProgramAnalyzer.hh.

Constructor & Destructor Documentation

StaticProgramAnalyzer()

StaticProgramAnalyzer::StaticProgramAnalyzer

(

)

The constructor.

Definition at line 50 of file StaticProgramAnalyzer.cc.

                                            :
    biggestAddress_(0) {
}

~StaticProgramAnalyzer()

StaticProgramAnalyzer::~StaticProgramAnalyzer ( )

virtual

The destructor.

Definition at line 57 of file StaticProgramAnalyzer.cc.

                                              {
}

Member Function Documentation

addProgram()

void StaticProgramAnalyzer::addProgram

(

const TTAProgram::Program &

program

)

Adds a new program to the analyzer and analyzes it. Results are added to the previously analyzed results.

Parameters

program

Sequential program to be analyzed.

Definition at line 67 of file StaticProgramAnalyzer.cc.

                                                                  {
 
    Instruction* instruction = &program.firstInstruction();
    Instruction* lastInstruction = &program.lastInstruction();
    while (instruction != lastInstruction) {
        for (int i = 0; i < instruction->moveCount(); i++) {
            Move& move = instruction->move(i);
            Terminal* source = &move.source();
            Terminal* destination = &move.destination();
            if (source->isGPR()) {
                integerVariables_.insert(source->index());
            } else if (source->isImmediate()) {
                immediates_[MathTools::requiredBits(
                        source->value().unsignedValue())] += 1;
            }
            if (destination->isFUPort()) {
                if (destination->isOpcodeSetting()) {
                    operations_.insert(
                        StringTools::stringToLower(
                            destination->operation().name()));
                }
            } else if (destination->isGPR()) {
                integerVariables_.insert(destination->index());
            }
            
        }
        instruction = &program.nextInstruction(*instruction);
    }
    // analyze the needed memory
    for (int i = 0; i < program.dataMemoryCount(); i++) {
        DataMemory& dataMemory = program.dataMemory(i);
        int definitionCount = dataMemory.dataDefinitionCount();
        DataDefinition& definition =
            dataMemory.dataDefinition(definitionCount - 1);
        Address address = definition.startAddress();
        InstructionAddress instructionAddress = address.location();
        instructionAddress += definition.size();
        if (biggestAddress_ < instructionAddress) {
            biggestAddress_ = instructionAddress;
        }
    }
}

References biggestAddress_, TTAProgram::DataMemory::dataDefinition(), TTAProgram::DataMemory::dataDefinitionCount(), TTAProgram::Move::destination(), immediates_, TTAProgram::Terminal::index(), integerVariables_, TTAProgram::Terminal::isFUPort(), TTAProgram::Terminal::isGPR(), TTAProgram::Terminal::isImmediate(), TTAProgram::Terminal::isOpcodeSetting(), TTAProgram::Address::location(), TTAProgram::Instruction::move(), TTAProgram::Instruction::moveCount(), Operation::name(), TTAProgram::Terminal::operation(), operations_, program, MathTools::requiredBits(), TTAProgram::DataDefinition::size(), TTAProgram::Move::source(), TTAProgram::DataDefinition::startAddress(), StringTools::stringToLower(), SimValue::unsignedValue(), and TTAProgram::Terminal::value().

Here is the call graph for this function:

biggestAddress()

InstructionAddress StaticProgramAnalyzer::biggestAddress

(

)

const

Returns the biggest instruction address used in the analyzed programs.

Returns

The biggest instruction address.

Definition at line 148 of file StaticProgramAnalyzer.cc.

                                            {
    return biggestAddress_;
}

References biggestAddress_.

immediateBitWidths()

std::map< int, int > StaticProgramAnalyzer::immediateBitWidths

(

)

const

Returns set of immediate bit widths used in the analyzed programs.

Returns

Set of immediate bit widths used in the analyzed programs.

Definition at line 138 of file StaticProgramAnalyzer.cc.

                                                {
    return immediates_;
}

References immediates_.

integerRegisterIndexes()

std::set< SIntWord > StaticProgramAnalyzer::integerRegisterIndexes

(

)

const

Returns set of register indexes used in the analyzed programs.

Returns

Set of register indexes used in the analyzed programs.

Definition at line 128 of file StaticProgramAnalyzer.cc.

                                                    {
    return integerVariables_;
}

References integerVariables_.

operationsUsed()

std::set< std::string > StaticProgramAnalyzer::operationsUsed

(

)

const

Returns set of operations used in the analyzed programs.

Operation names in the se are in lower case.

Returns

Set of operations used in the analyzed programs.

Definition at line 118 of file StaticProgramAnalyzer.cc.

                                            {
    return operations_;
}

References operations_.

resetCounters()

void StaticProgramAnalyzer::resetCounters

(

)

Resets the all counters used be the analyzer.

Definition at line 157 of file StaticProgramAnalyzer.cc.

                                     {
    operations_.clear();
    integerVariables_.clear();
}

References integerVariables_, and operations_.

Member Data Documentation

biggestAddress_

unsigned int StaticProgramAnalyzer::biggestAddress_

private

Memory used by programs.

Definition at line 69 of file StaticProgramAnalyzer.hh.

Referenced by addProgram(), and biggestAddress().

immediates_

std::map<int, int> StaticProgramAnalyzer::immediates_

private

Set of immediate widths used in the applications.

Definition at line 67 of file StaticProgramAnalyzer.hh.

Referenced by addProgram(), and immediateBitWidths().

integerVariables_

std::set<SIntWord> StaticProgramAnalyzer::integerVariables_

private

Set of integer variables used in the applications.

Definition at line 63 of file StaticProgramAnalyzer.hh.

Referenced by addProgram(), integerRegisterIndexes(), and resetCounters().

operations_

std::set<std::string> StaticProgramAnalyzer::operations_

private

Set of operations used in the applications.

Definition at line 65 of file StaticProgramAnalyzer.hh.

Referenced by addProgram(), operationsUsed(), and resetCounters().

---

The documentation for this class was generated from the following files:

• StaticProgramAnalyzer.hh
• StaticProgramAnalyzer.cc