POMDisassembler Class Reference

#include <POMDisassembler.hh>

Collaboration diagram for POMDisassembler:

Public Member Functions
	POMDisassembler (bool indices=false)
	POMDisassembler (const TTAProgram::Program &program, bool indices=false)
virtual	~POMDisassembler ()
virtual DisassemblyInstruction *	createInstruction (Word instructionIndex) const
virtual Word	startAddress () const
virtual Word	instructionCount () const
int	labelCount (Word address) const
std::string	label (Word address, int index) const
virtual TCEString	disassembleInstruction (const TTAProgram::Instruction &instruction, int addr=-1)
	"Template methods" that can be overridden in the derived assemblers.
virtual TCEString	disassembleProcedure (const TTAProgram::Procedure &proc)
virtual TCEString	disassembleProcedures ()
virtual TCEString	disassembleProgram ()
virtual TCEString	codeSectionDescription (Word startAddress)
virtual TCEString	dataSectionDescription (const TTAMachine::AddressSpace &aSpace, Word location)
virtual TCEString	procedureDescription (const TTAProgram::Procedure &proc)
virtual TCEString	destinationLabels (const TTAProgram::Procedure &proc, int instrIndex) const
virtual TCEString	labelPositionDescription (TCEString labelStr) const
virtual TCEString	dataDefDescription (const TTAProgram::DataDefinition &def)
virtual size_t	instructionSize (const TTAProgram::Instruction &)
	Returns the size of the instruction in memory addresses, if known. Falls back to address per instruction.
virtual void	setPrintAddresses (bool addresses)
virtual TCEString	printAddress (const TTAProgram::Instruction &instr) const

Static Public Member Functions
static POMDisassembler *	disassembler (const TTAMachine::Machine &mach, const TTAProgram::Program &program)
static std::string	disassemble (const TTAProgram::Move &move)
static std::string	disassemble (const TTAProgram::Instruction &instruction, bool indices=false, int addr=-1)
static std::string	disassemble (const TTAProgram::Procedure &proc, bool indices=false)
static std::string	disassemble (const TTAProgram::Program &program, bool indices=false)
static TCEString	disassembleFully (const TTAProgram::Program &program, bool indices=false)
static DisassemblyImmediate *	createInlineImmediate (const TTAProgram::Terminal &terminal, bool signExtend)

Protected Attributes
const TTAProgram::Program &	program_
	Program object model to disassemble.
bool	printAddresses_
	True if instruction indices (addresses) should be printed at the end of lines.

Static Private Member Functions
static int	labelCount (const TTAProgram::Program &program, Word address)
static std::string	label (const TTAProgram::Program &, Word address, int index)
static DisassemblyInstruction *	createInstruction (const TTAProgram::Program &program, const TTAProgram::Instruction &instruction)
static DisassemblyMove *	createMove (const TTAProgram::Move &move)
static DisassemblyImmediateAssignment *	createImmediateAssignment (const TTAProgram::Immediate &immediate)
static DisassemblyGuard *	createGuard (const TTAProgram::MoveGuard &guard)
static DisassemblyElement *	createTerminal (const TTAProgram::Terminal &terminal)
static DisassemblyElement *	createFUPort (const TTAProgram::Terminal &terminal)
static DisassemblyElement *	createRegister (const TTAProgram::Terminal &terminal)
static DisassemblyImmediateRegister *	createImmediateRegister (const TTAProgram::Terminal &terminal)
static bool	isCallOrJump (const TTAProgram::Terminal &terminal)

Detailed Description

Program object model disassembler.

Definition at line 70 of file POMDisassembler.hh.

Constructor & Destructor Documentation

POMDisassembler() [1/2]

POMDisassembler::POMDisassembler ( bool  printAddresses = false )

explicit

A constructor for disassembling pieces of a program which might not be attached to a Program object.

Parameters

printAddresses

True in case instruction addresses should be printed at the end of instruction lines as comments.

Definition at line 115 of file POMDisassembler.cc.

                                                    :
    program_(NullProgram::instance()), printAddresses_(printAddresses) {
}

POMDisassembler() [2/2]

POMDisassembler::POMDisassembler ( const TTAProgram::Program &  program, bool  printAddresses = false  )

explicit

A constructor for disassembling whole programs.

Parameters

program	Program to disassemble.
printAddresses	True in case instruction addresses should be printed at the end of instruction lines as comments.

Definition at line 104 of file POMDisassembler.cc.

                                                                            :
    program_(program), printAddresses_(printAddresses) {
}

~POMDisassembler()

POMDisassembler::~POMDisassembler ( )

virtual

The destructor.

Definition at line 123 of file POMDisassembler.cc.

                                  {
}

Member Function Documentation

codeSectionDescription()

TCEString POMDisassembler::codeSectionDescription ( Word  startAddress )

virtual

Definition at line 917 of file POMDisassembler.cc.

                                                         {
    TCEString output;
    output << "CODE " << startAddress << " ;";
    return output;
}

References startAddress().

Referenced by disassembleProgram().

Here is the call graph for this function:

createFUPort()

DisassemblyElement * POMDisassembler::createFUPort ( const TTAProgram::Terminal &  terminal )

staticprivate

Creates disassembly of a function unit port.

Parameters

terminal

Function unit terminal to disassemble.

Returns

Disassembly of the function unit terminal.

