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 }