void BinaryEdit::addLibraryPrereq(std::string libname) {
Symtab *symObj = mobj->parse_img()->getObject();
symObj->addLibraryPrereq(libname);
}
bool BinaryEdit::writeFile(const std::string &newFileName)
{
// Step 1: changes.
inst_printf(" writing %s ... \n", newFileName.c_str());
Symtab *symObj = mobj->parse_img()->getObject();
// link to the runtime library if tramp guards are currently enabled
if ( !symObj->isStaticBinary() && !BPatch::bpatch->isTrampRecursive() ) {
assert(!runtime_lib.empty());
symObj->addLibraryPrereq((*runtime_lib.begin())->fileName());
}
if( symObj->isStaticBinary() && isDirty() ) {
if( !doStaticBinarySpecialCases() ) {
cerr << "Failed to write file " << newFileName << ": static binary handler failed" << endl;
return false;
}
}
delayRelocation_ = false;
relocate();
vector<Region*> oldSegs;
symObj->getAllRegions(oldSegs);
//Write any traps to the mutatee
if (canUseTraps()) {
trapMapping.shouldBlockFlushes(false);
trapMapping.flush();
}
// Now, we need to copy in the memory of the new segments
for (unsigned i = 0; i < oldSegs.size(); i++) {
codeRange *segRange = NULL;
if (!memoryTracker_->find(oldSegs[i]->getMemOffset(), segRange)) {
#if 0
// Looks like BSS
if (newSegs[i].name == ".bss")
#endif
continue;
//inst_printf (" segment name: %s\n", newSegs[i].name.c_str());
//assert(0);
}
//inst_printf(" ==> memtracker: Copying to 0x%lx from 0x%lx\n",
//newSegs[i].loadaddr, segRange->get_local_ptr());
memoryTracker* mt = dynamic_cast<memoryTracker*>(segRange);
assert(mt);
if(mt->dirty) {
oldSegs[i]->setPtrToRawData(segRange->get_local_ptr(), oldSegs[i]->getMemSize());
}
//newSegs[i].data = segRange->get_local_ptr();
}
// Okay, that does it for the old stuff.
// Now we need to get the new stuff. That's all the allocated memory. First, big
// buffer to hold it.
void *newSectionPtr = malloc(highWaterMark_ - lowWaterMark_);
pdvector<codeRange *> writes;
memoryTracker_->elements(writes);
for (unsigned i = 0; i < writes.size(); i++) {
assert(newSectionPtr);
memoryTracker *tracker = dynamic_cast<memoryTracker *>(writes[i]);
assert(tracker);
//inst_printf("memory tracker: 0x%lx load=0x%lx size=%d %s\n",
//tracker->get_local_ptr(), tracker->get_address(), tracker->get_size(),
//tracker->alloced ? "[A]" : "");
if (!tracker->alloced) continue;
// Copy whatever is in there into the big buffer, at the appropriate address
assert(tracker->get_address() >= lowWaterMark_);
Address offset = tracker->get_address() - lowWaterMark_;
assert((offset + tracker->get_size()) < highWaterMark_);
void *ptr = (void *)(offset + (Address)newSectionPtr);
memcpy(ptr, tracker->get_local_ptr(), tracker->get_size());
}
// Righto. Now, that includes the old binary - by design -
// so skip it and see what we're talking about size-wise. Which should
// be less than the highWaterMark, so we can double-check.
// Next, make a new section. We have the following parameters:
// Offset vaddr: we get this from Symtab - "first free address with sufficient space"
// std::string name: without reflection, ".dyninstInst"
// unsigned long flags: these are a SymtabAPI abstraction. We're going with text|data because
// we might have both.
// bool loadable: heck yeah...
Region *newSec = NULL;
symObj->findRegion(newSec, ".dyninstInst");
if (newSec) {
// We're re-instrumenting - will fail for now
fprintf(stderr, "ERROR: unable to open/reinstrument previously instrumented binary %s!\n", newFileName.c_str());
return false;
}
symObj->addRegion(lowWaterMark_,
newSectionPtr,
highWaterMark_ - lowWaterMark_,
".dyninstInst",
Region::RT_TEXTDATA,
true);
fprintf(stderr,"Write lowWater : %lx, highWater : %lx\n",lowWaterMark_,highWaterMark_);
symObj->findRegion(newSec, ".dyninstInst");
assert(newSec);
if (mobj == getAOut()) {
// Add dynamic symbol relocations
for (unsigned i=0; i < dependentRelocations.size(); i++) {
Address to = dependentRelocations[i]->getAddress();
Symbol *referring = dependentRelocations[i]->getReferring();
/*
if (!symObj->isStaticBinary() && !symObj->hasReldyn() && !symObj->hasReladyn()) {
Address addr = referring->getOffset();
bool result = writeDataSpace((void *) to, getAddressWidth(), &addr);
assert(result);
continue;
}
*/
// Create the relocationEntry
relocationEntry localRel(to, referring->getMangledName(), referring,
relocationEntry::getGlobalRelType(getAddressWidth(), referring));
/*
if( mobj->isSharedLib() ) {
localRel.setRelAddr(to - mobj->imageOffset());
}
*/
symObj->addExternalSymbolReference(referring, newSec, localRel);
/*
newSymbol = new Symbol(referring->getName(),
Symbol::ST_FUNCTION,
Symbol::SL_GLOBAL,
Symbol::SV_DEFAULT,
(Address)0,
symObj->getDefaultModule(),
NULL,
8,
true,
false);
symObj->addSymbol(newSymbol, referring);
if (!symObj->hasReldyn() && symObj->hasReladyn()) {
newSec->addRelocationEntry(to, newSymbol, relocationEntry::dynrel, Region::RT_RELA);
} else {
newSec->addRelocationEntry(to, newSymbol, relocationEntry::dynrel);
}
*/
}
}
pdvector<Symbol *> newSyms;
buildDyninstSymbols(newSyms, newSec, symObj->getOrCreateModule("dyninstInst",
lowWaterMark_));
for (unsigned i = 0; i < newSyms.size(); i++) {
symObj->addSymbol(newSyms[i]);
}
// Okay, now...
// Hand textSection and newSection to DynSymtab.
// First, textSection.
// From the SymtabAPI documentation: we have the following methods we want to use.
// Symtab::addSection(Offset vaddr, void *data, unsigned int dataSize, std::string name,
// unsigned long flags, bool loadable)
// Symtab::updateCode(void *buffer, unsigned size)
// Symtab::emit(std::string filename)
// First, text
assert(symObj);
// And now we generate the new binary
//if (!symObj->emit(newFileName.c_str())) {
if (!symObj->emit(newFileName.c_str())) {
SymtabError lastError = Symtab::getLastSymtabError();
showErrorCallback(109, Symtab::printError(lastError));
return false;
}
return true;
}