Definition at line 320 of file POMDisassembler.cc.

                                                      {
    const FunctionUnit* fu = &terminal.functionUnit();
 
    const TTAProgram::TerminalFUPort& fuTerm =
        dynamic_cast<const TerminalFUPort&>(terminal);
 
    if (dynamic_cast<const UniversalFunctionUnit*>(fu) != NULL ||
        (fu->machine()->isUniversalMachine() &&
         dynamic_cast<const ControlUnit*>(fu) != NULL)) {
 
        // The terminal is a UniversalFunctionUnit operation or
        // a universal machine control unit operation.
        if (&fuTerm.hintOperation() != &NullOperation::instance()) {
            string operation = fuTerm.hintOperation().name();
            HWOperation* hwOperation = fu->operation(operation);
            FUPort* port = fu->operationPort(fuTerm.port().name());
            int operand = hwOperation->io(*port);
            return new DisassemblyOperand(
                fuTerm.hintOperation().name(), operand);
        }
        return new DisassemblyControlUnitPort(fuTerm.port().name());
    }
 
    // if terminal contains any information about operation
    if (fuTerm.isOpcodeSetting()) {
        // check if that osal operation was found
        if (&fuTerm.operation() == &NullOperation::instance()) {
            throw InstanceNotFound(__FILE__, __LINE__, __func__,
            (boost::format(
                "Osal operation for operation code name '%s' was not found.") 
             % fuTerm.hwOperation()->name()).str());
        }
        // The terminal is an opcode setting port of an operation or.
        // has additional info about opcode that terminal is bound.
        return new DisassemblyFUOpcodePort(
            fu->name(), fuTerm.port().name(), fuTerm.operation().name());
    }
 
    // The terminal is a generic function unit port.
    return new DisassemblyFUPort(fu->name(), terminal.port().name());
}

References __func__, TTAProgram::Terminal::functionUnit(), TTAProgram::TerminalFUPort::hintOperation(), TTAProgram::TerminalFUPort::hwOperation(), NullOperation::instance(), TTAMachine::HWOperation::io(), TTAProgram::TerminalFUPort::isOpcodeSetting(), TTAMachine::Machine::isUniversalMachine(), TTAMachine::Component::machine(), TTAMachine::HWOperation::name(), TTAMachine::Component::name(), TTAMachine::Port::name(), Operation::name(), TTAProgram::TerminalFUPort::operation(), TTAMachine::FunctionUnit::operation(), TTAMachine::FunctionUnit::operationPort(), TTAProgram::Terminal::port(), and TTAProgram::TerminalFUPort::port().

Referenced by createTerminal().

Here is the call graph for this function:

createGuard()

DisassemblyGuard * POMDisassembler::createGuard ( const TTAProgram::MoveGuard &  guard )

staticprivate

Creates disassembly of a move guard.

Parameters

guard

Move guard to disassemble.

Returns

Disassembly of the move guard.

Definition at line 434 of file POMDisassembler.cc.

                                                       {
 
    const Guard* guard = &moveGuard.guard();
 
    DisassemblyElement* guarded = NULL;
 
    // Check if the guarded element is a fu port.
    const PortGuard* portGuard = dynamic_cast<const PortGuard*>(guard);
    if (portGuard != NULL) {
        string fuName = portGuard->port()->parentUnit()->name();
        string portName = portGuard->port()->name();
        guarded = new DisassemblyFUPort(fuName, portName);
    }
 
    // Check if the guarded element is a register.
    const RegisterGuard* registerGuard =
        dynamic_cast<const RegisterGuard*>(guard);
    if (registerGuard != NULL) {
 
        // Check if the register file is bool rf of a universal machine.
        const RegisterFile* rf = registerGuard->registerFile();
        const UniversalMachine* machine =
            dynamic_cast<const UniversalMachine*>(rf->machine());
 
        if (machine != NULL && rf == &machine->booleanRegisterFile()) {
            return new DisassemblySequentialGuard(moveGuard.isInverted());
        } else {
            string rfName = registerGuard->registerFile()->name();
            int index = registerGuard->registerIndex();
            guarded = new DisassemblyRegister(rfName, index);
        }
    }
 
    // Check if the guard is unconditional.
    if (moveGuard.isUnconditional()) {
        // TODO: Disassemble unconditional guards.
        assert(false);
    }
 
 
    return new DisassemblyGuard(guarded, moveGuard.isInverted());
}

References assert, TTAProgram::MoveGuard::guard(), TTAProgram::MoveGuard::isInverted(), TTAProgram::MoveGuard::isUnconditional(), TTAMachine::Component::machine(), machine, TTAMachine::Component::name(), TTAMachine::Port::name(), TTAMachine::BaseFUPort::parentUnit(), TTAMachine::PortGuard::port(), TTAMachine::RegisterGuard::registerFile(), and TTAMachine::RegisterGuard::registerIndex().

Referenced by createMove().

Here is the call graph for this function:

createImmediateAssignment()

DisassemblyImmediateAssignment * POMDisassembler::createImmediateAssignment ( const TTAProgram::Immediate &  immediate )

staticprivate

Creates disassembly of an immediate assignment.

Definition at line 246 of file POMDisassembler.cc.

                                                                     {
    DisassemblyElement* destination = createTerminal(immediate.destination());
    SimValue value = immediate.value().value();
    bool signExt = immediate.destination().immediateUnit().signExtends();
    return new DisassemblyImmediateAssignment(value, signExt, destination);
}

References createTerminal(), TTAProgram::Immediate::destination(), TTAProgram::Terminal::immediateUnit(), TTAMachine::ImmediateUnit::signExtends(), TTAProgram::Immediate::value(), and TTAProgram::TerminalImmediate::value().

Referenced by createInstruction(), and disassemble().

Here is the call graph for this function:

createImmediateRegister()

DisassemblyImmediateRegister * POMDisassembler::createImmediateRegister ( const TTAProgram::Terminal &  terminal )

staticprivate

Creates disassembly of an immediate register.

Parameters

terminal

Immediate register to disassemble.

Returns

Disassembly of the immediate register.

Definition at line 420 of file POMDisassembler.cc.

                                                                 {
    string immediateUnit = terminal.immediateUnit().name();
    unsigned int index = terminal.index();
    return new DisassemblyImmediateRegister(immediateUnit, index);
}

References TTAProgram::Terminal::immediateUnit(), TTAProgram::Terminal::index(), and TTAMachine::Component::name().

Referenced by createTerminal().

Here is the call graph for this function:

createInlineImmediate()

