const char* ARMv7DOpcodeMiscCompareAndBranch::format()
{
appendInstructionName(opName());
appendPCRelativeOffset(immediate6() + 2);
return m_formatBuffer;
}
const char* ARMv7DOpcodeMiscPushPop::format()
{
appendInstructionName(opName());
appendRegisterList(registerMask());
return m_formatBuffer;
}
const char* ARMv7DOpcodeBranchExchangeT1::format()
{
appendInstructionName(opName());
appendRegisterName(rm());
return m_formatBuffer;
}
static void print( std::ostream& out, const TreeNode* nd, std::size_t indent=1)
{
if (nd->name())
{
out << nd->name() << ":" << std::endl;
}
std::string indentstr( indent*2, ' ');
if (nd->m_term && nd->args().empty())
{
out << indentstr;
out << "term '" << nd->term() << "'";
if (nd->variable())
{
out << " -> " << nd->m_variable;
}
out << std::endl;
}
else
{
out << indentstr;
out << opName( nd->op()) << ", cardinality " << nd->cardinality() << ", range " << nd->range();
if (nd->variable())
{
out << " -> " << nd->m_variable;
}
out << std::endl;
std::vector<TreeNode*>::const_iterator ai = nd->m_args.begin(), ae = nd->m_args.end();
for (; ai != ae; ++ai)
{
print( out, *ai, indent+1);
}
}
}
const char* ARMv7DOpcodeMiscHint16::format()
{
if (opA() > 4)
return defaultFormat();
appendInstructionName(opName());
return m_formatBuffer;
}
const char* ARMv7DOpcodeAddSubtractImmediate8::format()
{
appendInstructionName(opName(), !inITBlock());
appendRegisterName(rdn());
appendSeparator();
appendUnsignedImmediate(immediate8());
return m_formatBuffer;
}
const char* ARMv7DOpcodeMiscAddSubSP::format()
{
appendInstructionName(opName());
appendRegisterName(RegSP);
appendSeparator();
appendRegisterName(RegSP);
appendSeparator();
appendUnsignedImmediate(immediate7());
return m_formatBuffer;
}
const char* ARMv7DOpcodeLoadStoreRegisterImmediate::format()
{
const char* instructionName = opName();
if (!instructionName)
return defaultFormat();
appendInstructionName(opName());
appendRegisterName(rt());
appendSeparator();
appendCharacter('[');
appendRegisterName(rn());
if (immediate5()) {
appendSeparator();
appendUnsignedImmediate(immediate5() << scale());
}
appendCharacter(']');
return m_formatBuffer;
}
const char* ARMv7DOpcodeAddSubtractT1::format()
{
appendInstructionName(opName(), !inITBlock());
appendRegisterName(rd());
appendSeparator();
appendRegisterName(rn());
appendSeparator();
appendRegisterName(rm());
return m_formatBuffer;
}
const char* ARMv7DOpcodeLoadStoreRegisterOffsetT1::format()
{
appendInstructionName(opName());
appendRegisterName(rt());
appendSeparator();
appendCharacter('[');
appendRegisterName(rn());
appendSeparator();
appendRegisterName(rm());
appendCharacter(']');
return m_formatBuffer;
}
const char* ARMv7DOpcodeMiscByteHalfwordOps::format()
{
const char* instructionName = opName();
if (!instructionName)
return defaultFormat();
appendInstructionName(instructionName);
appendRegisterName(rd());
appendSeparator();
appendRegisterName(rm());
return m_formatBuffer;
}
shared_ptr<OutputPlugin>
OutputPlugin::getPlugin(std::string Details, const dynamo::Simulation* Sim)
{
typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
rapidxml::xml_document<> doc;
rapidxml::xml_node<> *node = doc.allocate_node(rapidxml::node_element,
doc.allocate_string("OP"));
boost::char_separator<char> DetailsSep(":");
boost::char_separator<char> OptionsSep(",");
boost::char_separator<char> ValueSep("=", "", boost::keep_empty_tokens);
tokenizer tokens(Details, DetailsSep);
tokenizer::iterator details_iter = tokens.begin();
node->append_attribute(doc.allocate_attribute
("Type", doc.allocate_string(details_iter->c_str())));
++details_iter;
if (details_iter != tokens.end())
{
tokenizer option_tokens(*details_iter, OptionsSep);
if (++details_iter != tokens.end())
M_throw() << "Two colons in outputplugin options " << *details_iter;
for (tokenizer::iterator options_iter = option_tokens.begin();
options_iter != option_tokens.end(); ++options_iter)
{
tokenizer value_tokens(*options_iter, ValueSep);
tokenizer::iterator value_iter = value_tokens.begin();
std::string opName(*value_iter);
std::string val;
if (++value_iter == value_tokens.end())
//There is no value to save, must be a flag
val = "";
else
val = *value_iter;
node->append_attribute(doc.allocate_attribute
(doc.allocate_string(opName.c_str()),
doc.allocate_string(val.c_str())));
}
}
return getPlugin(magnet::xml::Node(node, NULL), Sim);
}
const char* ARMv7DOpcodeDataProcessingRegisterT1::format()
{
appendInstructionName(opName(), inITBlock() && (!(op() == 0x8) || (op() == 0xa) || (op() == 0xb)));
appendRegisterName(rdn());
appendSeparator();
appendRegisterName(rm());
if (op() == 0x9) // rsb T1
appendString(", #0");
else if (op() == 0xd) { // mul T1
appendSeparator();
appendRegisterName(rdn());
}
return m_formatBuffer;
}
const char* ARMv7DOpcodeLoadStoreRegisterSPRelative::format()
{
appendInstructionName(opName());
appendRegisterName(rt());
appendSeparator();
appendCharacter('[');
appendRegisterName(RegSP);
if (immediate8()) {
appendSeparator();
appendUnsignedImmediate(immediate8() << 2);
}
appendCharacter(']');
return m_formatBuffer;
}
const char* ARMv7DOpcodeLogicalImmediateT1::format()
{
if (!op() && !immediate5()) {
// mov T2
appendInstructionName("movs");
appendRegisterName(rd());
appendSeparator();
appendRegisterName(rm());
return m_formatBuffer;
}
appendInstructionName(opName(), !inITBlock());
appendRegisterName(rd());
appendSeparator();
appendRegisterName(rm());
appendSeparator();
appendUnsignedImmediate((op() && !immediate5()) ? 32 : immediate5());
return m_formatBuffer;
}
Node* BinaryOpNode::calculate(){
Values value = token->value;
IntNumber *l_intToken = dynamic_cast<IntNumber*>(left->token);
FloatNumber *l_floatToken = dynamic_cast<FloatNumber*>(left->token);
Char *l_charToken = dynamic_cast<Char*>(left->token);
Node *res = 0;
if(l_floatToken){
float leftOp = l_floatToken->v2,
rightOp = dynamic_cast<FloatNumber*>(right->token)->v2;
switch(value){
case plus:
res = new FloatNode(new FloatNumber(left->token->start, 0, leftOp + rightOp), 0);
break;
case minus:
res = new FloatNode(new FloatNumber(left->token->start, 0, leftOp - rightOp), 0);
break;
case factor:
res = new FloatNode(new FloatNumber(left->token->start, 0, leftOp * rightOp), 0);
break;
case divis:
res = new FloatNode(new FloatNumber(left->token->start, 0, leftOp / rightOp), 0);
break;
case equally:
res = new IntNode(new IntNumber(left->token->start, 0, leftOp == rightOp));
break;
case not_eql:
res = new IntNode(new IntNumber(left->token->start, 0, leftOp != rightOp));
break;
default:
throw MyException("Operation \"" + opName(value) + "\" not allowed for these operands", left->token);
}
} else {
int leftOp, rightOp, r;
if(l_intToken){
leftOp = l_intToken->v2;
rightOp = dynamic_cast<IntNumber*>(right->token)->v2;
}
else {
leftOp = l_charToken->v2;
rightOp = dynamic_cast<Char*>(right->token)->v2;
}
auto op = operationReturningType[value];
switch(value){
case plus:
r = leftOp + rightOp;
break;
case minus:
r = leftOp - rightOp;
break;
case factor:
r = leftOp * rightOp;
break;
case divis:
if(rightOp == 0)
throw MyException("Division by zero", token);
r = leftOp / rightOp;
break;
case percent:
r = leftOp % rightOp;
break;
case more:
r = leftOp > rightOp;
break;
case Values::less:
r = leftOp < rightOp;
break;
case equally:
r = leftOp == rightOp;
break;
case not_eql:
r = leftOp != rightOp;
break;
case xor:
r = leftOp ^ rightOp;
break;
case l_and:
r = leftOp && rightOp;
break;
case l_or:
r = leftOp || rightOp;
break;
case b_and:
r = leftOp & rightOp;
break;
case b_or:
r = leftOp | rightOp;
break;
case more_or_eql:
r = leftOp >= rightOp;
break;
case less_or_eql:
r = leftOp <= rightOp;
break;
case sr:
r = leftOp >> rightOp;
break;
case sl:
r = leftOp << rightOp;
break;
}
if(op == CharType)
res = new CharNode(new Char(left->token->start, 0, r));
else
res = new IntNode(new IntNumber(left->token->start, 0, r));
}
return res;
}
void PostfixUnaryOpNode::print(ofstream *f, int deep) const {
operand->print(deep);
*f << string(deep * 2, ' ') << opName(token->value) << endl;
}
void PostfixUnaryOpNode::print(int deep) const {
operand->print(deep);
cout << string(deep * 2, ' ') << opName(token->value) << endl;
}
void UnaryOpNode::print(ofstream *f, int deep) const {
*f << string(deep * 2, ' ') << opName(token->value) << endl;
operand->print(f, deep + 1);
}
void UnaryOpNode::print(int deep) const {
cout << string(deep * 2, ' ') << opName(token->value) << endl;
operand->print(deep + 1);
}
void BinaryOpNode::print(ofstream *f, int deep){
left->print(f, deep + 1);
*f << string(deep * 2, ' ') << opName(token->value) << endl;
right->print(deep + 1);
}
void BinaryOpNode::print(int deep) const {
left->print(deep + 1);
cout << string(deep * 2, ' ') << opName(token->value) << endl;
right->print(deep + 1);
}
void Graph::dump(const char* prefix, NodeIndex nodeIndex)
{
Node& node = at(nodeIndex);
NodeType op = node.op();
unsigned refCount = node.refCount();
bool skipped = !refCount;
bool mustGenerate = node.mustGenerate();
if (mustGenerate)
--refCount;
dataLog("%s", prefix);
printNodeWhiteSpace(node);
// Example/explanation of dataflow dump output
//
// 14: <!2:7> GetByVal(@3, @13)
// ^1 ^2 ^3 ^4 ^5
//
// (1) The nodeIndex of this operation.
// (2) The reference count. The number printed is the 'real' count,
// not including the 'mustGenerate' ref. If the node is
// 'mustGenerate' then the count it prefixed with '!'.
// (3) The virtual register slot assigned to this node.
// (4) The name of the operation.
// (5) The arguments to the operation. The may be of the form:
// @# - a NodeIndex referencing a prior node in the graph.
// arg# - an argument number.
// $# - the index in the CodeBlock of a constant { for numeric constants the value is displayed | for integers, in both decimal and hex }.
// id# - the index in the CodeBlock of an identifier { if codeBlock is passed to dump(), the string representation is displayed }.
// var# - the index of a var on the global object, used by GetGlobalVar/PutGlobalVar operations.
dataLog("% 4d:%s<%c%u:", (int)nodeIndex, skipped ? " skipped " : " ", mustGenerate ? '!' : ' ', refCount);
if (node.hasResult() && !skipped && node.hasVirtualRegister())
dataLog("%u", node.virtualRegister());
else
dataLog("-");
dataLog(">\t%s(", opName(op));
bool hasPrinted = false;
if (node.flags() & NodeHasVarArgs) {
for (unsigned childIdx = node.firstChild(); childIdx < node.firstChild() + node.numChildren(); childIdx++) {
if (hasPrinted)
dataLog(", ");
else
hasPrinted = true;
dataLog("%s@%u%s",
useKindToString(m_varArgChildren[childIdx].useKind()),
m_varArgChildren[childIdx].index(),
speculationToAbbreviatedString(
at(m_varArgChildren[childIdx]).prediction()));
}
} else {
if (!!node.child1()) {
dataLog("%s@%u%s",
useKindToString(node.child1().useKind()),
node.child1().index(),
speculationToAbbreviatedString(at(node.child1()).prediction()));
}
if (!!node.child2()) {
dataLog(", %s@%u%s",
useKindToString(node.child2().useKind()),
node.child2().index(),
speculationToAbbreviatedString(at(node.child2()).prediction()));
}
if (!!node.child3()) {
dataLog(", %s@%u%s",
useKindToString(node.child3().useKind()),
node.child3().index(),
speculationToAbbreviatedString(at(node.child3()).prediction()));
}
hasPrinted = !!node.child1();
}
if (strlen(nodeFlagsAsString(node.flags()))) {
dataLog("%s%s", hasPrinted ? ", " : "", nodeFlagsAsString(node.flags()));
hasPrinted = true;
}
if (node.hasArrayMode()) {
dataLog("%s%s", hasPrinted ? ", " : "", modeToString(node.arrayMode()));
hasPrinted = true;
}
if (node.hasVarNumber()) {
dataLog("%svar%u", hasPrinted ? ", " : "", node.varNumber());
hasPrinted = true;
}
if (node.hasRegisterPointer()) {
dataLog(
"%sglobal%u(%p)", hasPrinted ? ", " : "",
globalObjectFor(node.codeOrigin)->findRegisterIndex(node.registerPointer()),
node.registerPointer());
hasPrinted = true;
}
if (node.hasIdentifier()) {
dataLog("%sid%u{%s}", hasPrinted ? ", " : "", node.identifierNumber(), m_codeBlock->identifier(node.identifierNumber()).ustring().utf8().data());
hasPrinted = true;
}
if (node.hasStructureSet()) {
for (size_t i = 0; i < node.structureSet().size(); ++i) {
dataLog("%sstruct(%p)", hasPrinted ? ", " : "", node.structureSet()[i]);
hasPrinted = true;
}
}
if (node.hasStructure()) {
dataLog("%sstruct(%p)", hasPrinted ? ", " : "", node.structure());
hasPrinted = true;
}
if (node.hasStructureTransitionData()) {
dataLog("%sstruct(%p -> %p)", hasPrinted ? ", " : "", node.structureTransitionData().previousStructure, node.structureTransitionData().newStructure);
hasPrinted = true;
}
if (node.hasStorageAccessData()) {
StorageAccessData& storageAccessData = m_storageAccessData[node.storageAccessDataIndex()];
dataLog("%sid%u{%s}", hasPrinted ? ", " : "", storageAccessData.identifierNumber, m_codeBlock->identifier(storageAccessData.identifierNumber).ustring().utf8().data());
dataLog(", %lu", static_cast<unsigned long>(storageAccessData.offset));
hasPrinted = true;
}
ASSERT(node.hasVariableAccessData() == node.hasLocal());
if (node.hasVariableAccessData()) {
VariableAccessData* variableAccessData = node.variableAccessData();
int operand = variableAccessData->operand();
if (operandIsArgument(operand))
dataLog("%sarg%u(%s)", hasPrinted ? ", " : "", operandToArgument(operand), nameOfVariableAccessData(variableAccessData));
else
dataLog("%sr%u(%s)", hasPrinted ? ", " : "", operand, nameOfVariableAccessData(variableAccessData));
hasPrinted = true;
}
if (node.hasConstantBuffer()) {
if (hasPrinted)
dataLog(", ");
dataLog("%u:[", node.startConstant());
for (unsigned i = 0; i < node.numConstants(); ++i) {
if (i)
dataLog(", ");
dataLog("%s", m_codeBlock->constantBuffer(node.startConstant())[i].description());
}
dataLog("]");
hasPrinted = true;
}
if (op == JSConstant) {
dataLog("%s$%u", hasPrinted ? ", " : "", node.constantNumber());
JSValue value = valueOfJSConstant(nodeIndex);
dataLog(" = %s", value.description());
hasPrinted = true;
}
if (op == WeakJSConstant) {
dataLog("%s%p", hasPrinted ? ", " : "", node.weakConstant());
hasPrinted = true;
}
if (node.isBranch() || node.isJump()) {
dataLog("%sT:#%u", hasPrinted ? ", " : "", node.takenBlockIndex());
hasPrinted = true;
}
if (node.isBranch()) {
dataLog("%sF:#%u", hasPrinted ? ", " : "", node.notTakenBlockIndex());
hasPrinted = true;
}
dataLog("%sbc#%u", hasPrinted ? ", " : "", node.codeOrigin.bytecodeIndex);
hasPrinted = true;
(void)hasPrinted;
dataLog(")");
if (!skipped) {
if (node.hasVariableAccessData())
dataLog(" predicting %s%s", speculationToString(node.variableAccessData()->prediction()), node.variableAccessData()->shouldUseDoubleFormat() ? ", forcing double" : "");
else if (node.hasHeapPrediction())
dataLog(" predicting %s", speculationToString(node.getHeapPrediction()));
}
dataLog("\n");
}
