void operator()(const RegisterDescriptor &desc, const char *abbr) { BaseSemantics::RegisterStatePtr regstate = ops->get_state()->get_register_state(); FormatRestorer fmt(o); o <<prefix <<std::setw(8) <<std::left <<abbr <<"= { "; fmt.restore(); BaseSemantics::SValuePtr val = regstate->readRegister(desc, ops.get()); o <<*val <<" }\n"; }
std::string NoOperation::StateNormalizer::toString(const BaseSemantics::DispatcherPtr &cpu, const BaseSemantics::StatePtr &state_) { BaseSemantics::StatePtr state = state_; BaseSemantics::RiscOperatorsPtr ops = cpu->get_operators(); if (!state) return ""; bool isCloned = false; // do we have our own copy of the state? // If possible and appropriate, remove the instruction pointer register const RegisterDescriptor regIp = cpu->instructionPointerRegister(); BaseSemantics::RegisterStateGenericPtr rstate = BaseSemantics::RegisterStateGeneric::promote(state->registerState()); if (rstate && rstate->is_partly_stored(regIp)) { BaseSemantics::SValuePtr ip = ops->readRegister(cpu->instructionPointerRegister()); if (ip->is_number()) { state = state->clone(); isCloned = true; rstate = BaseSemantics::RegisterStateGeneric::promote(state->registerState()); rstate->erase_register(regIp, ops.get()); } } // Get the memory state, cloning the state if not done so above. BaseSemantics::MemoryCellStatePtr mem = boost::dynamic_pointer_cast<BaseSemantics::MemoryCellState>(state->memoryState()); if (mem && !isCloned) { state = state->clone(); isCloned = true; mem = BaseSemantics::MemoryCellState::promote(state->memoryState()); } // Erase memory that has never been written (i.e., cells that sprang into existence by reading an address) of which appears // to have been recently popped from the stack. CellErasurePredicate predicate(ops, ops->readRegister(cpu->stackPointerRegister()), ignorePoppedMemory_); if (mem) mem->eraseMatchingCells(predicate); BaseSemantics::Formatter fmt; fmt.set_show_latest_writers(false); fmt.set_show_properties(false); std::ostringstream ss; ss <<(*state+fmt); return ss.str(); }
BaseSemantics::StatePtr NoOperation::initialState(SgAsmInstruction *insn) const { ASSERT_not_null(insn); ASSERT_not_null(cpu_); BaseSemantics::StatePtr state; if (normalizer_) { state = normalizer_->initialState(cpu_, insn); } else { state = cpu_->currentState()->clone(); state->clear(); RegisterDescriptor IP = cpu_->instructionPointerRegister(); state->writeRegister(IP, cpu_->number_(IP.get_nbits(), insn->get_address()), cpu_->get_operators().get()); } // Set the stack pointer to a concrete value if (initialSp_) { const RegisterDescriptor regSp = cpu_->stackPointerRegister(); BaseSemantics::RiscOperatorsPtr ops = cpu_->get_operators(); state->writeRegister(regSp, ops->number_(regSp.get_nbits(), *initialSp_), ops.get()); } return state; }