DisassemblyImmediate * POMDisassembler::createInlineImmediate ( const TTAProgram::Terminal &  terminal, bool  signExtend  )

static

Creates disassembly of an immediate value.

Parameters

terminal	Immediate value to disassemble.
signExtend	If the immediate should be considered signed or unsigned.

Returns

Disassembly of the immediate value.

Definition at line 296 of file POMDisassembler.cc.

                                               {
    if (const TTAProgram::TerminalProgramOperation* tpo =
        dynamic_cast<const TTAProgram::TerminalProgramOperation*>(&terminal)) {
        if (!tpo->isAddressKnown())
            return new DisassemblyImmediate(NullSimValue::instance(), false);
    }
    try {
        return new DisassemblyImmediate(
            terminal.value(), signExtend);
    } catch (Exception& e) {
        return new DisassemblyImmediate(
            NullSimValue::instance(), signExtend);
    }
}

References NullSimValue::instance(), and TTAProgram::Terminal::value().

Referenced by createMove(), TTAProgram::TerminalImmediate::toString(), and TTAProgram::TerminalLaneIDImmediate::toString().

Here is the call graph for this function:

createInstruction() [1/2]

DisassemblyInstruction * POMDisassembler::createInstruction ( const TTAProgram::Program &  program, const TTAProgram::Instruction &  instruction  )

staticprivate

Returns disassembly of an instruction at the given index.

The client is responsible for destroying the instruction object.

Parameters

program	Parent program of the instruction.
index	Index of the instruction to disassemble.

Returns

Disassembly of the instruction at given index.

Definition at line 155 of file POMDisassembler.cc.

                                                            {
 
    DisassemblyInstruction* disassembly = new DisassemblyInstruction();
 
    const Machine::BusNavigator& navigator =
        program.targetProcessor().busNavigator();
 
    // The instruction disassembly is created by one bus at a time.
    for (int i = 0; i < navigator.count(); i++) {
 
        Bus* bus = navigator.item(i);
        string busName = bus->name();
        bool isUsed = false;
 
        // Check for move.
        for (int i = 0; i < instruction.moveCount(); i++) {
            if (&instruction.move(i).bus() == bus) {
                disassembly->addMove(createMove(instruction.move(i)));
                isUsed = true;
            }
        }
 
        if (!isUsed) {
            disassembly->addMove(new DisassemblyNOP);
        }
    }
 
    // Add disassembly of long immediates in immediate slots.
    for (int i = 0; i < instruction.immediateCount(); i++) {
        disassembly->addLongImmediate(
            createImmediateAssignment(instruction.immediate(i)));
    }
 
    return disassembly;
}

References DisassemblyInstruction::addLongImmediate(), DisassemblyInstruction::addMove(), TTAProgram::Move::bus(), TTAMachine::Machine::Navigator< ComponentType >::count(), createImmediateAssignment(), createMove(), TTAProgram::Instruction::immediate(), TTAProgram::Instruction::immediateCount(), TTAMachine::Machine::Navigator< ComponentType >::item(), TTAProgram::Instruction::move(), TTAProgram::Instruction::moveCount(), TTAMachine::Component::name(), and program.

Here is the call graph for this function:

createInstruction() [2/2]

DisassemblyInstruction * POMDisassembler::createInstruction ( Word  index ) const

virtual

Returns disassembly of an instruction at the given index.

The client is responsible for destroying the instruction object.

Parameters

index

Index of the instruction to disassemble.

Returns

Disassembly of the instruction at given index.

Definition at line 137 of file POMDisassembler.cc.

                                                   {
 
    const Instruction& instruction = program_.instructionAt(index);
    return createInstruction(program_, instruction);
}

References createInstruction(), TTAProgram::Program::instructionAt(), and program_.

Referenced by createInstruction(), disassemble(), and DisassemblyGridTable::GetValue().

Here is the call graph for this function:

createMove()

DisassemblyMove * POMDisassembler::createMove ( const TTAProgram::Move &  move )

staticprivate

Creates disassembly of a move.

Parameters

move	Move to disassemble.

Returns

Disassembly of the move.

Definition at line 200 of file POMDisassembler.cc.

                                            {
 
    // Disassemble move terminals.
    DisassemblyElement* destinationDis = createTerminal(move.destination());
    DisassemblyElement* sourceDis = NULL;
 
    if (move.source().isImmediate()) {
 
        // Special case: if the move source is an inline immediate, and
        // the move destination is call/jump operand, the inline immediate
        // is disassembled as label if possible.
        if (isCallOrJump(move.destination()) &&
            move.isInInstruction() && move.parent().isInProcedure() &&
            move.parent().parent().isInProgram() &&
            labelCount(
                move.parent().parent().parent(),
                move.source().value().uLongWordValue()) > 0) {
 
            LongWord immediate = move.source().value().uLongWordValue();
            std::string codelabel = label(
                move.parent().parent().parent(), immediate, 0);
            sourceDis = new DisassemblyLabel(codelabel);
        } else {
            sourceDis =
                createInlineImmediate(
                    move.source(), move.bus().signExtends());
        }
    } else {
        sourceDis = createTerminal(move.source());
    }
 
    DisassemblyMove* disassembly = NULL;
    if (!move.isUnconditional()) {
        DisassemblyGuard* guardDis = createGuard(move.guard());
        disassembly = new DisassemblyMove(sourceDis, destinationDis, guardDis);
    } else {
        disassembly = new DisassemblyMove(sourceDis, destinationDis);
    }
    return disassembly;
}

References TTAProgram::Move::bus(), createGuard(), createInlineImmediate(), createTerminal(), TTAProgram::Move::destination(), TTAProgram::Move::guard(), isCallOrJump(), TTAProgram::Terminal::isImmediate(), TTAProgram::Move::isInInstruction(), TTAProgram::Instruction::isInProcedure(), TTAProgram::CodeSnippet::isInProgram(), TTAProgram::Move::isUnconditional(), label(), labelCount(), TTAProgram::CodeSnippet::parent(), TTAProgram::Instruction::parent(), TTAProgram::Move::parent(), TTAMachine::Bus::signExtends(), TTAProgram::Move::source(), SimValue::uLongWordValue(), and TTAProgram::Terminal::value().

