uint64_t
RoseBin_DataFlowAbstract::getValueInMemoryRefExp(SgAsmExpression* expr) {
uint64_t res = 0;
if (isSgAsmValueExpression(expr)) {
res = getValueInExpression(isSgAsmValueExpression(expr));
} else if (isSgAsmx86RegisterReferenceExpression(expr)) {
SgAsmx86RegisterReferenceExpression* refexp = isSgAsmx86RegisterReferenceExpression(expr);
std::pair<X86RegisterClass, int> code;
if (refexp) {
code = std::make_pair((X86RegisterClass)refexp->get_descriptor().get_major(), refexp->get_descriptor().get_minor());
// we have to add up this value, currently we assign 5000 to the register
// fixme later
if (code.first == x86_regclass_gpr && code.second == x86_gpr_bp)
res = 0;
else
res = 5000;
}
} else if (isSgAsmBinaryAdd(expr)) {
// add up the left and right side
SgAsmBinaryAdd* binadd = isSgAsmBinaryAdd(expr);
SgAsmExpression* left = binadd->get_lhs();
SgAsmExpression* right = binadd->get_rhs();
res = getValueInMemoryRefExp(left) + getValueInMemoryRefExp(right);
} else if (isSgAsmBinaryMultiply(expr)) {
// add up the left and right side
SgAsmBinaryMultiply* binadd = isSgAsmBinaryMultiply(expr);
SgAsmExpression* left = binadd->get_lhs();
SgAsmExpression* right = binadd->get_rhs();
res = getValueInMemoryRefExp(left) * getValueInMemoryRefExp(right);
} else {
cerr << " ERROR :: getValueInMemoryRefExp - no such condition specified"
<< expr->class_name() << endl;
}
return res;
}
/* Helper for unparsePowerpcExpression(SgAsmExpression*) */
static std::string unparsePowerpcExpression(SgAsmExpression* expr, const AsmUnparser::LabelMap *labels,
const RegisterDictionary *registers, bool useHex) {
std::string result = "";
if (expr == NULL) return "BOGUS:NULL";
switch (expr->variantT()) {
case V_SgAsmBinaryAdd:
result = unparsePowerpcExpression(isSgAsmBinaryExpression(expr)->get_lhs(), labels, registers, false) + " + " +
unparsePowerpcExpression(isSgAsmBinaryExpression(expr)->get_rhs(), labels, registers, false);
break;
case V_SgAsmMemoryReferenceExpression: {
SgAsmMemoryReferenceExpression* mr = isSgAsmMemoryReferenceExpression(expr);
SgAsmExpression* addr = mr->get_address();
switch (addr->variantT()) {
case V_SgAsmBinaryAdd: {
SgAsmBinaryAdd* a = isSgAsmBinaryAdd(addr);
std::string lhs = unparsePowerpcExpression(a->get_lhs(), labels, registers, false);
if (isSgAsmValueExpression(a->get_rhs())) {
// Sign-extend from 16 bits
SgAsmValueExpression *ve = isSgAsmValueExpression(a->get_rhs());
ASSERT_not_null(ve);
result = boost::lexical_cast<std::string>(
(int64_t)IntegerOps::signExtend<16, 64>(SageInterface::getAsmConstant(ve)));
result += "(" + lhs + ")";
} else {
result = lhs + ", " + unparsePowerpcExpression(a->get_rhs(), labels, registers, false);
}
break;
}
default:
result = "(" + unparsePowerpcExpression(addr, labels, registers, false) + ")";
break;
}
break;
}
case V_SgAsmDirectRegisterExpression: {
SgAsmInstruction *insn = SageInterface::getEnclosingNode<SgAsmInstruction>(expr);
SgAsmDirectRegisterExpression* rr = isSgAsmDirectRegisterExpression(expr);
result = unparsePowerpcRegister(insn, rr->get_descriptor(), registers);
break;
}
case V_SgAsmIntegerValueExpression: {
uint64_t v = isSgAsmIntegerValueExpression(expr)->get_absoluteValue();
if (useHex) {
result = StringUtility::intToHex(v);
} else {
result = StringUtility::numberToString(v);
}
if (expr->get_comment().empty() && labels) {
AsmUnparser::LabelMap::const_iterator li = labels->find(v);
if (li!=labels->end())
result = StringUtility::appendAsmComment(result, li->second);
}
break;
}
default: {
ASSERT_not_reachable("invalid PowerPC expression: " + expr->class_name());
}
}
result = StringUtility::appendAsmComment(result, expr->get_replacement());
result = StringUtility::appendAsmComment(result, expr->get_comment());
return result;
}
