void FunctionCounter::instrument(){ uint32_t temp32; // the number functions in the code uint64_t counterArrayEntries = reserveDataOffset(sizeof(uint32_t)); temp32 = getNumberOfExposedFunctions(); initializeReservedData(getInstDataAddress() + counterArrayEntries, sizeof(uint32_t), &temp32); // an array of counters. note that everything is passed by reference uint64_t counterArray = reserveDataOffset(getNumberOfExposedFunctions() * sizeof(uint32_t)); temp32 = 0; for (uint32_t i = 0; i < getNumberOfExposedFunctions(); i++){ initializeReservedData(getInstDataAddress() + counterArray + i*sizeof(uint32_t), sizeof(uint32_t), &temp32); } // the names of all the functions uint64_t funcNameArray = reserveDataOffset(getNumberOfExposedFunctions() * sizeof(char*)); exitFunc->addArgument(counterArrayEntries); exitFunc->addArgument(counterArray); exitFunc->addArgument(funcNameArray); InstrumentationPoint* p = addInstrumentationPoint(getProgramExitBlock(), exitFunc, InstrumentationMode_tramp); ASSERT(p); if (!p->getInstBaseAddress()){ PRINT_ERROR("Cannot find an instrumentation point at the exit function"); } for (uint32_t i = 0; i < getNumberOfExposedFunctions(); i++){ Function* f = getExposedFunction(i); uint64_t funcname = reserveDataOffset(strlen(f->getName()) + 1); uint64_t funcnameAddr = getInstDataAddress() + funcname; initializeReservedData(getInstDataAddress() + funcNameArray + i*sizeof(char*), sizeof(char*), &funcnameAddr); initializeReservedData(getInstDataAddress() + funcname, strlen(f->getName()) + 1, (void*)f->getName()); InstrumentationSnippet* snip = new InstrumentationSnippet(); uint64_t counterOffset = counterArray + (i * sizeof(uint32_t)); // snippet contents, in this case just increment a counter if (is64Bit()){ snip->addSnippetInstruction(X86InstructionFactory64::emitAddImmByteToMem(1, getInstDataAddress() + counterOffset)); } else { snip->addSnippetInstruction(X86InstructionFactory32::emitAddImmByteToMem(1, getInstDataAddress() + counterOffset)); } // do not generate control instructions to get back to the application, this is done for // the snippet automatically during code generation // register the snippet we just created addInstrumentationSnippet(snip); // register an instrumentation point at the function that uses this snippet InstrumentationPoint* p = addInstrumentationPoint(f, snip, InstrumentationMode_inline, FlagsProtectionMethod_light); } }
void CallReplace::instrument(){ uint32_t temp32; uint64_t temp64; LineInfoFinder* lineInfoFinder = NULL; if (hasLineInformation()){ lineInfoFinder = getLineInfoFinder(); } InstrumentationPoint* p = addInstrumentationPoint(getProgramEntryBlock(), programEntry, InstrumentationMode_tramp, FlagsProtectionMethod_full, InstLocation_prior); ASSERT(p); if (!p->getInstBaseAddress()){ PRINT_ERROR("Cannot find an instrumentation point at the exit function"); } p = addInstrumentationPoint(getProgramExitBlock(), programExit, InstrumentationMode_tramp, FlagsProtectionMethod_full, InstLocation_prior); ASSERT(p); if (!p->getInstBaseAddress()){ PRINT_ERROR("Cannot find an instrumentation point at the exit function"); } uint64_t siteIndex = reserveDataOffset(sizeof(uint32_t)); programEntry->addArgument(siteIndex); Vector<X86Instruction*> myInstPoints; Vector<uint32_t> myInstList; Vector<LineInfo*> myLineInfos; for (uint32_t i = 0; i < getNumberOfExposedInstructions(); i++){ X86Instruction* instruction = getExposedInstruction(i); ASSERT(instruction->getContainer()->isFunction()); Function* function = (Function*)instruction->getContainer(); if (instruction->isFunctionCall()){ Symbol* functionSymbol = getElfFile()->lookupFunctionSymbol(instruction->getTargetAddress()); if (functionSymbol){ //PRINT_INFOR("looking for function %s", functionSymbol->getSymbolName()); uint32_t funcIdx = searchFileList(functionList, functionSymbol->getSymbolName()); if (funcIdx < (*functionList).size()){ BasicBlock* bb = function->getBasicBlockAtAddress(instruction->getBaseAddress()); ASSERT(bb->containsCallToRange(0,-1)); ASSERT(instruction->getSizeInBytes() == Size__uncond_jump); myInstPoints.append(instruction); myInstList.append(funcIdx); LineInfo* li = NULL; if (lineInfoFinder){ li = lineInfoFinder->lookupLineInfo(bb); } myLineInfos.append(li); } } } } ASSERT(myInstPoints.size() == myInstList.size()); ASSERT(myLineInfos.size() == myInstList.size()); uint64_t fileNames = reserveDataOffset(sizeof(char*) * myInstList.size()); uint64_t lineNumbers = reserveDataOffset(sizeof(uint32_t) * myInstList.size()); for (uint32_t i = 0; i < myInstList.size(); i++){ uint32_t line = 0; char* fname = NOSTRING; if (myLineInfos[i]){ line = myLineInfos[i]->GET(lr_line); fname = myLineInfos[i]->getFileName(); } uint64_t filenameaddr = getInstDataAddress() + reserveDataOffset(strlen(fname) + 1); initializeReservedData(getInstDataAddress() + fileNames + i*sizeof(char*), sizeof(char*), &filenameaddr); initializeReservedData(filenameaddr, strlen(fname), fname); initializeReservedData(getInstDataAddress() + lineNumbers + i*sizeof(uint32_t), sizeof(uint32_t), &line); } programEntry->addArgument(fileNames); programEntry->addArgument(lineNumbers); for (uint32_t i = 0; i < myInstPoints.size(); i++){ PRINT_INFOR("(site %d) %#llx: replacing call %s -> %s in function %s", i, myInstPoints[i]->getBaseAddress(), getFunctionName(myInstList[i]), getWrapperName(myInstList[i]), myInstPoints[i]->getContainer()->getName()); InstrumentationPoint* pt = addInstrumentationPoint(myInstPoints[i], functionWrappers[myInstList[i]], InstrumentationMode_tramp, FlagsProtectionMethod_none, InstLocation_replace); if (getElfFile()->is64Bit()){ pt->addPrecursorInstruction(X86InstructionFactory64::emitMoveRegToMem(X86_REG_CX, getInstDataAddress() + getRegStorageOffset())); pt->addPrecursorInstruction(X86InstructionFactory64::emitMoveImmToReg(i, X86_REG_CX)); pt->addPrecursorInstruction(X86InstructionFactory64::emitMoveRegToMem(X86_REG_CX, getInstDataAddress() + siteIndex)); pt->addPrecursorInstruction(X86InstructionFactory64::emitMoveMemToReg(getInstDataAddress() + getRegStorageOffset(), X86_REG_CX, true)); } else { pt->addPrecursorInstruction(X86InstructionFactory32::emitMoveRegToMem(X86_REG_CX, getInstDataAddress() + getRegStorageOffset())); pt->addPrecursorInstruction(X86InstructionFactory32::emitMoveImmToReg(i, X86_REG_CX)); pt->addPrecursorInstruction(X86InstructionFactory32::emitMoveRegToMem(X86_REG_CX, getInstDataAddress() + siteIndex)); pt->addPrecursorInstruction(X86InstructionFactory32::emitMoveMemToReg(getInstDataAddress() + getRegStorageOffset(), X86_REG_CX)); } } }
void BasicBlockCounter::instrument() { InstrumentationTool::instrument(); ASSERT(currentPhase == ElfInstPhase_user_reserve && "Instrumentation phase order must be observed"); uint32_t temp32; LineInfoFinder* lineInfoFinder = NULL; if (hasLineInformation()){ lineInfoFinder = getLineInfoFinder(); } uint64_t lineArray = reserveDataOffset(getNumberOfExposedBasicBlocks() * sizeof(uint32_t)); uint64_t fileNameArray = reserveDataOffset(getNumberOfExposedBasicBlocks() * sizeof(char*)); uint64_t funcNameArray = reserveDataOffset(getNumberOfExposedBasicBlocks() * sizeof(char*)); uint64_t hashCodeArray = reserveDataOffset(getNumberOfExposedBasicBlocks() * sizeof(uint64_t)); uint64_t appName = reserveDataOffset((strlen(getApplicationName()) + 1) * sizeof(char)); initializeReservedData(getInstDataAddress() + appName, strlen(getApplicationName()) + 1, getApplicationName()); uint64_t instExt = reserveDataOffset((strlen(getInstSuffix()) + 1) * sizeof(char)); initializeReservedData(getInstDataAddress() + instExt, strlen(getInstSuffix()) + 1, getInstSuffix()); // the number blocks in the code uint64_t counterArrayEntries = reserveDataOffset(sizeof(uint32_t)); // an array of counters. note that everything is passed by reference uint64_t counterArray = reserveDataOffset(getNumberOfExposedBasicBlocks() * sizeof(uint32_t)); exitFunc->addArgument(counterArray); exitFunc->addArgument(appName); exitFunc->addArgument(instExt); InstrumentationPoint* p = addInstrumentationPoint(getProgramExitBlock(), exitFunc, InstrumentationMode_tramp); if (!p->getInstBaseAddress()){ PRINT_ERROR("Cannot find an instrumentation point at the exit function"); } temp32 = 0; for (uint32_t i = 0; i < getNumberOfExposedBasicBlocks(); i++){ initializeReservedData(getInstDataAddress() + counterArray + i*sizeof(uint32_t), sizeof(uint32_t), &temp32); } // the number of inst points entryFunc->addArgument(counterArrayEntries); temp32 = getNumberOfExposedBasicBlocks(); initializeReservedData(getInstDataAddress() + counterArrayEntries, sizeof(uint32_t), &temp32); // an array for line numbers entryFunc->addArgument(lineArray); // an array for file name pointers entryFunc->addArgument(fileNameArray); // an array for function name pointers entryFunc->addArgument(funcNameArray); // an array for hashcodes entryFunc->addArgument(hashCodeArray); p = addInstrumentationPoint(getProgramEntryBlock(), entryFunc, InstrumentationMode_tramp, FlagsProtectionMethod_full, InstLocation_prior); p->setPriority(InstPriority_userinit); if (!p->getInstBaseAddress()){ PRINT_ERROR("Cannot find an instrumentation point at the entry block"); } uint64_t noDataAddr = getInstDataAddress() + reserveDataOffset(strlen(NOSTRING) + 1); char* nostring = new char[strlen(NOSTRING) + 1]; sprintf(nostring, "%s\0", NOSTRING); initializeReservedData(noDataAddr, strlen(NOSTRING) + 1, nostring); PRINT_DEBUG_MEMTRACK("There are %d instrumentation points", getNumberOfExposedBasicBlocks()); Vector<BasicBlock*>* allBlocks = new Vector<BasicBlock*>(); Vector<LineInfo*>* allLineInfos = new Vector<LineInfo*>(); uint32_t noProtPoints = 0; uint32_t complexSelection = 0; for (uint32_t i = 0; i < getNumberOfExposedBasicBlocks(); i++){ BasicBlock* bb = getExposedBasicBlock(i); LineInfo* li = NULL; if (lineInfoFinder){ li = lineInfoFinder->lookupLineInfo(bb); } Function* f = bb->getFunction(); (*allBlocks).append(bb); (*allLineInfos).append(li); if (i % 1000 == 0){ PRINT_DEBUG_MEMTRACK("inst point %d", i); PRINT_MEMTRACK_STATS(__LINE__, __FILE__, __FUNCTION__); } if (li){ uint32_t line = li->GET(lr_line); initializeReservedData(getInstDataAddress() + lineArray + sizeof(uint32_t)*i, sizeof(uint32_t), &line); uint64_t filename = reserveDataOffset(strlen(li->getFileName()) + 1); uint64_t filenameAddr = getInstDataAddress() + filename; initializeReservedData(getInstDataAddress() + fileNameArray + i*sizeof(char*), sizeof(char*), &filenameAddr); initializeReservedData(getInstDataAddress() + filename, strlen(li->getFileName()) + 1, (void*)li->getFileName()); } else { temp32 = 0; initializeReservedData(getInstDataAddress() + lineArray + sizeof(uint32_t)*i, sizeof(uint32_t), &temp32); initializeReservedData(getInstDataAddress() + fileNameArray + i*sizeof(char*), sizeof(char*), &noDataAddr); } uint64_t funcname = reserveDataOffset(strlen(f->getName()) + 1); uint64_t funcnameAddr = getInstDataAddress() + funcname; initializeReservedData(getInstDataAddress() + funcNameArray + i*sizeof(char*), sizeof(char*), &funcnameAddr); initializeReservedData(getInstDataAddress() + funcname, strlen(f->getName()) + 1, (void*)f->getName()); uint64_t hashValue = bb->getHashCode().getValue(); initializeReservedData(getInstDataAddress() + hashCodeArray + i*sizeof(uint64_t), sizeof(uint64_t), &hashValue); InstrumentationSnippet* snip = new InstrumentationSnippet(); uint64_t counterOffset = counterArray + (i * sizeof(uint32_t)); // snippet contents, in this case just increment a counter if (is64Bit()){ snip->addSnippetInstruction(X86InstructionFactory64::emitAddImmByteToMem(1, getInstDataAddress() + counterOffset)); } else { snip->addSnippetInstruction(X86InstructionFactory32::emitAddImmByteToMem(1, getInstDataAddress() + counterOffset)); } // do not generate control instructions to get back to the application, this is done for // the snippet automatically during code generation // register the snippet we just created addInstrumentationSnippet(snip); // register an instrumentation point at the function that uses this snippet FlagsProtectionMethods prot = FlagsProtectionMethod_light; #ifndef NO_REG_ANALYSIS if (bb->getLeader()->allFlagsDeadIn()){ prot = FlagsProtectionMethod_none; noProtPoints++; } for (uint32_t j = 0; j < bb->getNumberOfInstructions(); j++){ if (bb->getInstruction(j)->allFlagsDeadIn() || bb->getInstruction(j)->allFlagsDeadOut()){ complexSelection++; break; } } #endif InstrumentationPoint* p = addInstrumentationPoint(bb, snip, InstrumentationMode_inline, prot); } PRINT_MEMTRACK_STATS(__LINE__, __FILE__, __FUNCTION__); #ifdef NO_REG_ANALYSIS PRINT_WARN(10, "Warning: register analysis disabled"); #endif PRINT_INFOR("Excluding flags protection for %d/%d instrumentation points", noProtPoints, getNumberOfExposedBasicBlocks()); //PRINT_INFOR("complex inst point selection: %d/%d instrumentation points", complexSelection, getNumberOfExposedBasicBlocks()); printStaticFile(allBlocks, allLineInfos); delete[] nostring; delete allBlocks; delete allLineInfos; ASSERT(currentPhase == ElfInstPhase_user_reserve && "Instrumentation phase order must be observed"); }