void DataRewriter::organizeNewBss(Region* reg, unsigned char magic) {
/**
*
*/
fprintf(stderr, "BSS region starts at %p\n", reg->getRegionAddr());
VarList globals = filterVariables(reg);
unsigned int dataSize = 0;
unsigned int dataBase = 0;
unsigned int dataOffset = 0;
unsigned int rawIndex = 0;
unsigned int rawValue = 0;
unsigned int newRawIndex = 0;
dataSize = reg->getRegionSize();
dataBase = newDataBase + newDataSize;
fprintf(stderr, "BSS base = %p\n", (void*) dataBase);
unsigned int newBssSize = sizeof(unsigned char) * dataSize;
oldRawBss = (unsigned char*) reg->getPtrToRawData();
newRawBss = (unsigned char*) malloc (newBssSize);
memcpy(newRawBss, oldRawBss, dataSize);
for (int i = 0; i < globals.size(); i++) {
dataOffset = globals[i]->getOffset();
rawIndex = dataOffset - dataBase;
// Update the relocated address mapping
newLocs[dataOffset] = dataBase + newRawIndex;
newRawIndex += globals[i]->getSize();
}
for (AddrMapping::const_iterator iter = newLocs.begin();
iter != newLocs.end();
++iter) {
fprintf(stderr, "%p -> %p\n", iter->first, iter->second);
}
// Causes a segfault in the mutated binary
//
//if (!reg->setPtrToRawData(newRawBss, newDataSize)) {
// fprintf(stderr, "Unable to assign new data section.\n");
// exit(EXIT_FAILURE);
//}
}
void DataRewriter::organizeNewData(Region* reg, unsigned char magic) {
/**
*
*/
VarList globals = filterVariables(reg);
unsigned int dataSize = 0;
unsigned int dataBase = 0;
unsigned int dataOffset = 0;
unsigned int rawIndex = 0;
unsigned int rawValue = 0;
unsigned int newRawIndex = 0;
dataSize = reg->getRegionSize();
dataBase = reg->getRegionAddr();
newDataBase = dataBase;
newDataSize = sizeof(unsigned char) * dataSize * 2;
oldRaw = (unsigned char*) reg->getPtrToRawData();
newRaw = (unsigned char*) malloc (newDataSize);
// The dso_handle bullshit
memcpy(newRaw, oldRaw, 4);
memset(newRaw + 4, magic, 4);
newRawIndex += 8;
// Pad the new data section with an extra 4 bytes between all 4 byte values.
for (int i = 0; i < globals.size(); i++) {
dataOffset = globals[i]->getOffset();
rawIndex = dataOffset - dataBase;
memcpy(newRaw + newRawIndex, oldRaw + rawIndex, 4);
// Sanity checks, write magic values into padding
memset(newRaw + newRawIndex + 4, magic, 4);
// Update the relocated address mapping
newLocs[dataOffset] = dataBase + newRawIndex;
newRawIndex += 8;
}
fprintf(stderr, "NEW DATA: %p through %p\n", newDataBase, newDataBase + newDataSize);
if (!reg->setPtrToRawData(newRaw, newDataSize)) {
fprintf(stderr, "Unable to assign new data section.\n");
exit(EXIT_FAILURE);
}
}
// Count the load and store bytes for the
// I think we can only return expressions to calculate the value, not the actual values,
// since sizeof(type) is machine dependent
// Consider both scalar and array accesses by default. Consider both floating point and integer types by default.
// return a pair of expressions:
// load_byte_exp, and
// store_byte_exp
// Algorithm:
// 1. Call side effect analysis to find read/write variables, some reference may trigger both read and write accesses
// Accesses to the same array/scalar variable are grouped into one read (or write) access
// e.g. array[i][j], array[i][j+1], array[i][j-1], etc are counted a single access
// 2. Group accesses based on the types (same type? increment the same counter to shorten expression length)
// 4. Iterate on the results to generate expression like 2*sizeof(float) + 5* sizeof(double)
// As an approximate, we use simple analysis here assuming no function calls.
std::pair <SgExpression*, SgExpression*> CountLoadStoreBytes (SgLocatedNode* input, bool includeScalars /* = true */, bool includeIntType /* = true */)
{
std::pair <SgExpression*, SgExpression*> result;
assert (input != NULL);
// the input is essentially the loop body, a scope statement
SgScopeStatement* scope = isSgScopeStatement(input);
// We need to record the associated loop info.
//SgStatement* loop= NULL;
SgForStatement* forloop = isSgForStatement(scope->get_scope());
SgFortranDo* doloop = isSgFortranDo(scope->get_scope());
if (forloop)
{
//loop = forloop;
}
else if (doloop)
{
//loop = doloop;
}
else
{
cerr<<"Error in CountLoadStoreBytes (): input is not loop body type:"<< input->class_name()<<endl;
assert(false);
}
//Plan A: use and extend Qing's side effect analysis
std::set<SgInitializedName*> readVars;
std::set<SgInitializedName*> writeVars;
bool success = SageInterface::collectReadWriteVariables (isSgStatement(input), readVars, writeVars);
if (success!= true)
{
cout<<"Warning: CountLoadStoreBytes(): failed to collect load/store, mostly due to existence of function calls inside of loop body @ "<<input->get_file_info()->get_line()<<endl;
}
std::set<SgInitializedName*>::iterator it;
if (debug)
cout<<"debug: found read variables (SgInitializedName) count = "<<readVars.size()<<endl;
for (it=readVars.begin(); it!=readVars.end(); it++)
{
SgInitializedName* iname = (*it);
if (debug)
cout<<scalar_or_array (iname->get_type()) <<" "<<iname->get_name()<<"@"<<iname->get_file_info()->get_line()<<endl;
}
if (!includeScalars )
readVars = filterVariables (readVars);
if (debug)
cout<<"debug: found write variables (SgInitializedName) count = "<<writeVars.size()<<endl;
for (it=writeVars.begin(); it!=writeVars.end(); it++)
{
SgInitializedName* iname = (*it);
if (debug)
cout<<scalar_or_array(iname->get_type()) <<" "<<iname->get_name()<<"@"<<iname->get_file_info()->get_line()<<endl;
}
if (!includeScalars )
writeVars = filterVariables (writeVars);
result.first = calculateBytes (readVars, scope, true);
result.second = calculateBytes (writeVars, scope, false);
return result;
}