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;
}
// 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
}