Referenced by createInstruction(), disassemble(), and disassemble().

Here is the call graph for this function:

createRegister()

DisassemblyElement * POMDisassembler::createRegister ( const TTAProgram::Terminal &  terminal )

staticprivate

Creates disassembly of a register.

Parameters

terminal

Register to disassemble.

Returns

Disassembly of the register.

Exceptions

WrongSubclass

The terminal was not register.

Definition at line 370 of file POMDisassembler.cc.

                                                        {
    const RegisterFile* rf = &terminal.registerFile();
 
    if (rf == NULL) {
        throw WrongSubclass(__FILE__, __LINE__, __func__,
                            "Not register terminal.");
    }
 
    const UniversalMachine* machine =
        dynamic_cast<const UniversalMachine*>(rf->machine());
 
    if (machine != NULL) {
 
        if (rf == &machine->booleanRegisterFile()) {
            // universal bool register
            return new DisassemblyBoolRegister();
        }
 
 
        // The register is a UnboundedRegisterFile register of a universal
        // machine.
        const UnboundedRegisterFile* universalRF =
            dynamic_cast<const UnboundedRegisterFile*>(rf);
 
        if (universalRF == &machine->integerRegisterFile()) {
            // universal int register
            return new DisassemblyIntRegister(terminal.index());
        }
        
        if (universalRF == &machine->doubleRegisterFile()) {
            // universal floating point register
            return new DisassemblyFPRegister(terminal.index());
        }
 
        // Unknown universal machine register type.
        throw WrongSubclass(
            __FILE__, __LINE__, __func__,
            "Unknown universal machine register type.");
    }
 
    return new DisassemblyRegister(rf->name(), terminal.index());
}

References __func__, TTAProgram::Terminal::index(), TTAMachine::Component::machine(), machine, TTAMachine::Component::name(), and TTAProgram::Terminal::registerFile().

Referenced by createTerminal().

Here is the call graph for this function:

createTerminal()

DisassemblyElement * POMDisassembler::createTerminal ( const TTAProgram::Terminal &  terminal )

staticprivate

Creates disassembly of a move terminal.

Determines the terminal type, an uses appropriate function to create disassembly of the terminal.

Parameters

terminal

Move terminal to disassemble.

Returns

Disassembly of the move terminal.

Exceptions

WrongSubclass

The terminal type was unknown.

Definition at line 265 of file POMDisassembler.cc.

                                                        {
    assert (
        !terminal.isImmediate() &&
        "Should handle immediate as a special case due to depending on "
        "extension mode!");
 
    if (terminal.isFUPort()) {
        return createFUPort(terminal);
    }
 
    if (terminal.isGPR()) {
        return createRegister(terminal);
    }
 
    if (terminal.isImmediateRegister()) {
        return createImmediateRegister(terminal);
    }
 
    // Unkown terminal type.
    throw WrongSubclass(__FILE__, __LINE__, __func__,
                        "Unknown terminal type.");
}

References __func__, assert, createFUPort(), createImmediateRegister(), createRegister(), TTAProgram::Terminal::isFUPort(), TTAProgram::Terminal::isGPR(), TTAProgram::Terminal::isImmediate(), and TTAProgram::Terminal::isImmediateRegister().

Referenced by createImmediateAssignment(), and createMove().

Here is the call graph for this function:

dataDefDescription()

TCEString POMDisassembler::dataDefDescription ( const TTAProgram::DataDefinition &  def )

virtual

Definition at line 933 of file POMDisassembler.cc.

                                         {
 
    std::ostringstream output;
    output << "DA " << std::dec << def.size();
    if (def.isInitialized())  {
        for (int mau = 0; mau < def.size(); mau++) {
            output << endl << "1:0x" << std::hex << def.MAU(mau);
        }
    }
    output << " ;" << endl;
    return output.str();
}

References TTAProgram::DataDefinition::isInitialized(), TTAProgram::DataDefinition::MAU(), and TTAProgram::DataDefinition::size().

Referenced by disassembleProgram().

Here is the call graph for this function:

dataSectionDescription()

TCEString POMDisassembler::dataSectionDescription ( const TTAMachine::AddressSpace &  aSpace, Word  location  )

virtual

Definition at line 924 of file POMDisassembler.cc.

                                                         {
    TCEString output;
    output << "DATA " << aSpace.name() << " "
           << location << " ;";
    return output;
}

References TTAMachine::Component::name().

Referenced by disassembleProgram().

Here is the call graph for this function:

destinationLabels()

TCEString POMDisassembler::destinationLabels ( const TTAProgram::Procedure &  proc, int  instrIndex  ) const

virtual

Definition at line 840 of file POMDisassembler.cc.

                                                           {
 
    std::stringstream stringStream;
    InstructionAddress addr = proc.startAddress().location() + instrIndex;
    const int lc = POMDisassembler::labelCount(proc.parent(), addr);
    for (int labelIndex = 0; labelIndex < lc; ++labelIndex) {
        stringStream
            << labelPositionDescription(POMDisassembler::label(
                proc.parent(), addr, labelIndex))
            << std::endl;
    }
    return stringStream.str();
}

References label(), labelCount(), labelPositionDescription(), TTAProgram::Address::location(), TTAProgram::CodeSnippet::parent(), and TTAProgram::CodeSnippet::startAddress().

Referenced by disassembleProcedure().

Here is the call graph for this function:

disassemble() [1/4]

std::string POMDisassembler::disassemble ( const TTAProgram::Instruction &  instruction, bool  printAddresses = false, int  addr = -1  )

static

Static helper function to create disassembly string from an instruction.

Parameters

