InstructionSpecificAddressCallback.cpp

Go to the documentation of this file.

 
#include "etiss/IntegratedLibrary/InstructionSpecificAddressCallback.h"
 
extern "C"
{
    int InstructionSpecificAddressCallback_callback(void *this_)
    {
        etiss::plugin::InstructionSpecificAddressCallback::Data *data_ =
            (etiss::plugin::InstructionSpecificAddressCallback::Data *)this_;
#if DEBUG
        if (this_ == 0)
        {
            etiss::log(etiss::ERROR, "InstructionSpecificAddressCallback_callback called with nullptr.");
            return false;
        }
        if (data_->this_ == 0)
        {
            etiss::log(etiss::ERROR, "InstructionSpecificAddressCallback_callback called with uninitialized struct.");
        }
#endif
        return ((etiss::plugin::InstructionSpecificAddressCallback *)(data_->this_))->callback();
    }
}
 
using namespace etiss::plugin;
 
InstructionSpecificAddressCallback::InstructionSpecificAddressCallback()
{
    pluginData_.state_ = 0;
    pluginData_.this_ = this;
}
InstructionSpecificAddressCallback::~InstructionSpecificAddressCallback() {}
 
void InstructionSpecificAddressCallback::initCodeBlock(etiss::CodeBlock &block) const
{
    block.fileglobalCode().insert("extern int InstructionSpecificAddressCallback_callback(void *);\n");
    block.functionglobalCode().insert("  if ( (*(uint32_t*)(" + getPointerCode() +
                                      ")) != " + etiss::toString(pluginData_.state_) +
                                      ") return ETISS_RETURNCODE_RELOADCURRENTBLOCK;\n"); // add print function
}
 
void InstructionSpecificAddressCallback::finalizeInstrSet(etiss::instr::ModedInstructionSet &mis) const
{
    mis.foreach ([this](etiss::instr::VariableInstructionSet &vis) {
        vis.foreach ([this](etiss::instr::InstructionSet &set) {
            set.foreach ([this](etiss::instr::Instruction &instr) {
                instr.addCallback(
                    [this](etiss::instr::BitArray &ba, etiss::CodeSet &cs, etiss::instr::InstructionContext &ic) {
                        if (this->callbackAddresses().find(ic.current_address_) != this->callbackAddresses().end())
                        {
                            std::stringstream ss;
                            ss << "      if ( (*(uint32_t*)(" << getPointerCode()
                               << ")) != " << etiss::toString(pluginData_.state_) << ")\n"
                               << "        return ETISS_RETURNCODE_RELOADCURRENTBLOCK;";
                            cs.append(CodePart::PREINITIALDEBUGRETURNING).code() = ss.str();
 
                            ss.str("");
                            ss.clear();
                            ss << "      uint32_t callbackCalled = InstructionSpecificAddressCallback_callback("
                               << getPointerCode() << ");";
                            // cs.append(CodePart::APPENDEDREQUIRED).code() = ss.str();
                            cs.append(CodePart::PREINITIALDEBUGRETURNING).code() = ss.str();
 
                            ss.str("");
                            ss.clear();
                            ss << "      if(callbackCalled)\n"
                               << "        return ETISS_RETURNCODE_NOERROR;";
                            // cs.append(CodePart::APPENDEDRETURNINGREQUIRED).code() = ss.str();
                            cs.append(CodePart::PREINITIALDEBUGRETURNING).code() = ss.str();
                        }
                        return true;
                    },
                    0);
                if (callbackOnInstruction(instr))
                {
                    instr.addCallback(
                        [this](etiss::instr::BitArray &ba, etiss::CodeSet &cs, etiss::instr::InstructionContext &ic) {
                            std::stringstream ss;
                            ss << "      InstructionSpecificAddressCallback_callback(";
                            ss << getPointerCode();
                            ss << ");";
                            cs.append(CodePart::PREINITIALDEBUGRETURNING).code() = ss.str();
                            return true;
                        },
                        0);
                }
            });
        });
    });
}
 
std::string InstructionSpecificAddressCallback::_getPluginName() const
{
    return "InstructionSpecificAddressCallback";
}
 
void *InstructionSpecificAddressCallback::getPluginHandle()
{
    return (void *)&pluginData_;
}