void MachOLinkingContext::configure(HeaderFileType type, Arch arch, OS os,
uint32_t minOSVersion) {
_outputMachOType = type;
_arch = arch;
_os = os;
_osMinVersion = minOSVersion;
switch (_outputMachOType) {
case llvm::MachO::MH_EXECUTE:
// If targeting newer OS, use _main
if (minOS("10.8", "6.0")) {
_entrySymbolName = "_main";
} else {
// If targeting older OS, use start (in crt1.o)
_entrySymbolName = "start";
}
// __PAGEZERO defaults to 4GB on 64-bit (except for PP64 which lld does not
// support) and 4KB on 32-bit.
if (is64Bit(_arch)) {
_pageZeroSize = 0x100000000;
} else {
_pageZeroSize = 0x1000;
}
// Make PIE by default when targetting newer OSs.
switch (os) {
case OS::macOSX:
if (minOSVersion >= 0x000A0700) // MacOSX 10.7
_pie = true;
break;
case OS::iOS:
if (minOSVersion >= 0x00040300) // iOS 4.3
_pie = true;
break;
case OS::iOS_simulator:
_pie = true;
break;
case OS::unknown:
break;
}
break;
case llvm::MachO::MH_DYLIB:
_globalsAreDeadStripRoots = true;
break;
case llvm::MachO::MH_BUNDLE:
break;
case llvm::MachO::MH_OBJECT:
_printRemainingUndefines = false;
_allowRemainingUndefines = true;
default:
break;
}
// Set default segment page sizes based on arch.
if (arch == arch_arm64)
_pageSize = 4*4096;
}
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);
}
}
bool CCallSpecial::isValid(Inst& inst)
{
if (inst.args.size() < argArgOffset)
return false;
for (unsigned i = 0; i < numCalleeArgs; ++i) {
Arg& arg = inst.args[i + calleeArgOffset];
if (!arg.isGP())
return false;
switch (arg.kind()) {
case Arg::Imm:
if (is32Bit())
break;
return false;
case Arg::Imm64:
if (is64Bit())
break;
return false;
case Arg::Tmp:
case Arg::Addr:
case Arg::Stack:
case Arg::CallArg:
break;
default:
return false;
}
}
// Return args need to be exact.
if (inst.args[returnGPArgOffset + 0] != Tmp(GPRInfo::returnValueGPR))
return false;
if (inst.args[returnGPArgOffset + 1] != Tmp(GPRInfo::returnValueGPR2))
return false;
if (inst.args[returnFPArgOffset + 0] != Tmp(FPRInfo::returnValueFPR))
return false;
for (unsigned i = argArgOffset; i < inst.args.size(); ++i) {
if (!inst.args[i].isReg())
return false;
if (inst.args[i] == Tmp(scratchRegister))
return false;
}
return true;
}
bool MachOLinkingContext::is64Bit() const {
return is64Bit(_arch);
}
/* Main entry point of elf-parser */
int32_t main(int32_t argc, char *argv[])
{
int32_t fd;
Elf32_Ehdr eh; /* elf-header is fixed size */
if(argc!=2) {
printf("Usage: elf-parser <ELF-file>\n");
return 0;
}
fd = open(argv[1], O_RDONLY|O_SYNC);
if(fd<0) {
printf("Error %d Unable to open %s\n", fd, argv[1]);
return 0;
}
/* ELF header : at start of file */
read_elf_header(fd, &eh);
if(!is_ELF(eh)) {
return 0;
}
if(is64Bit(eh)){
Elf64_Ehdr eh64; /* elf-header is fixed size */
Elf64_Shdr* sh_tbl; /* section-header table is variable size */
read_elf_header64(fd, &eh64);
print_elf_header64(eh64);
/* Section header table : */
sh_tbl = malloc(eh64.e_shentsize * eh64.e_shnum);
if(!sh_tbl) {
printf("Failed to allocate %d bytes\n",
(eh64.e_shentsize * eh64.e_shnum));
}
read_section_header_table64(fd, eh64, sh_tbl);
print_section_headers64(fd, eh64, sh_tbl);
/* Symbol tables :
* sh_tbl[i].sh_type
* |`- SHT_SYMTAB
* `- SHT_DYNSYM
*/
print_symbols64(fd, eh64, sh_tbl);
/* Save .text section as text.S
*/
save_text_section64(fd, eh64, sh_tbl);
/* Disassemble .text section
* Logs asm instructions to stdout
* Currently supports ARMv7
*/
disassemble64(fd, eh64, sh_tbl);
} else{
Elf32_Shdr* sh_tbl; /* section-header table is variable size */
print_elf_header(eh);
/* Section header table : */
sh_tbl = malloc(eh.e_shentsize * eh.e_shnum);
if(!sh_tbl) {
printf("Failed to allocate %d bytes\n",
(eh.e_shentsize * eh.e_shnum));
}
read_section_header_table(fd, eh, sh_tbl);
print_section_headers(fd, eh, sh_tbl);
/* Symbol tables :
* sh_tbl[i].sh_type
* |`- SHT_SYMTAB
* `- SHT_DYNSYM
*/
print_symbols(fd, eh, sh_tbl);
/* Save .text section as text.S
*/
save_text_section(fd, eh, sh_tbl);
/* Disassemble .text section
* Logs asm instructions to stdout
* Currently supports ARMv7
*/
disassemble(fd, eh, sh_tbl);
}
return 0;
}
bool BranchInfo::is32Bit()
{
//default to 32 bit
bool res = HasAnyFlags(m_uiFlags, BF_WINDOWS_32|BF_LINUX_32) || isMacOsX() || !is64Bit();
return res;
}
uint64_t PECOFFLinkingContext::getBaseAddress() const {
if (_baseAddress == invalidBaseAddress)
return is64Bit() ? pe32PlusDefaultBaseAddress : pe32DefaultBaseAddress;
return _baseAddress;
}
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");
}