instruction	Instruction to disassemble.
printAddresses	Print the instruction's index as comment.

Returns

Disassembly of the instruction.

Definition at line 688 of file POMDisassembler.cc.

                                                                             {
 
    std::string disasm = "";
    if (!instruction.isInProcedure() ||
        !instruction.parent().isInProgram()) {
 
        // a "free instruction" that is not connected to any program
        // traverse the moves instead of the buses
 
        DisassemblyInstruction* dInstruction = new DisassemblyInstruction();
        // The instruction disassembly is created by one move at a time.
        for (int i = 0; i < instruction.moveCount(); i++) {
 
            const Move& move = instruction.move(i);
            const Bus* bus = &move.bus();
            string busName = move.bus().name();
            bool isUsed = false;
 
            // Check for long immediate.
            for (int i = 0; i < instruction.immediateCount(); i++) {
                if (&instruction.instructionTemplate() != 
                    &NullInstructionTemplate::instance() &&
                    instruction.instructionTemplate().usesSlot(busName)) {
                    dInstruction->addMove(
                        createImmediateAssignment(instruction.immediate(i)));
                    isUsed = true;
                }
            }
 
            // Check for move.
            for (int i = 0; i < instruction.moveCount(); i++) {
                if (&instruction.move(i).bus() == bus) {
                    dInstruction->addMove(createMove(instruction.move(i)));
                    isUsed = true;
                }
            }
 
            if (!isUsed) {
                dInstruction->addMove(new DisassemblyNOP);
            }
        }
 
        // Add disassembly of long immediates in immediate slots.
        for (int i = 0; i < instruction.immediateCount(); i++) {
            dInstruction->addLongImmediate(
                createImmediateAssignment(instruction.immediate(i)));                
        }
        
        disasm = dInstruction->toString() + " # 'free instruction'";
        delete dInstruction;
        dInstruction = NULL;
    } else {
 
        const Program& program = instruction.parent().parent();
        DisassemblyInstruction* dInstruction = 
            createInstruction(program, instruction);
 
        disasm = dInstruction->toString();
        delete dInstruction;
        dInstruction = NULL;
 
        // check for partially scheduled code, that is, moves that refer to
        // the unversal machine even though the target machine is not 
        // a universal machine
        const TTAMachine::Machine* mach = 
            dynamic_cast<UniversalMachine*>(&program.targetProcessor());
 
        if (mach == NULL) {
            // we have either mixed code or parallel code, let's check if this
            // instruction has a move scheduled to universal machine's bus, 
            // in which case it's mixed code and the sequential move did not
            // get printed with createInstruction()
            for (int i = 0; i < instruction.moveCount(); ++i) {
                const TTAProgram::Move& m = instruction.move(i);
                if (dynamic_cast<UniversalMachine*>(m.bus().machine()) != NULL) {
                    // found unscheduled move, add it only as a comment to the
                    // disassembly to make the output compilable with TCEAssembler
                    disasm += "\t# unscheduled: ";
                    disasm += POMDisassembler::disassemble(m);
                }
            }
        } else {
            // a sequential program
        }
 
        if (printAddresses) {
            disasm += 
                "\t# @" + 
                Conversion::toString(
                    addr != -1 ? addr : instruction.address().location());
        }
    }
    // to display source filename and line number
    // check for source code filename, we just use the file filename, 
    // assume the all the move belong the same file
    TCEString fileNameStr = "";
    for (int i = 0; i < instruction.moveCount(); ++i) {
        const TTAProgram::Move& m = instruction.move(i);
        if (m.hasSourceFileName()) {
            fileNameStr += m.sourceFileName();
            break;
        }
    }
 
    if (fileNameStr != "")
        disasm += "\t# file: " + fileNameStr;        
 
    // check for soure code line number info
    TCEString lineNumberStr = "";
    for (int i = 0; i < instruction.moveCount(); ++i) {
        const TTAProgram::Move& m = instruction.move(i);
        if (m.hasSourceLineNumber()) {
            if (lineNumberStr != "") {
                lineNumberStr += ", ";
            }
            lineNumberStr += 
                Conversion::toString(m.sourceLineNumber());
        }
    }
        
    if (lineNumberStr != "")
        disasm += "\t# slines: " + lineNumberStr;        
    
    return disasm;
}

References DisassemblyInstruction::addLongImmediate(), DisassemblyInstruction::addMove(), TTAProgram::Instruction::address(), TTAProgram::Move::bus(), createImmediateAssignment(), createInstruction(), createMove(), disassemble(), TTAProgram::Move::hasSourceFileName(), TTAProgram::Move::hasSourceLineNumber(), TTAProgram::Instruction::immediate(), TTAProgram::Instruction::immediateCount(), TTAMachine::NullInstructionTemplate::instance(), TTAProgram::Instruction::instructionTemplate(), TTAProgram::Instruction::isInProcedure(), TTAProgram::CodeSnippet::isInProgram(), TTAProgram::Address::location(), TTAMachine::Component::machine(), TTAProgram::Instruction::move(), TTAProgram::Instruction::moveCount(), TTAMachine::Component::name(), TTAProgram::CodeSnippet::parent(), TTAProgram::Instruction::parent(), program, TTAProgram::Move::sourceFileName(), TTAProgram::Move::sourceLineNumber(), DisassemblyInstruction::toString(), Conversion::toString(), and TTAMachine::InstructionTemplate::usesSlot().

Here is the call graph for this function:

disassemble() [2/4]

std::string POMDisassembler::disassemble ( const TTAProgram::Move &  move )

static

Static helper function to create disassembly string from a move.

Parameters

move	Move to disassemble.

Returns

Disassembly of the instruction.

