#include <string.h>
#include <fstream>
#include <vector>
#include <iostream>
#include <elf.h>

using namespace std;

typedef uint8_t U8;
typedef int8_t S8;
typedef uint32_t U32;
typedef int32_t S32;

U8* pBytes;

U32 baseAddress=0;

Elf32_Ehdr *pEhdr=0;
Elf32_Phdr *pPhdr=0;
Elf32_Dyn *pDyn=0;

Elf32_Phdr *pPhdrInterp=0;
Elf32_Phdr *pPhdrLoad=0;
Elf32_Phdr *pPhdrDyn=0;

void ProcessDynamic() {
	Elf32_Dyn* pD=pDyn;

	Elf32_Dyn newDyn[32];
	U32 i=0;
	
	newDyn[i].d_tag=DT_DEBUG;
	newDyn[i].d_un.d_val=0;
	i++;
		
	while(pD->d_tag!=DT_NULL) {
		switch(pD->d_tag) {
			case DT_NEEDED:
			case DT_STRTAB:
			//case DT_SYMTAB:
				newDyn[i].d_tag=pD->d_tag;
				newDyn[i].d_un.d_val=pD->d_un.d_val;
				i++;
				break;	
		}	
		pD++;
	}	

	newDyn[i].d_tag=DT_SYMTAB;
	newDyn[i].d_un.d_val=0;
	i++;
	
	newDyn[i].d_tag=0;
	newDyn[i].d_un.d_val=0;
	i++;
	
	//last 15 bytes of dynamic are now 0 and so can reside in bss
	
	U32 newDynSize=i*sizeof(Elf32_Dyn);
	
	memcpy(pDyn, newDyn, newDynSize);
	
	S32 delta=pPhdrDyn->p_filesz-newDynSize;
	
//	pPhdrDyn->p_filesz-=(delta+15);
	pPhdrDyn->p_filesz-=(delta);
	pPhdrDyn->p_memsz-=delta;
	
//	pPhdrLoad->p_filesz-=(delta+15);
	pPhdrLoad->p_filesz-=(delta);
	//don't alter memsize as bss still lays at same location
}

int main(int argc, char* argv[]) {	
	if(argc!=3) {
		cerr << "usage : megastrip filename.o outfilename.o" << endl;
		return 0;	
	}
	
	fstream file(argv[1]);
	if(file.is_open()==false) {
		cerr << "could not open file : " << argv[1] << endl;
		return -1;
	}
		
	file.seekg(0, ios::end);
	S32 length=file.tellg();
	file.seekg(0, ios::beg);
	
	pBytes=new U8[length];
	
	file.read((char*)&pBytes[0], length);
	file.close();
	
	pEhdr=(Elf32_Ehdr*)&pBytes[0];
	pPhdr=(Elf32_Phdr*)&pBytes[pEhdr->e_phoff];
	
	for(U32 i=0;i<pEhdr->e_phnum;i++) {
		switch(pPhdr[i].p_type) {
			case PT_DYNAMIC: pPhdrDyn=&pPhdr[i]; break;
			case PT_LOAD: pPhdrLoad=&pPhdr[i]; break;
			case PT_INTERP: pPhdrInterp=&pPhdr[i]; break;	
		}
	}
	
	pDyn=(Elf32_Dyn*)&pBytes[pPhdrDyn->p_offset];
	
	baseAddress=pPhdrLoad->p_vaddr;

	ProcessDynamic();	

	pEhdr->e_shoff=pEhdr->e_shentsize=pEhdr->e_shnum=pEhdr->e_shstrndx=0;
	
	ofstream outputfile(argv[2], ofstream::binary | ofstream::trunc);
	outputfile.write((char*)&pBytes[0], pPhdrLoad->p_filesz);
	outputfile.close();

	return 0;	
}