std::string unparseX86Expression(SgAsmExpression *expr, const AsmUnparser::LabelMap *labels,
const RegisterDictionary *registers, bool leaMode) {
std::string result = "";
if (expr == NULL) return "BOGUS:NULL";
switch (expr->variantT()) {
case V_SgAsmBinaryAdd:
result = unparseX86Expression(isSgAsmBinaryExpression(expr)->get_lhs(), labels, registers, false) + " + " +
unparseX86Expression(isSgAsmBinaryExpression(expr)->get_rhs(), labels, registers, false);
break;
case V_SgAsmBinarySubtract:
result = unparseX86Expression(isSgAsmBinaryExpression(expr)->get_lhs(), labels, registers, false) + " - " +
unparseX86Expression(isSgAsmBinaryExpression(expr)->get_rhs(), labels, registers, false);
break;
case V_SgAsmBinaryMultiply:
result = unparseX86Expression(isSgAsmBinaryExpression(expr)->get_lhs(), labels, registers, false) + "*" +
unparseX86Expression(isSgAsmBinaryExpression(expr)->get_rhs(), labels, registers, false);
break;
case V_SgAsmMemoryReferenceExpression: {
SgAsmMemoryReferenceExpression* mr = isSgAsmMemoryReferenceExpression(expr);
if (!leaMode) {
result += x86TypeToPtrName(mr->get_type()) + " " +
(mr->get_segment() ? unparseX86Expression(mr->get_segment(), labels, registers, false) + ":" : "");
}
result += "[" + unparseX86Expression(mr->get_address(), labels, registers, false) + "]";
break;
}
case V_SgAsmDirectRegisterExpression: {
SgAsmInstruction *insn = SageInterface::getEnclosingNode<SgAsmInstruction>(expr);
SgAsmDirectRegisterExpression* rr = isSgAsmDirectRegisterExpression(expr);
result = unparseX86Register(insn, rr->get_descriptor(), registers);
break;
}
case V_SgAsmIndirectRegisterExpression: {
SgAsmInstruction *insn = SageInterface::getEnclosingNode<SgAsmInstruction>(expr);
SgAsmIndirectRegisterExpression* rr = isSgAsmIndirectRegisterExpression(expr);
result = unparseX86Register(insn, rr->get_descriptor(), registers);
if (!result.empty() && '0'==result[result.size()-1])
result = result.substr(0, result.size()-1);
result += "(" + StringUtility::numberToString(rr->get_index()) + ")";
break;
}
case V_SgAsmIntegerValueExpression: {
SgAsmIntegerValueExpression *ival = isSgAsmIntegerValueExpression(expr);
ASSERT_not_null(ival);
uint64_t value = ival->get_absoluteValue(); // not sign extended
// If the value looks like it might be an address, then don't bother showing the decimal form.
if ((32==ival->get_significantBits() || 64==ival->get_significantBits()) &&
value > 0x0000ffff && value < 0xffff0000) {
result = StringUtility::addrToString(value, ival->get_significantBits());
} else {
result = StringUtility::signedToHex2(value, ival->get_significantBits());
}
// Optional label. Prefer a label supplied by the caller's LabelMap, but not for single-byte constants. If
// there's no caller-supplied label, then consider whether the value expression is relative to some other IR node.
if (expr->get_comment().empty()) {
std::string label;
if (label.empty() && ival->get_significantBits()>8)
label =x86ValToLabel(value, labels);
if (label.empty())
label = ival->get_label();
result = StringUtility::appendAsmComment(result, label);
}
break;
}
default: {
ASSERT_not_reachable("invalid x86 expression: " + expr->class_name());
}
}
result = StringUtility::appendAsmComment(result, expr->get_replacement());
result = StringUtility::appendAsmComment(result, expr->get_comment());
return result;
}
std::string unparseX86Expression(SgAsmExpression *expr, const AsmUnparser::LabelMap *labels, bool leaMode) {
std::string result = "";
if (expr == NULL) return "BOGUS:NULL";
switch (expr->variantT()) {
case V_SgAsmBinaryAdd:
result = unparseX86Expression(isSgAsmBinaryExpression(expr)->get_lhs(), labels, false) + " + " +
unparseX86Expression(isSgAsmBinaryExpression(expr)->get_rhs(), labels, false);
break;
case V_SgAsmBinarySubtract:
result = unparseX86Expression(isSgAsmBinaryExpression(expr)->get_lhs(), labels, false) + " - " +
unparseX86Expression(isSgAsmBinaryExpression(expr)->get_rhs(), labels, false);
break;
case V_SgAsmBinaryMultiply:
result = unparseX86Expression(isSgAsmBinaryExpression(expr)->get_lhs(), labels, false) + "*" +
unparseX86Expression(isSgAsmBinaryExpression(expr)->get_rhs(), labels, false);
break;
case V_SgAsmMemoryReferenceExpression: {
SgAsmMemoryReferenceExpression* mr = isSgAsmMemoryReferenceExpression(expr);
if (!leaMode) {
result += x86TypeToPtrName(mr->get_type()) + " PTR " +
(mr->get_segment() ? unparseX86Expression(mr->get_segment(), labels, false) + ":" : "");
}
result += "[" + unparseX86Expression(mr->get_address(), labels, false) + "]";
break;
}
case V_SgAsmx86RegisterReferenceExpression: {
SgAsmx86RegisterReferenceExpression* rr = isSgAsmx86RegisterReferenceExpression(expr);
result = unparseX86Register(rr->get_descriptor());
break;
}
case V_SgAsmByteValueExpression:
case V_SgAsmWordValueExpression:
case V_SgAsmDoubleWordValueExpression:
case V_SgAsmQuadWordValueExpression:
case V_SgAsmIntegerValueExpression: {
SgAsmIntegerValueExpression *ival = isSgAsmIntegerValueExpression(expr);
assert(ival!=NULL);
uint64_t value = ival->get_absolute_value(); // not sign extended
result = StringUtility::addrToString(value, ival->get_significant_bits(), true/*signed*/);
// Optional label. Prefer a label supplied by the caller's LabelMap, but not for single-byte constants. If
// there's no caller-supplied label, then consider whether the value expression is relative to some other IR node.
std::string label;
if (ival->get_significant_bits()>8)
label =x86ValToLabel(value, labels);
if (label.empty())
label = ival->get_label();
if (!label.empty())
result += "<" + label + ">";
break;
}
default: {
std::cerr << "Unhandled expression kind " << expr->class_name() << std::endl;
ROSE_ASSERT (false);
}
}
if (expr->get_replacement() != "") {
result += " <" + expr->get_replacement() + ">";
}
#if 0
if (expr->get_bit_size()>0) {
result += " <@" + StringUtility::numberToString(expr->get_bit_offset()) +
"+" + StringUtility::numberToString(expr->get_bit_size()) + ">";
}
#endif
return result;
}
// Constructor
DataMemberInitializationAttribute::DataMemberInitializationAttribute ( SgAsmInstruction* instruction, SgProject* p )
{
ROSE_ASSERT(instruction != NULL);
printf ("Building a DataMemberInitializationAttribute object for instruction = %s \n",unparseInstructionWithAddress(instruction).c_str());
// Identify the offset and if this is a stack reference or a global reference.
SgAsmMemoryReferenceExpression* memoryReferenceExpression = isSgAsmMemoryReferenceExpression(instruction->get_operandList()->get_operands()[0]);
ROSE_ASSERT(memoryReferenceExpression != NULL);
SgAsmRegisterReferenceExpression* segmentRegister = isSgAsmRegisterReferenceExpression(memoryReferenceExpression->get_segment());
ROSE_ASSERT(segmentRegister != NULL);
#ifdef USE_NEW_ISA_INDEPENDENT_REGISTER_HANDLING
// This is a data member
isStackVariable = (segmentRegister->get_register_number() == SgAsmRegisterReferenceExpression::e_ss);
// This is to test if there is another register being referenced.
bool isGlobalVariable = (segmentRegister->get_register_number() == SgAsmRegisterReferenceExpression::e_ds);
// This should be either a stack or global variable (no other allowed).
ROSE_ASSERT(isStackVariable == true || isGlobalVariable == true);
ROSE_ASSERT(isStackVariable == false || isGlobalVariable == false);
SgAsmBinaryAdd* binaryAdd = isSgAsmBinaryAdd(memoryReferenceExpression->get_address());
if (binaryAdd != NULL)
{
// Case of a non-zero offset into the global scope or the stack frame.
ROSE_ASSERT(binaryAdd->get_rhs() != NULL);
SgAsmValueExpression* offsetExpression = isSgAsmValueExpression(binaryAdd->get_rhs());
ROSE_ASSERT(offsetExpression != NULL);
offset = get_value(offsetExpression);
}
else
{
// Case of zero offset from stack frame (first variable in the stack)
// or a global variable with immediate address.
offset = 0;
if (isGlobalVariable == true)
{
// Handle the case of a global variable.
ROSE_ASSERT(memoryReferenceExpression != NULL);
SgAsmValueExpression* offsetExpression = isSgAsmValueExpression(memoryReferenceExpression->get_address());
if (offsetExpression != NULL)
{
offset = get_value(offsetExpression);
}
#if 0
// ... finish me ...
printf ("... finish me ... offset = %p \n",(void*)offset);
ROSE_ASSERT(false);
#else
printf ("isGlobalVariable == true: offset = %p \n",(void*)offset);
#endif
}
}
SgAsmValueExpression* valueExpression = isSgAsmValueExpression(instruction->get_operandList()->get_operands()[1]);
ROSE_ASSERT(valueExpression != NULL);
value = get_value(valueExpression);
type = valueExpression->get_type();
ROSE_ASSERT(type != NULL);
printf (" isStackVariable = %s \n",isStackVariable ? "true" : "false");
printf (" isGlobalVariable = %s \n",isGlobalVariable ? "true" : "false");
printf (" offset = %zu \n",offset);
printf (" value = %zu = %p \n",value,(void*)value);
printf (" type = %p = %s \n",type,type->class_name().c_str());
#else
// DQ (9/2/2013): This allows us to get the existing code compiled and then move to update the code seperately.
printf ("This code needs to be updated to handle the new register handling (ISA independence) \n");
ROSE_ASSERT(false);
#endif
#if 0
printf ("Exiting as a test... \n");
ROSE_ASSERT(false);
#endif
}