Definition at line 629 of file POMDisassembler.cc.

                                                       {
   
    // special handling for calls: find out the procedure name to make
    // the disassembly a bit more readable
    if (move.isCall()) {
        if (move.source().isInstructionAddress()) {
            
            DisassemblyMove* dMove = createMove(move);
            std::string disasm = "";
            disasm = dMove->toString();
            
            Procedure* proc = NULL;
            try {
                proc = dynamic_cast<TTAProgram::Procedure*>(
                    &move.source().instructionReference().instruction().parent());
            } catch (...) {
                // proc stays NULL if something goes wrong.
            }
            
            std::string procName = 
                proc != NULL ? proc->name() : "unknown_proc";
            return (boost::format("%s -> %s.call.1") 
                    % procName
                    % move.destination().functionUnit().name()).str();
        } 
        
        if (move.source().isCodeSymbolReference()) {
            return (boost::format("%s -> %s.call.1")
                    % move.source().toString()
                    % move.destination().functionUnit().name()).str();
        }
    } else if (move.isJump() && move.source().isCodeSymbolReference()) {
        // A jump to a procedure, converted from a call.
        return (boost::format("%s -> %s.jump.1")
                % move.source().toString()
                % move.destination().functionUnit().name()).str();
    }
 
    DisassemblyMove* dMove = createMove(move);
    std::string disasm = "";
    disasm = dMove->toString();
    delete dMove;
    return disasm;
}

References createMove(), TTAProgram::Move::destination(), TTAProgram::Terminal::functionUnit(), TTAProgram::InstructionReference::instruction(), TTAProgram::Terminal::instructionReference(), TTAProgram::Move::isCall(), TTAProgram::Terminal::isCodeSymbolReference(), TTAProgram::Terminal::isInstructionAddress(), TTAProgram::Move::isJump(), TTAMachine::Component::name(), TTAProgram::Procedure::name(), TTAProgram::Instruction::parent(), TTAProgram::Move::source(), DisassemblyMove::toString(), and TTAProgram::Terminal::toString().

Referenced by TTAProgram::CodeSnippet::add(), TTAProgram::Instruction::address(), SimpleBrokerDirector::assign(), SimProgramBuilder::build(), SimulatorFrontend::compareState(), TTAProgram::ProgramWriter::createCodeSection(), ControlFlowGraph::createControlFlowEdge(), ControlFlowGraph::directJump(), ProgramDependenceGraph::disassemble(), disassemble(), disassembleInstruction(), TTAProgram::CodeSnippet::disassembly(), llvm::LLVMTCEBuilder::doFinalization(), ControlFlowGraph::findNextIndex(), main(), CriticalPathBBMoveNodeSelector::mightBeReady(), DataDependenceGraph::nodeOfMove(), SimProgramBuilder::processInstruction(), DataDependenceGraphBuilder::processTriggerPO(), BFUnscheduleFromBody::returnOriginal(), BFUnscheduleMove::returnOriginal(), BFShareOperandLate::revert(), BFOptimization::rmLC(), TTAProgram::Instruction::toString(), TTAProgram::Move::toString(), MoveNode::toString(), and TTAProgram::Program::toString().

Here is the call graph for this function:

disassemble() [3/4]

std::string POMDisassembler::disassemble ( const TTAProgram::Procedure &  proc, bool  printAddresses = false  )

static

Static helper function to create a disassembly string from a procedure.

Parameters

proc	Procedure to disassemble.
printAddresses	Print the instruction addresses as comment.

Returns

Disassembly of the procedure in a string.

Exceptions

Exception

Can leak exceptions if the traversed program is malformed, etc.

Deprecated:

Use obj.disassembleProcedure(proc) instead.

Definition at line 1011 of file POMDisassembler.cc.

                                                          {
    POMDisassembler disasm(printAddresses);
    return disasm.disassembleProcedure(proc);
}

References disassembleProcedure().

Here is the call graph for this function:

disassemble() [4/4]

std::string POMDisassembler::disassemble ( const TTAProgram::Program &  program, bool  printAddresses = false  )

static

Static helper function to create a disassembly string from a program.

Parameters

program	Program to disassemble.
printAddresses	Print the instruction addresses as comment.

Returns

Disassembly of the program in a string.

Exceptions

Exception

Can leak exceptions if the traversed program is malformed, etc.

Deprecated:

Use obj.disassembleProcedures() instead.

Definition at line 826 of file POMDisassembler.cc.

                                                           {
    POMDisassembler disasm(program, printAddresses);
    return disasm.disassembleProcedures();
}

References disassembleProcedures(), and program.

Here is the call graph for this function:

disassembleFully()

TCEString POMDisassembler::disassembleFully ( const TTAProgram::Program &  program, bool  printAddresses = false  )

static

Static helper function to create a disassembly string from a whole program including section markers and data memory initializations.

Parameters

program	Program to disassemble.
printAddresses	If the instruction addresses should be printed.

Returns

Disassembly of the program in a string.

Exceptions

Exception

Can leak exceptions if the traversed program is malformed, etc.

Deprecated:

Use obj.disassembleProgram() instead.

Definition at line 910 of file POMDisassembler.cc.

                                                           {
    POMDisassembler disasm(program, printAddresses);
    return disasm.disassembleProgram();
}

References disassembleProgram(), and program.

Here is the call graph for this function:

disassembleInstruction()

TCEString POMDisassembler::disassembleInstruction ( const TTAProgram::Instruction &  instruction, int  addr = -1  )

virtual

"Template methods" that can be overridden in the derived assemblers.

Definition at line 675 of file POMDisassembler.cc.

                                                        {
    return POMDisassembler::disassemble(instruction, printAddresses_, addr);
}

References disassemble(), and printAddresses_.

Referenced by SimulatorFrontend::disassembleInstruction(), disassembleProcedure(), and SimulatorFrontend::programLocationDescription().

Here is the call graph for this function:

disassembleProcedure()

TCEString POMDisassembler::disassembleProcedure ( const TTAProgram::Procedure &  proc )

virtual

Definition at line 861 of file POMDisassembler.cc.

                                                                     {
 
    std::stringstream stringStream;
 
    const TTAProgram::Instruction* currentInstruction = NULL;
    stringStream << procedureDescription(proc) << std::endl;
 
    for (int instrIndex = 0, iCount = proc.instructionCount();
         instrIndex < iCount; ++instrIndex) {
        currentInstruction = &proc.instructionAtIndex(instrIndex);
 
        stringStream << destinationLabels(proc, instrIndex);
 
        InstructionAddress addr = proc.startAddress().location() + instrIndex;
 
        // Do not print "implicit instructions" of OTAs.
        if (currentInstruction->size() > 0) {
            stringStream << "\t" <<
                disassembleInstruction(*currentInstruction, addr) << std::endl;
        }
    }
    return stringStream.str();
}

References destinationLabels(), disassembleInstruction(), TTAProgram::CodeSnippet::instructionAtIndex(), TTAProgram::CodeSnippet::instructionCount(), TTAProgram::Address::location(), procedureDescription(), TTAProgram::Instruction::size(), and TTAProgram::CodeSnippet::startAddress().

Referenced by disassemble(), and disassembleProcedures().

Here is the call graph for this function:

disassembleProcedures()

TCEString POMDisassembler::disassembleProcedures ( )

virtual

Definition at line 886 of file POMDisassembler.cc.

                                       {
 
    std::stringstream stringStream;
 
    for (int procIndex = 0; procIndex < program_.procedureCount();
         ++procIndex) {
        const Procedure& proc = program_.procedureAtIndex(procIndex);
        stringStream << disassembleProcedure(proc);
    }
    return stringStream.str();
}

References disassembleProcedure(), TTAProgram::Program::procedureAtIndex(), TTAProgram::Program::procedureCount(), and program_.

Referenced by disassemble(), and disassembleProgram().

Here is the call graph for this function:

disassembleProgram()

TCEString POMDisassembler::disassembleProgram ( )

virtual

Create a disassembly string from the whole program including module headers, section markers and data memory initializations.

Returns

Disassembly of the program in a string.

Exceptions

Exception

Can leak exceptions if the traversed program is malformed, etc.

Definition at line 956 of file POMDisassembler.cc.

                                    {
 
    std::stringstream output;
    Word first = startAddress();
 
    output << codeSectionDescription(first) << endl << endl;
    output << disassembleProcedures() << endl << endl;
 
    // Write data memory initializations.
    for (int i = 0; i < program_.dataMemoryCount(); i++) {
 
        const TTAProgram::DataMemory& mem = program_.dataMemory(i);
        const TTAMachine::AddressSpace& aSpace = mem.addressSpace();
 
        if (mem.dataDefinitionCount() == 0) continue;
 
        output << dataSectionDescription(
            aSpace, mem.dataDefinition(0).startAddress().location()) << endl;
 
        // Definitions are put in a map to order them.
        // TODO: the indexing API of DataMemory could be used for this?
        // TODO: does this handle "holes" correctly or assume fully
        // "connected regions" always?
        // TODO: this does not handle UDATA at all!
        std::map<Word, const TTAProgram::DataDefinition*> definitions;
        for (int d = 0; d < mem.dataDefinitionCount(); d++) {
            const TTAProgram::DataDefinition& def = mem.dataDefinition(d);
            definitions[def.startAddress().location()] = &def;
        }
 
        std::map<Word, const TTAProgram::DataDefinition*>::iterator iter =
            definitions.begin();
 
        for (; iter != definitions.end(); iter++) {
            const TTAProgram::DataDefinition* def = (*iter).second;
            output << dataDefDescription(*def) << endl;
        }
    }
    output << endl;
 
    return output.str();
}

References TTAProgram::DataMemory::addressSpace(), codeSectionDescription(), dataDefDescription(), TTAProgram::DataMemory::dataDefinition(), TTAProgram::DataMemory::dataDefinitionCount(), TTAProgram::Program::dataMemory(), TTAProgram::Program::dataMemoryCount(), dataSectionDescription(), disassembleProcedures(), TTAProgram::Address::location(), program_, TTAProgram::DataDefinition::startAddress(), and startAddress().

Referenced by disassembleFully().

Here is the call graph for this function:

disassembler()

POMDisassembler * POMDisassembler::disassembler ( const TTAMachine::Machine &  mach, const TTAProgram::Program &  program  )

static

A factor for building a correct type of disassembler for the target.

Definition at line 1022 of file POMDisassembler.cc.

                                      {
    return new POMDisassembler(program);
}

References program.

Referenced by TTAProgram::Program::finalize(), and SimulatorFrontend::initializeDisassembler().

instructionCount()

Word POMDisassembler::instructionCount ( ) const

virtual

Returns number of instructions in the program.

Returns

Instruction count.

Definition at line 495 of file POMDisassembler.cc.

                                        {
    Word count = 0;
    unsigned procedureCount = program_.procedureCount();
    for (unsigned i = 0; i < procedureCount; i++) {
        const Procedure& procedure = program_.procedure(i);
        count = count + procedure.instructionCount();
    }
    return count;
}

References TTAProgram::CodeSnippet::instructionCount(), TTAProgram::Program::procedure(), TTAProgram::Program::procedureCount(), and program_.

Here is the call graph for this function:

instructionSize()

virtual size_t POMDisassembler::instructionSize ( const TTAProgram::Instruction &  )

inlinevirtual

Returns the size of the instruction in memory addresses, if known. Falls back to address per instruction.

Definition at line 119 of file POMDisassembler.hh.

        { return 1; }

Referenced by TTAProgram::Program::finalize().

isCallOrJump()

bool POMDisassembler::isCallOrJump ( const TTAProgram::Terminal &  terminal )

staticprivate

Checks if the terminal is a control unit jump or call operand.

Parameters

terminal

Terminal to check.

Returns

True, if the terminal is a control unit jump or call operand, false otherwise.

Definition at line 595 of file POMDisassembler.cc.

                                                      {
 
    if (!terminal.isFUPort()) {
        return false;
    }
 
    const FunctionUnit* fu = &terminal.functionUnit();
 
    if (dynamic_cast<const ControlUnit*>(fu) == NULL) {
        return false;
    }
 
    if (!terminal.isOpcodeSetting()) {
        return false;
    }
 
    string operationName =
        StringTools::stringToLower(terminal.operation().name());
 
    if (operationName == "call" || operationName == "jump") {
        return true;
    }
 
    return false;
}

References TTAProgram::Terminal::functionUnit(), TTAProgram::Terminal::isFUPort(), TTAProgram::Terminal::isOpcodeSetting(), Operation::name(), TTAProgram::Terminal::operation(), and StringTools::stringToLower().

Referenced by createMove().

Here is the call graph for this function:

label() [1/2]

std::string POMDisassembler::label ( const TTAProgram::Program &  program, Word  address, int  index  )

staticprivate

Returns instruction label with the given index.

Parameters

address	Instruction address.
program	Program to search label for.

Returns

Instruction label with the given index and address.

Exceptions

OutOfRange

The address or index is out of range.

Definition at line 563 of file POMDisassembler.cc.

                                                               {
    if (index == 0 && labelCount(program, address) == 1) {
        for (int i = 0; i < program.procedureCount(); i++) {
            if (program.procedure(i).startAddress().location() == address) {
                return program.procedure(i).name();
            }
        }
    }
 
    if (index > labelCount(program, address)) {
        throw OutOfRange(
            __FILE__, __LINE__, __func__, "No label in requested index: " +
            Conversion::toString(index));
    }
 
    Address iaddr(address, program.startAddress().space());
 
    const CodeLabel& label =
        program.globalScopeConst().globalCodeLabel(iaddr, index);
 
    return label.name();
}

References __func__, label(), labelCount(), TTAProgram::Label::name(), program, and Conversion::toString().

Here is the call graph for this function:

label() [2/2]

std::string POMDisassembler::label	(	Word	address,
		int	index
	)		const

Returns instruction label with the given index.

Parameters

address

Instruction address.

Returns

Instruction label with the given index and address.

Exceptions

OutOfRange

The address or index is out of range.

Definition at line 550 of file POMDisassembler.cc.

                                                    {
    return label(program_, address, index);
}

References label(), and program_.

Referenced by createMove(), destinationLabels(), label(), and label().

Here is the call graph for this function:

labelCount() [1/2]

int POMDisassembler::labelCount ( const TTAProgram::Program &  program, Word  address  )

staticprivate

Returns number of labels at the given address.

Parameters

address

Instruction address.

Returns

Instruction label count.

Definition at line 523 of file POMDisassembler.cc.

                                                                          {
    
    Address iaddr(address, program.startAddress().space());
    const GlobalScope& scope = program.globalScopeConst();
    unsigned labelCount = scope.globalCodeLabelCount(iaddr);
 
    if (labelCount > 0) {
        return labelCount;
    }
 
    for (int i = 0; i < program.procedureCount(); i++) {
        if (program.procedure(i).startAddress().location() == address) {
            return 1;
        }
    }
 
    return 0;
}

References TTAProgram::GlobalScope::globalCodeLabelCount(), labelCount(), and program.

Here is the call graph for this function:

labelCount() [2/2]

int POMDisassembler::labelCount

(

Word

address

)

const

Returns number of labels at the given address.

Parameters

address

Instruction address.

Returns

Instruction label count.

Definition at line 512 of file POMDisassembler.cc.

                                              {
    return labelCount(program_, address);
}

References labelCount(), and program_.

Referenced by createMove(), destinationLabels(), label(), labelCount(), and labelCount().

Here is the call graph for this function:

labelPositionDescription()

TCEString POMDisassembler::labelPositionDescription ( TCEString  labelStr ) const

virtual

Definition at line 856 of file POMDisassembler.cc.

                                                                  {
    return labelStr + ":";
}

Referenced by destinationLabels().

printAddress()

TCEString POMDisassembler::printAddress ( const TTAProgram::Instruction &  instr ) const

virtual

Definition at line 1030 of file POMDisassembler.cc.

                                                                      {
    return TCEString("\t# @") << instr.address().location();
}

References TTAProgram::Instruction::address(), and TTAProgram::Address::location().

Here is the call graph for this function:

procedureDescription()

TCEString POMDisassembler::procedureDescription ( const TTAProgram::Procedure &  proc )

virtual

Definition at line 833 of file POMDisassembler.cc.

                                                                     {
    TCEString output;
    output << ":procedure " << proc.name() << ";";
    return output;
}

References TTAProgram::Procedure::name().

Referenced by disassembleProcedure().

Here is the call graph for this function:

setPrintAddresses()

virtual void POMDisassembler::setPrintAddresses ( bool  addresses )

inlinevirtual

Definition at line 125 of file POMDisassembler.hh.

        { printAddresses_ = addresses; }

References printAddresses_.

startAddress()

Word POMDisassembler::startAddress ( ) const

virtual

Returns start address of the program.

Returns

Start address of the program.

Definition at line 483 of file POMDisassembler.cc.

                                    {
    unsigned int address = program_.startAddress().location();
    return address;
}

References TTAProgram::Address::location(), program_, and TTAProgram::Program::startAddress().

Referenced by codeSectionDescription(), disassembleProgram(), and main().

Here is the call graph for this function:

Member Data Documentation

printAddresses_

bool POMDisassembler::printAddresses_

protected

True if instruction indices (addresses) should be printed at the end of lines.

Definition at line 134 of file POMDisassembler.hh.

Referenced by disassembleInstruction(), and setPrintAddresses().

program_

const TTAProgram::Program& POMDisassembler::program_

protected

Program object model to disassemble.

Definition at line 132 of file POMDisassembler.hh.

Referenced by createInstruction(), disassembleProcedures(), disassembleProgram(), instructionCount(), label(), labelCount(), and startAddress().

---

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

• POMDisassembler.hh
• POMDisassembler.cc