HG_REPOSITORIES/LPP/INSTRUMENTATION/SocExplorer Commit - r52:91fdf0217d26

Sync /!\ do not use this revision

jeandet -

r52:91fdf0217d26 default

parent child

Context file:

r52:91fdf0217d26

Expand all files

src/common/genericBinaryFiles/abstractbinfile.cpp created 644 +30 0

@@ -0,0 +1,30
	1	/*------------------------------------------------------------------------------
	2	-- This file is a part of the SocExplorer Software
	3	-- Copyright (C) 2014, Plasma Physics Laboratory - CNRS
	4	--
	5	-- This program is free software; you can redistribute it and/or modify
	6	-- it under the terms of the GNU General Public License as published by
	7	-- the Free Software Foundation; either version 2 of the License, or
	8	-- (at your option) any later version.
	9	--
	10	-- This program is distributed in the hope that it will be useful,
	11	-- but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	-- GNU General Public License for more details.
	14	--
	15	-- You should have received a copy of the GNU General Public License
	16	-- along with this program; if not, write to the Free Software
	17	-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	18	-------------------------------------------------------------------------------*/
	19	/*-- Author : Alexis Jeandet
	20	-- Mail : alexis.jeandet@member.fsf.org
	21	----------------------------------------------------------------------------*/
	22	#include "abstractbinfile.h"
	23
	24
	25	codeFragment::codeFragment()
	26	{
	27	data = NULL;
	28	size = 0;
	29	address = 0;
	30	}

src/common/genericBinaryFiles/abstractbinfile.h created 644 +71 0

@@ -0,0 +1,71
	1	/*------------------------------------------------------------------------------
	2	-- This file is a part of the SocExplorer Software
	3	-- Copyright (C) 2014, Plasma Physics Laboratory - CNRS
	4	--
	5	-- This program is free software; you can redistribute it and/or modify
	6	-- it under the terms of the GNU General Public License as published by
	7	-- the Free Software Foundation; either version 2 of the License, or
	8	-- (at your option) any later version.
	9	--
	10	-- This program is distributed in the hope that it will be useful,
	11	-- but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	-- GNU General Public License for more details.
	14	--
	15	-- You should have received a copy of the GNU General Public License
	16	-- along with this program; if not, write to the Free Software
	17	-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	18	-------------------------------------------------------------------------------*/
	19	/*-- Author : Alexis Jeandet
	20	-- Mail : alexis.jeandet@member.fsf.org
	21	----------------------------------------------------------------------------*/
	22	#ifndef ABSTRACTBINFILE_H
	23	#define ABSTRACTBINFILE_H
	24
	25	#include <QtCore/QObject>
	26	#include <QtWidgets/QWidget>
	27
	28	class codeFragment
	29	{
	30	public:
	31	codeFragment();
	32	codeFragment(char* data, quint64 size, quint64 address):data(data),size(size),address(address){}
	33	~codeFragment()
	34	{
	35	free(data);
	36	}
	37	QString header;
	38	char* data;
	39	quint64 size;
	40	quint64 address;
	41	};
	42
	43	class abstractBinFile : public QObject
	44	{
	45	Q_OBJECT
	46	public:
	47
	48	virtual bool openFile(const QString& File)=0;
	49	virtual bool isopened()=0;
	50	virtual int closeFile()=0;
	51	virtual QList<codeFragment*> getFragments()=0;
	52	virtual bool toSrec(const QString& File)=0;
	53	virtual bool toBinary(const QString& File)=0;
	54	protected:
	55	QString p_fileName;
	56	};
	57
	58
	59	class abstractBinFileWidget : public QWidget
	60	{
	61	Q_OBJECT
	62
	63	public:
	64	abstractBinFileWidget(QWidget* parent = 0):QWidget(parent){}
	65
	66	public slots:
	67	virtual void setFile(abstractBinFile* file)=0;
	68	virtual void reloadFile()=0;
	69	};
	70
	71	#endif // ABSTRACTBINFILE_H

src/common/genericBinaryFiles/elf/elffile.cpp created 644 +1075 0

This diff has been collapsed as it changes many lines, (1075 lines changed) Show them Hide them
	@@ -0,0 +1,1075
		1	/*------------------------------------------------------------------------------
		2	-- This file is a part of the SocExplorer Software
		3	-- Copyright (C) 2014, Plasma Physics Laboratory - CNRS
		4	--
		5	-- This program is free software; you can redistribute it and/or modify
		6	-- it under the terms of the GNU General Public License as published by
		7	-- the Free Software Foundation; either version 2 of the License, or
		8	-- (at your option) any later version.
		9	--
		10	-- This program is distributed in the hope that it will be useful,
		11	-- but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	-- GNU General Public License for more details.
		14	--
		15	-- You should have received a copy of the GNU General Public License
		16	-- along with this program; if not, write to the Free Software
		17	-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
		18	-------------------------------------------------------------------------------*/
		19	/*-- Author :
		20	Alexis Jeandet
		21	-- Mail :
		22	alexis.jeandet@member.fsf.org
		23	----------------------------------------------------------------------------*/
		24	#include "elffile.h"
		25	#include "srecfile.h"
		26	#include "binaryfile.h"
		27	#include <stdint.h>
		28
		29	ElfFile::ElfFile()
		30	:abstractBinFile()
		31	{
		32	this->opened = false;
		33	this->type_elf = false;
		34	this->elfFile = (int)NULL;
		35	this->e = NULL;
		36	}
		37
		38	ElfFile::ElfFile(const QString &File)
		39	:abstractBinFile()
		40	{
		41	this->opened = false;
		42	this->type_elf = false;
		43	this->elfFile = (int)NULL;
		44	this->e = NULL;
		45	this->p_fileName = File;
		46	openFile(File);
		47	}
		48
		49	ElfFile::~ElfFile()
		50	{
		51	closeFile();
		52	if(scn)free(scn);
		53	if(data)free(data);
		54	for(int i=0;i<this->sections.count();i++)
		55	{
		56	delete this->sections.at(i);
		57	}
		58	this->sections.clear();
		59	for(int i=0;i<this->Segments.count();i++)
		60	{
		61	free(this->Segments.at(i));
		62	}
		63	this->Segments.clear();
		64	for(int i=0;i<symbols.count();i++)
		65	{
		66	delete this->symbols.at(i);
		67	}
		68	this->symbols.clear();
		69	}
		70
		71	bool ElfFile::openFile(const QString &File)
		72	{
		73	this->p_fileName = File;
		74	this->closeFile();
		75	if(elf_version(EV_CURRENT)==EV_NONE)return 0;
		76	#ifdef _ELF_WINDOWS_
		77	this->elfFile = open(File.toStdString().c_str(),O_RDONLY\|O_BINARY ,0);
		78	#else
		79	this->elfFile = open(File.toStdString().c_str(),O_RDONLY ,0);
		80	#endif
		81	if(this->elfFile==(int)NULL)return 0;
		82	this->e = elf_begin(this->elfFile,ELF_C_READ,NULL);
		83	if(this->e==NULL)return 0;
		84	this->ek = elf_kind(this->e);
		85	gelf_getehdr (this->e, &this->ehdr );
		86	elf_getshdrstrndx (this->e, &this->shstrndx);
		87	this->updateSegments();
		88	this->updateSections();
		89	this->updateSymbols();
		90	this->opened = true;
		91	return 1;
		92	}
		93
		94	bool ElfFile::isopened()
		95	{
		96	return this->opened;
		97	}
		98
		99	int ElfFile::closeFile()
		100	{
		101	if(this->elfFile!=(int)NULL)
		102	{
		103	if(this->e!=NULL)
		104	{
		105	elf_end(this->e);
		106	this->e = NULL;
		107	}
		108	close(this->elfFile);
		109	this->elfFile = (int)NULL;
		110	}
		111	this->opened = false;
		112	return 0;
		113	}
		114
		115
		116	QList<codeFragment*> ElfFile::getFragments(QStringList fragmentList)
		117	{
		118	QList<codeFragment*> fragments;
		119	if (isopened())
		120	{
		121	for(int i =0;i<fragmentList.count();i++)
		122	{
		123	fragments.append(getFragment(fragmentList.at(i)));
		124	}
		125	}
		126	return fragments;
		127	}
		128
		129	QList<codeFragment*> ElfFile::getFragments()
		130	{
		131	return getFragments(QStringList()<<".data"<<".text");
		132	}
		133
		134	codeFragment *ElfFile::getFragment(const QString &name)
		135	{
		136	codeFragment* fragment= new codeFragment();
		137	for(int i=0;i<getSectionCount();i++)
		138	{
		139	if(getSectionName(i) == name)
		140	{
		141	fragment->data =NULL;
		142	fragment->size = getSectionDatasz(i);
		143	fragment->address = getSectionPaddr(i);
		144	getSectionData(i,&fragment->data);
		145	}
		146	}
		147	return fragment;
		148	}
		149
		150
		151
		152
		153
		154
		155
		156	QString elfresolveMachine(Elf64_Half e_machine)
		157	{
		158	QString machineName;
		159	//Update from with bash script don't write it by yourself!
		160	switch(e_machine)
		161	{
		162	case EM_NONE:
		163	machineName = " No machine ";
		164	break;
		165	case EM_M32:
		166	machineName = " AT&T WE 32100 ";
		167	break;
		168	case EM_SPARC:
		169	machineName = " SUN SPARC ";
		170	break;
		171	case EM_386:
		172	machineName = " Intel 80386 ";
		173	break;
		174	case EM_68K:
		175	machineName = " Motorola m68k family ";
		176	break;
		177	case EM_88K:
		178	machineName = " Motorola m88k family ";
		179	break;
		180	case EM_860:
		181	machineName = " Intel 80860 ";
		182	break;
		183	case EM_MIPS:
		184	machineName = " MIPS R3000 big-endian ";
		185	break;
		186	case EM_S370:
		187	machineName = " IBM System/370 ";
		188	break;
		189	case EM_MIPS_RS3_LE:
		190	machineName = " MIPS R3000 little-endian ";
		191	break;
		192	case EM_PARISC:
		193	machineName = " HPPA ";
		194	break;
		195	case EM_VPP500:
		196	machineName = " Fujitsu VPP500 ";
		197	break;
		198	case EM_SPARC32PLUS:
		199	machineName = " Sun's \"v8plus\" ";
		200	break;
		201	case EM_960:
		202	machineName = " Intel 80960 ";
		203	break;
		204	case EM_PPC:
		205	machineName = " PowerPC ";
		206	break;
		207	case EM_PPC64:
		208	machineName = " PowerPC 64-bit ";
		209	break;
		210	case EM_S390:
		211	machineName = " IBM S390 ";
		212	break;
		213	case EM_V800:
		214	machineName = " NEC V800 series ";
		215	break;
		216	case EM_FR20:
		217	machineName = " Fujitsu FR20 ";
		218	break;
		219	case EM_RH32:
		220	machineName = " TRW RH-32 ";
		221	break;
		222	case EM_RCE:
		223	machineName = " Motorola RCE ";
		224	break;
		225	case EM_ARM:
		226	machineName = " ARM ";
		227	break;
		228	case EM_FAKE_ALPHA:
		229	machineName = " Digital Alpha ";
		230	break;
		231	case EM_SH:
		232	machineName = " Hitachi SH ";
		233	break;
		234	case EM_SPARCV9:
		235	machineName = " SPARC v9 64-bit ";
		236	break;
		237	case EM_TRICORE:
		238	machineName = " Siemens Tricore ";
		239	break;
		240	case EM_ARC:
		241	machineName = " Argonaut RISC Core ";
		242	break;
		243	case EM_H8_300:
		244	machineName = " Hitachi H8/300 ";
		245	break;
		246	case EM_H8_300H:
		247	machineName = " Hitachi H8/300H ";
		248	break;
		249	case EM_H8S:
		250	machineName = " Hitachi H8S ";
		251	break;
		252	case EM_H8_500:
		253	machineName = " Hitachi H8/500 ";
		254	break;
		255	case EM_IA_64:
		256	machineName = " Intel Merced ";
		257	break;
		258	case EM_MIPS_X:
		259	machineName = " Stanford MIPS-X ";
		260	break;
		261	case EM_COLDFIRE:
		262	machineName = " Motorola Coldfire ";
		263	break;
		264	case EM_68HC12:
		265	machineName = " Motorola M68HC12 ";
		266	break;
		267	case EM_MMA:
		268	machineName = " Fujitsu MMA Multimedia Accelerator";
		269	break;
		270	case EM_PCP:
		271	machineName = " Siemens PCP ";
		272	break;
		273	case EM_NCPU:
		274	machineName = " Sony nCPU embeeded RISC ";
		275	break;
		276	case EM_NDR1:
		277	machineName = " Denso NDR1 microprocessor ";
		278	break;
		279	case EM_STARCORE:
		280	machineName = " Motorola Start*Core processor ";
		281	break;
		282	case EM_ME16:
		283	machineName = " Toyota ME16 processor ";
		284	break;
		285	case EM_ST100:
		286	machineName = " STMicroelectronic ST100 processor ";
		287	break;
		288	case EM_TINYJ:
		289	machineName = " Advanced Logic Corp. Tinyj emb.fam";
		290	break;
		291	case EM_X86_64:
		292	machineName = " AMD x86-64 architecture ";
		293	break;
		294	case EM_PDSP:
		295	machineName = " Sony DSP Processor ";
		296	break;
		297	case EM_FX66:
		298	machineName = " Siemens FX66 microcontroller ";
		299	break;
		300	case EM_ST9PLUS:
		301	machineName = " STMicroelectronics ST9+ 8/16 mc ";
		302	break;
		303	case EM_ST7:
		304	machineName = " STmicroelectronics ST7 8 bit mc ";
		305	break;
		306	case EM_68HC16:
		307	machineName = " Motorola MC68HC16 microcontroller ";
		308	break;
		309	case EM_68HC11:
		310	machineName = " Motorola MC68HC11 microcontroller ";
		311	break;
		312	case EM_68HC08:
		313	machineName = " Motorola MC68HC08 microcontroller ";
		314	break;
		315	case EM_68HC05:
		316	machineName = " Motorola MC68HC05 microcontroller ";
		317	break;
		318	case EM_SVX:
		319	machineName = " Silicon Graphics SVx ";
		320	break;
		321	case EM_ST19:
		322	machineName = " STMicroelectronics ST19 8 bit mc ";
		323	break;
		324	case EM_VAX:
		325	machineName = " Digital VAX ";
		326	break;
		327	case EM_CRIS:
		328	machineName = " Axis Communications 32-bit embedded processor ";
		329	break;
		330	case EM_JAVELIN:
		331	machineName = " Infineon Technologies 32-bit embedded processor ";
		332	break;
		333	case EM_FIREPATH:
		334	machineName = " Element 14 64-bit DSP Processor ";
		335	break;
		336	case EM_ZSP:
		337	machineName = " LSI Logic 16-bit DSP Processor ";
		338	break;
		339	case EM_MMIX:
		340	machineName = " Donald Knuth's educational 64-bit processor ";
		341	break;
		342	case EM_HUANY:
		343	machineName = " Harvard University machine-independent object files ";
		344	break;
		345	case EM_PRISM:
		346	machineName = " SiTera Prism ";
		347	break;
		348	case EM_AVR:
		349	machineName = " Atmel AVR 8-bit microcontroller ";
		350	break;
		351	case EM_FR30:
		352	machineName = " Fujitsu FR30 ";
		353	break;
		354	case EM_D10V:
		355	machineName = " Mitsubishi D10V ";
		356	break;
		357	case EM_D30V:
		358	machineName = " Mitsubishi D30V ";
		359	break;
		360	case EM_V850:
		361	machineName = " NEC v850 ";
		362	break;
		363	case EM_M32R:
		364	machineName = " Mitsubishi M32R ";
		365	break;
		366	case EM_MN10300:
		367	machineName = " Matsushita MN10300 ";
		368	break;
		369	case EM_MN10200:
		370	machineName = " Matsushita MN10200 ";
		371	break;
		372	case EM_PJ:
		373	machineName = " picoJava ";
		374	break;
		375	case EM_OPENRISC:
		376	machineName = " OpenRISC 32-bit embedded processor ";
		377	break;
		378	case EM_ARC_A5:
		379	machineName = " ARC Cores Tangent-A5 ";
		380	break;
		381	case EM_XTENSA:
		382	machineName = " Tensilica Xtensa Architecture ";
		383	break;
		384	case EM_AARCH64:
		385	machineName = " ARM AARCH64 ";
		386	break;
		387	case EM_TILEPRO:
		388	machineName = " Tilera TILEPro ";
		389	break;
		390	case EM_MICROBLAZE:
		391	machineName = " Xilinx MicroBlaze ";
		392	break;
		393	case EM_TILEGX:
		394	machineName = " Tilera TILE-Gx ";
		395	break;
		396	case EM_NUM:
		397	machineName = "";
		398	break;
		399	default:
		400	machineName ="Unknow Machine";
		401	break;
		402	}
		403	return machineName;
		404	}
		405
		406
		407
		408
		409	QString ElfFile::getClass()
		410	{
		411	if(this->e!=NULL)
		412	{
		413	int eclass = gelf_getclass(this->e);
		414	if(eclass==ELFCLASS32)return "ELF32";
		415	if(eclass==ELFCLASS64)return "ELF64";
		416	}
		417	return "none";
		418	}
		419
		420
		421	bool ElfFile::iself()
		422	{
		423	return (this->getType()!="Unknow");
		424	}
		425
		426	QString ElfFile::getArchitecture()
		427	{
		428	if(this->e!=NULL)
		429	{
		430	return elfresolveMachine(this->ehdr.e_machine);
		431	}
		432	return "";
		433	}
		434
		435
		436	QString ElfFile::getType()
		437	{
		438	QString kind("");
		439	if(this->e!=NULL)
		440	{
		441	switch(this->ek)
		442	{
		443	case ELF_K_AR:
		444	kind = "Archive";
		445	break;
		446	case ELF_K_ELF:
		447	kind = "Elf";
		448	break;
		449	case ELF_K_COFF:
		450	kind = "COFF";
		451	break;
		452	case ELF_K_NUM:
		453	kind = "NUM";
		454	break;
		455	case ELF_K_NONE:
		456	kind = "Data";
		457	break;
		458	default:
		459	kind = "Unknow";
		460	break;
		461	}
		462	}
		463	return kind;
		464	}
		465
		466	QString ElfFile::getEndianness()
		467	{
		468	if(this->e!=NULL)
		469	{
		470	if(this->ehdr.e_ident[EI_DATA]==ELFDATA2LSB)return "2's complement, little endian";
		471	if(this->ehdr.e_ident[EI_DATA]==ELFDATA2MSB)return "2's complement, big endian";
		472	}
		473	return "none";
		474	}
		475
		476	QString ElfFile::getABI()
		477	{
		478	if(this->e!=NULL)
		479	{
		480	if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_NONE)return "UNIX System V ABI";
		481	if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_SYSV)return "Alias";
		482	if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_HPUX)return "HP-UX";
		483	if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_NETBSD)return "NetBSD";
		484	if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_LINUX)return "Object uses GNU ELF extensions";
		485	if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_SOLARIS)return "Sun Solaris";
		486	if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_AIX)return "IBM AIX";
		487	if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_IRIX)return "SGI Irix";
		488	if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_FREEBSD)return "FreeBSD";
		489	if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_TRU64)return "Compaq TRU64 UNIX";
		490	if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_MODESTO)return " Novell Modesto";
		491	if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_OPENBSD)return "OpenBSD";
		492	if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_ARM_AEABI)return "ARM EABI";
		493	if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_ARM)return "ARM";
		494	if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_STANDALONE)return "Standalone (embedded) application";
		495	}
		496	return "none";
		497	}
		498
		499
		500	qint64 ElfFile::getVersion()
		501	{
		502	if(this->e!=NULL)
		503	{
		504	return this->ehdr.e_version;
		505	}
		506	return -1;
		507	}
		508
		509	qint64 ElfFile::getEntryPointAddress()
		510	{
		511	if(this->e!=NULL)
		512	{
		513	return this->ehdr.e_entry;
		514	}
		515	return -1;
		516	}
		517
		518
		519	int ElfFile::getSectionCount()
		520	{
		521	return (int)this->SectionCount;
		522	}
		523
		524	int ElfFile::getSymbolCount()
		525	{
		526	return (int)this->SymbolCount;
		527	}
		528
		529
		530	int ElfFile::getSegmentCount()
		531	{
		532	return (int)this->SegmentCount;
		533	}
		534
		535
		536	QString ElfFile::getSegmentType(int index)
		537	{
		538	QString type("");
		539	if(this->e!=NULL)
		540	{
		541	if(index < this->Segments.count())
		542	{
		543	switch(this->Segments.at(index)->p_type)
		544	{
		545	case PT_NULL:
		546	type = "Program header table entry unused";
		547	break;
		548	case PT_LOAD:
		549	type = "Loadable program segment";
		550	break;
		551	case PT_DYNAMIC :
		552	type = "Dynamic linking information";
		553	break;
		554	case PT_INTERP:
		555	type ="Program interpreter";
		556	break;
		557	case PT_NOTE:
		558	type = "Auxiliary information";
		559	break;
		560	case PT_SHLIB:
		561	type = "Reserved";
		562	break;
		563	case PT_PHDR:
		564	type = "Entry for header table itself";
		565	break;
		566	case PT_TLS:
		567	type = "Thread-local storage segment";
		568	break;
		569	case PT_NUM:
		570	type = "Number of defined types";
		571	break;
		572	case PT_LOOS:
		573	type = "Start of OS-specific";
		574	break;
		575	case PT_SUNWSTACK:
		576	type = "Stack segment";
		577	break;
		578	case PT_LOPROC:
		579	type = "Start of processor-specific";
		580	break;
		581	case PT_HIPROC:
		582	type = "End of processor-specific";
		583	break;
		584	default:
		585	type = "Unknow Section Type";
		586	break;
		587	}
		588	}
		589	}
		590
		591	return type;
		592	}
		593
		594
		595	qint64 ElfFile::getSegmentOffset(int index)
		596	{
		597	qint64 Offset = -1;
		598	if(this->e!=NULL)
		599	{
		600	if(index < this->Segments.count())
		601	{
		602	Offset = (qint64)this->Segments.at(index)->p_offset;
		603	}
		604	}
		605	return Offset;
		606	}
		607
		608
		609	qint64 ElfFile::getSegmentVaddr(int index)
		610	{
		611	int64_t Vaddr = 0;
		612	if(this->e!=NULL)
		613	{
		614	if(index < this->Segments.count())
		615	{
		616	Vaddr = (int64_t)this->Segments.at(index)->p_vaddr;
		617	}
		618	}
		619	return Vaddr;
		620	}
		621
		622
		623	qint64 ElfFile::getSegmentPaddr(int index)
		624	{
		625	int64_t Paddr=0;
		626	if(this->e!=NULL)
		627	{
		628	if(index < this->Segments.count())
		629	{
		630	Paddr = (int64_t)this->Segments.at(index)->p_paddr;
		631	}
		632	}
		633	return Paddr;
		634	}
		635
		636	qint64 ElfFile::getSectionPaddr(int index)
		637	{
		638	int64_t Paddr=0;
		639	if(this->e!=NULL)
		640	{
		641	if(index < this->sections.count())
		642	{
		643	Paddr = (int64_t)this->sections.at(index)->section_header->sh_addr;
		644	}
		645	}
		646	return Paddr;
		647	}
		648
		649
		650	qint64 ElfFile::getSegmentFilesz(int index)
		651	{
		652	int64_t FileSz=0;
		653	if(this->e!=NULL)
		654	{
		655	if(index < this->Segments.count())
		656	{
		657	FileSz = (int64_t)this->Segments.at(index)->p_filesz;
		658	}
		659	}
		660	return FileSz;
		661	}
		662
		663	qint64 ElfFile::getSectionDatasz(int index)
		664	{
		665	int64_t DataSz=0;
		666	if(this->e!=NULL)
		667	{
		668	if(index < this->sections.count())
		669	{
		670	if(this->sections.at(index)->section_header->sh_type==SHT_NOBITS)
		671	{
		672	DataSz=0;
		673	}
		674	else
		675	{
		676	DataSz = (int64_t)this->sections.at(index)->data->d_size;
		677	}
		678	}
		679	}
		680	return DataSz;
		681	}
		682
		683	bool ElfFile::getSectionData(int index, char **buffer)
		684	{
		685	if(this->e!=NULL)
		686	{
		687	if(index < this->sections.count())
		688	{
		689	buffer = (char )malloc(this->sections.at(index)->data->d_size);
		690	memcpy(*buffer,this->sections.at(index)->data->d_buf,this->sections.at(index)->data->d_size);
		691	return true;
		692	}
		693	}
		694	return false;
		695	}
		696
		697
		698	qint64 ElfFile::getSegmentMemsz(int index)
		699	{
		700	int64_t MemSz=0;
		701	if(this->e!=NULL)
		702	{
		703	if(index < this->Segments.count())
		704	{
		705	MemSz = (int64_t)this->Segments.at(index)->p_memsz;
		706	}
		707	}
		708	return MemSz;
		709	}
		710
		711	qint64 ElfFile::getSectionMemsz(int index)
		712	{
		713	int64_t MemSz=0;
		714	if(this->e!=NULL)
		715	{
		716	if(index < this->sections.count())
		717	{
		718	MemSz = (int64_t)this->sections.at(index)->section_header->sh_size;
		719	}
		720	}
		721	return MemSz;
		722	}
		723
		724
		725	QString ElfFile::getSegmentFlags(int index)
		726	{
		727	QString flags("");
		728	if(this->e!=NULL)
		729	{
		730	if(index < this->Segments.count())
		731	{
		732	if((this->Segments.at(index)->p_flags&PF_X) == PF_X)flags+="x";
		733	if((this->Segments.at(index)->p_flags&PF_W) == PF_W)flags+="w";
		734	if((this->Segments.at(index)->p_flags&PF_R) == PF_R)flags+="r";
		735	if((this->Segments.at(index)->p_flags&PF_MASKOS) == PF_MASKOS)flags+=" OS-specific";
		736	if((this->Segments.at(index)->p_flags&PF_MASKPROC) == PF_MASKPROC)flags+=" Processor-specific";
		737	}
		738	}
		739	return flags;
		740	}
		741
		742
		743	QString ElfFile::getSectionName(int index)
		744	{
		745	if((index<sections.count()) && (index>=0))
		746	{
		747	char* nameChr = elf_strptr(this->e , this->shstrndx , this->sections.at(index)->section_header->sh_name);
		748	return QString(nameChr);
		749	}
		750	return "";
		751	}
		752
		753
		754	void ElfFile::updateSections()
		755	{
		756	for(int i=0;i<this->sections.count();i++)
		757	{
		758	delete this->sections.at(i);
		759	}
		760	this->sections.clear();
		761	this->scn = elf_nextscn (this->e , NULL );
		762	this->SectionCount = 0;
		763	while( this->scn != NULL )
		764	{
		765	GElf_Shdr* shdr = (GElf_Shdr*)malloc(sizeof(GElf_Shdr));
		766	gelf_getshdr ( this->scn , shdr );
		767	Elf_Data* data = elf_getdata(this->scn, NULL);
		768	this->sections.append(new Elf_Section(data,shdr));
		769	this->SectionCount+=1;
		770	this->scn = elf_nextscn(e , scn);
		771	}
		772	}
		773
		774
		775	void ElfFile::updateSegments()
		776	{
		777	elf_getphdrnum (this->e , &this->SegmentCount);
		778	for(int i=0;i<this->Segments.count();i++)
		779	{
		780	free(this->Segments.at(i));
		781	}
		782	this->Segments.clear();
		783	for(int i=0;i<(int)this->SegmentCount;i++)
		784	{
		785	GElf_Phdr* header=(GElf_Phdr*)malloc(sizeof(GElf_Phdr));
		786	gelf_getphdr (this->e , i , header );
		787	this->Segments.append(header);
		788	}
		789	}
		790
		791	void ElfFile::updateSymbols()
		792	{
		793	for(int i=0;i<symbols.count();i++)
		794	{
		795	delete this->symbols.at(i);
		796	}
		797	this->symbols.clear();
		798	updateSections(); //Useless in most case but safer to do it
		799	for(int i=0;i<(int)SectionCount;i++)
		800	{
		801	//First find Symbol table
		802	if(this->getSectionName(i)==".symtab")
		803	{
		804	Elf_Section* sec = sections.at(i);
		805	this->SymbolCount = sec->section_header->sh_size / sec->section_header->sh_entsize;
		806	//Then list all symbols
		807	for(int j=0;j<(int)this->SymbolCount;j++)
		808	{
		809	GElf_Sym* esym = (GElf_Sym*)malloc(sizeof(GElf_Sym));
		810	gelf_getsym(sec->data, j, esym);
		811	QString name = elf_strptr(this->e,sec->section_header->sh_link,esym->st_name);
		812	Elf_Symbol* sym = new Elf_Symbol(name,esym);
		813	symbols.append(sym);
		814	}
		815	}
		816	}
		817
		818	}
		819
		820
		821
		822	QString ElfFile::getSectionType(int index)
		823	{
		824	QString type("");
		825	if(this->e!=NULL)
		826	{
		827	if(index < this->sections.count())
		828	{
		829	switch(this->sections.at(index)->section_header->sh_type)
		830	{
		831	case SHT_NULL : type = "Section header table entry unused"; break;
		832	case SHT_PROGBITS : type = "Program data"; break;
		833	case SHT_SYMTAB : type = "Symbol table"; break;
		834	case SHT_STRTAB : type = "String table"; break;
		835	case SHT_RELA : type = "Relocation entries with addends"; break;
		836	case SHT_HASH : type = "Symbol hash table"; break;
		837	case SHT_DYNAMIC : type = "Dynamic linking information"; break;
		838	case SHT_NOTE : type = "Notes"; break;
		839	case SHT_NOBITS :type = "Program space with no data (bss)"; break;
		840	case SHT_REL :type = "Relocation entries, no addends"; break;
		841	case SHT_SHLIB : type = "Reserved"; break;
		842	case SHT_DYNSYM : type = "Dynamic linker symbol table"; break;
		843	case SHT_INIT_ARRAY : type = "Array of constructors"; break;
		844	case SHT_FINI_ARRAY : type = "Array of destructors"; break;
		845	case SHT_PREINIT_ARRAY : type = "Array of pre-constructors"; break;
		846	case SHT_GROUP : type = "Section group"; break;
		847	case SHT_SYMTAB_SHNDX : type = "Extended section indeces"; break;
		848	case SHT_NUM : type = "Number of defined types. "; break;
		849	case SHT_LOOS : type = "Start OS-specific. "; break;
		850	case SHT_LOSUNW : type = "Sun-specific low bound. "; break;
		851	case SHT_SUNW_COMDAT : type = " "; break;
		852	case SHT_SUNW_syminfo : type = " "; break;
		853	case SHT_GNU_verdef : type = "Version definition section. "; break;
		854	case SHT_GNU_verneed : type = "Version needs section. "; break;
		855	case SHT_GNU_versym : type = "Version symbol table. "; break;
		856	case SHT_LOPROC : type = "Start of processor-specific"; break;
		857	case SHT_HIPROC : type = "End of processor-specific"; break;
		858	case SHT_HIUSER : type = "End of application-specific"; break;
		859	}
		860	}
		861	}
		862	return type;
		863	}
		864
		865	int ElfFile::getSectionIndex(QString name)
		866	{
		867	if(this->e!=NULL)
		868	{
		869	for(int i=0;i<sections.count();i++)
		870	{
		871	if(getSectionName(i)==name)
		872	return i;
		873	}
		874	}
		875	return -1;
		876	}
		877
		878	bool ElfFile::sectionIsNobits(int index)
		879	{
		880	if(this->e!=NULL)
		881	{
		882	if(index < this->sections.count())
		883	{
		884	return this->sections.at(index)->section_header->sh_type== SHT_NOBITS;
		885	}
		886	}
		887	return false;
		888	}
		889
		890	QString ElfFile::getSymbolName(int index)
		891	{
		892	if(this->e!=NULL)
		893	{
		894	if(index < this->symbols.count())
		895	{
		896	return symbols.at(index)->name;
		897	}
		898	}
		899	return "";
		900	}
		901
		902	QString ElfFile::getSymbolType(int index)
		903	{
		904	if(this->e!=NULL)
		905	{
		906	if(index < this->symbols.count())
		907	{
		908	int type = GELF_ST_TYPE(symbols.at(index)->sym->st_info);
		909	switch(type)
		910	{
		911	case STT_NOTYPE:
		912	return "No Type";
		913	break;
		914	case STT_OBJECT:
		915	return "Object";
		916	break;
		917	case STT_FUNC:
		918	return "Function";
		919	break;
		920	case STT_SECTION:
		921	return "Section";
		922	break;
		923	case STT_FILE:
		924	return "File";
		925	break;
		926	case STT_COMMON:
		927	return "Common data object";
		928	break;
		929	case STT_TLS:
		930	return "Thread-local data object";
		931	break;
		932	case STT_NUM:
		933	return "Number of defined types";
		934	break;
		935	case STT_LOOS:
		936	return "Start of OS-specific";
		937	break;
		938	case STT_HIOS:
		939	return "End of OS-specific";
		940	break;
		941	case STT_LOPROC:
		942	return "Start of processor-specific";
		943	break;
		944	case STT_HIPROC:
		945	return "End of processor-specific";
		946	break;
		947	default:
		948	return "none";
		949	break;
		950	}
		951	}
		952	}
		953	return "none";
		954	}
		955
		956	quint64 ElfFile::getSymbolSize(int index)
		957	{
		958	if(this->e!=NULL)
		959	{
		960	if((index < this->symbols.count()) && (index>=0))
		961	{
		962	return symbols.at(index)->sym->st_size;
		963	}
		964	}
		965	return 0;
		966	}
		967
		968	QString ElfFile::getSymbolSectionName(int index)
		969	{
		970	if(this->e!=NULL)
		971	{
		972	if((index < this->symbols.count()) && (index>=0))
		973	{
		974	return getSectionName(symbols.at(index)->sym->st_shndx-1);
		975	}
		976	}
		977	return "none";
		978	}
		979
		980	int ElfFile::getSymbolSectionIndex(int index)
		981	{
		982	if(this->e!=NULL)
		983	{
		984	if((index < this->symbols.count()) && (index>=0))
		985	{
		986	return symbols.at(index)->sym->st_shndx;
		987	}
		988	}
		989	return 0;
		990	}
		991
		992	quint64 ElfFile::getSymbolAddress(int index)
		993	{
		994	if(this->e!=NULL)
		995	{
		996	if((index < this->symbols.count()) && (index>=0))
		997	{
		998	return symbols.at(index)->sym->st_value;
		999	}
		1000	}
		1001	return 0;
		1002	}
		1003
		1004	QString ElfFile::getSymbolLinkType(int index)
		1005	{
		1006	if(this->e!=NULL)
		1007	{
		1008	if(index < this->symbols.count())
		1009	{
		1010	int btype = GELF_ST_BIND(symbols.at(index)->sym->st_info);
		1011	switch(btype)
		1012	{
		1013	case STB_LOCAL:
		1014	return "Local";
		1015	break;
		1016	case STB_GLOBAL:
		1017	return "Global";
		1018	break;
		1019	case STB_WEAK:
		1020	return "Weak";
		1021	break;
		1022	case STB_NUM:
		1023	return "Number of defined types";
		1024	break;
		1025	case STB_LOOS:
		1026	return "Start of OS-specific";
		1027	break;
		1028	case STB_HIOS:
		1029	return "End of OS-specific";
		1030	break;
		1031	case STB_LOPROC:
		1032	return "Start of processor-specific";
		1033	break;
		1034	case STB_HIPROC:
		1035	return "End of processor-specific";
		1036	break;
		1037	default:
		1038	return "none";
		1039	break;
		1040	}
		1041	}
		1042	}
		1043	return "none";
		1044	}
		1045
		1046	bool ElfFile::isElf(const QString &File)
		1047	{
		1048	int file =0;
		1049	#ifdef _ELF_WINDOWS_
		1050	file = open(File.toStdString().c_str(),O_RDONLY\|O_BINARY ,0);
		1051	#else
		1052	file = open(File.toStdString().c_str(),O_RDONLY ,0);
		1053	#endif
		1054	char Magic[4];
		1055	if(file!=-1)
		1056	{
		1057	size_t res = read(file,Magic,4);
		1058	close(file);
		1059	if((res==4) && (Magic[0]==0x7f) && (Magic[1]==0x45) && (Magic[2]==0x4c) && (Magic[3]==0x46))
		1060	{
		1061	return true;
		1062	}
		1063	}
		1064	return false;
		1065	}
		1066
		1067	bool ElfFile::toSrec(const QString &File)
		1068	{
		1069	return srecFile::toSrec(this->getFragments(),File);
		1070	}
		1071
		1072	bool ElfFile::toBinary(const QString &File)
		1073	{
		1074	return binaryFile::toBinary(getFragments(),File);
		1075	}

src/common/genericBinaryFiles/elf/elffile.h created 644 +136 0

@@ -0,0 +1,136
	1	/*------------------------------------------------------------------------------
	2	-- This file is a part of the SocExplorer Software
	3	-- Copyright (C) 2014, Plasma Physics Laboratory - CNRS
	4	--
	5	-- This program is free software; you can redistribute it and/or modify
	6	-- it under the terms of the GNU General Public License as published by
	7	-- the Free Software Foundation; either version 2 of the License, or
	8	-- (at your option) any later version.
	9	--
	10	-- This program is distributed in the hope that it will be useful,
	11	-- but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	-- GNU General Public License for more details.
	14	--
	15	-- You should have received a copy of the GNU General Public License
	16	-- along with this program; if not, write to the Free Software
	17	-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	18	-------------------------------------------------------------------------------*/
	19	/*-- Author : Alexis Jeandet
	20	-- Mail : alexis.jeandet@member.fsf.org
	21	----------------------------------------------------------------------------*/
	22	#include <abstractbinfile.h>
	23	#include <QtCore/QObject>
	24	#include <QtCore/QStringList>
	25	#include <libelf.h>
	26	#include <gelf.h>
	27	#include <sys/types.h>
	28	#include <sys/stat.h>
	29	#include <fcntl.h>
	30	#include <unistd.h>
	31	#ifndef ELFFILE_H
	32	#define ELFFILE_H
	33
	34	class Elf_Section
	35	{
	36	public:
	37	Elf_Section(){}
	38	Elf_Section(Elf_Data* data,GElf_Shdr* section_header)
	39	{
	40	this->data = data;
	41	this->section_header = section_header;
	42	}
	43	~Elf_Section()
	44	{
	45	free(section_header);
	46	}
	47	Elf_Data* data;
	48	GElf_Shdr* section_header;
	49	};
	50
	51	class Elf_Symbol
	52	{
	53	public:
	54	Elf_Symbol(){}
	55	Elf_Symbol(const QString& name,GElf_Sym* sym):name(name),sym(sym){}
	56	~Elf_Symbol(){free(sym);}
	57	QString name;
	58	GElf_Sym* sym;
	59	};
	60
	61	class ElfFile : public abstractBinFile
	62	{
	63	Q_OBJECT
	64	public:
	65	ElfFile();
	66	ElfFile(const QString& File);
	67	~ElfFile();
	68	bool openFile(const QString& File);
	69	bool isopened();
	70	int closeFile();
	71	QList<codeFragment*> getFragments();
	72	QList<codeFragment*> getFragments(QStringList fragmentList);
	73
	74	QString getClass();
	75	QString getArchitecture();
	76	QString getType();
	77	QString getEndianness();
	78	QString getABI();
	79	qint64 getVersion();
	80	qint64 getEntryPointAddress();
	81
	82	int getSectionCount();
	83	int getSymbolCount();
	84	int getSegmentCount();
	85
	86	QString getSegmentType(int index);
	87	qint64 getSegmentOffset(int index);
	88	qint64 getSegmentVaddr(int index);
	89	qint64 getSegmentPaddr(int index);
	90	qint64 getSegmentFilesz(int index);
	91	qint64 getSegmentMemsz(int index);
	92	QString getSegmentFlags(int index);
	93
	94	bool getSectionData(int index, char **buffer);
	95	qint64 getSectionPaddr(int index);
	96	qint64 getSectionMemsz(int index);
	97	qint64 getSectionDatasz(int index);
	98	QString getSectionName(int index);
	99	QString getSectionType(int index);
	100	int getSectionIndex(QString name);
	101	bool sectionIsNobits(int index);
	102
	103	QString getSymbolName(int index);
	104	QString getSymbolType(int index);
	105	quint64 getSymbolSize(int index);
	106	QString getSymbolSectionName(int index);
	107	int getSymbolSectionIndex(int index);
	108	quint64 getSymbolAddress(int index);
	109	QString getSymbolLinkType(int index);
	110	bool iself();
	111	static bool isElf(const QString& File);
	112
	113	bool toSrec(const QString& File);
	114	bool toBinary(const QString& File);
	115
	116	private:
	117	codeFragment* getFragment(const QString& name);
	118	void updateSections();
	119	void updateSegments();
	120	void updateSymbols();
	121	int elfFile;
	122	bool opened;
	123	bool type_elf;
	124	Elf* e;
	125	Elf_Kind ek;
	126	GElf_Ehdr ehdr;
	127	Elf_Scn * scn;
	128	Elf_Data * data;
	129	size_t SymbolCount,SectionCount,SegmentCount, shstrndx;
	130	QList<GElf_Phdr*> Segments;
	131	QList<Elf_Section*> sections;
	132	QList<Elf_Symbol*> symbols;
	133
	134	};
	135
	136	#endif // ELFFILE_H

src/common/genericBinaryFiles/elf/elffilewidget.cpp created 644 +346 0

@@ -0,0 +1,346
	1	/*------------------------------------------------------------------------------
	2	-- This file is a part of the SocExplorer Software
	3	-- Copyright (C) 2014, Plasma Physics Laboratory - CNRS
	4	--
	5	-- This program is free software; you can redistribute it and/or modify
	6	-- it under the terms of the GNU General Public License as published by
	7	-- the Free Software Foundation; either version 2 of the License, or
	8	-- (at your option) any later version.
	9	--
	10	-- This program is distributed in the hope that it will be useful,
	11	-- but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	-- GNU General Public License for more details.
	14	--
	15	-- You should have received a copy of the GNU General Public License
	16	-- along with this program; if not, write to the Free Software
	17	-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	18	-------------------------------------------------------------------------------*/
	19	/*-- Author : Alexis Jeandet
	20	-- Mail : alexis.jeandet@member.fsf.org
	21	----------------------------------------------------------------------------*/
	22	#include "elffilewidget.h"
	23	#include "ui_elffilewidget.h"
	24	#include <QtWidgets/QTableWidgetItem>
	25	#include <QtWidgets/QFileDialog>
	26	#include "qhexedit.h"
	27	#include "qtablewidgetintitem.h"
	28	#include "../srec/srecfile.h"
	29	#include "../BinFile/binaryfile.h"
	30
	31	elfFileWidget::elfFileWidget(QWidget *parent) :
	32	abstractBinFileWidget(parent),
	33	ui(new Ui::elfFileWidget)
	34	{
	35	ui->setupUi(this);
	36	exportToSREC_action = new QAction(tr("Export to SREC"),this);
	37	exportToBIN_action = new QAction(tr("Export to Binary"),this);
	38	viewSymbolInHexViewer_action = new QAction(tr("View in Hexviewer"),this);
	39	connect(this->ui->sectionsList,SIGNAL(cellActivated(int,int)),this,SLOT(sectionCellActivated(int,int)));
	40	this->ui->sectionsList->addAction(exportToSREC_action);
	41	this->ui->sectionsList->addAction(exportToBIN_action);
	42	this->ui->symbolsList->addAction(viewSymbolInHexViewer_action);
	43	this->ui->symbolsList->addAction(exportToSREC_action);
	44	this->ui->symbolsList->addAction(exportToBIN_action);
	45	connect(this->exportToBIN_action,SIGNAL(triggered()),this,SLOT(exportToBIN()));
	46	connect(this->exportToSREC_action,SIGNAL(triggered()),this,SLOT(exportToSREC()));
	47	connect(this->ui->symbolsFilter,SIGNAL(textChanged(QString)),this,SLOT(filterSymbols(QString)));
	48	connect(this->ui->caseSensitive,SIGNAL(toggled(bool)),this,SLOT(filterSymbolsCaseUpdate(bool)));
	49	connect(this->viewSymbolInHexViewer_action,SIGNAL(triggered()),this,SLOT(viewSymbolInHexViewer()));
	50	this->p_hexviewer = new QHexEdit();
	51	this->p_hexviewer->setWindowTitle("SocExplorer Hexadecimal viewer");
	52	this->setWindowTitle("SocExplorer Elf viewer");
	53	}
	54
	55
	56
	57	elfFileWidget::~elfFileWidget()
	58	{
	59	delete ui;
	60	delete p_hexviewer;
	61	}
	62
	63
	64
	65	void elfFileWidget::setFile(ElfFile *file)
	66	{
	67	this->p_elf = file;
	68	if(p_elf->isopened() && p_elf->iself())
	69	{
	70	this->ui->classLabel->setText(p_elf->getClass());
	71	this->ui->VersionLabel->setText(QString::number(p_elf->getVersion()));
	72	this->ui->machineLabel->setText(p_elf->getArchitecture());
	73	this->ui->endiannesLabel->setText(p_elf->getEndianness());
	74	this->ui->abiLabel->setText(p_elf->getABI());
	75	this->ui->entryPointLabel->setText(QString("0x%1").arg((uint)p_elf->getEntryPointAddress(),8,16));
	76	this->ui->typeLabel->setText(p_elf->getType());
	77	this->ui->sectionCountLabel->setText(QString::number(p_elf->getSectionCount()));
	78	this->ui->symbolCountLabel->setText(QString::number(p_elf->getSymbolCount()));
	79	}
	80	reloadFile();
	81	}
	82
	83	void elfFileWidget::reloadFile()
	84	{
	85	updateSymbols();
	86	updateSections();
	87	}
	88
	89
	90
	91	void elfFileWidget::updateSymbols()
	92	{
	93	this->ui->symbolsList->clear();
	94	this->ui->symbolsList->setRowCount(p_elf->getSymbolCount());
	95	this->ui->symbolsList->setHorizontalHeaderLabels(QStringList()<<"Index"<<"Value"<<"Size"<<"Type"<<"Link"<<"Section"<<"Name");
	96	for(int i=0;i<p_elf->getSymbolCount();i++)
	97	{
	98	QTableWidgetItem newItem = (QTableWidgetItem)new QTableWidgetIntItem(QString("%1").arg(i),DecimalItem);
	99	newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
	100	this->ui->symbolsList->setItem(i, 0, newItem);
	101
	102	newItem = (QTableWidgetItem*)new QTableWidgetIntItem(QString("0x%1").arg(p_elf->getSymbolAddress(i),8,16).replace(" ","0"),HexaDecimalItem);
	103	newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
	104	this->ui->symbolsList->setItem(i, 1, newItem);
	105
	106	newItem = (QTableWidgetItem*)new QTableWidgetIntItem(QString("%1").arg(p_elf->getSymbolSize(i)),DecimalItem);
	107	newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
	108	this->ui->symbolsList->setItem(i, 2, newItem);
	109
	110	newItem = new QTableWidgetItem(p_elf->getSymbolType(i));
	111	newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
	112	this->ui->symbolsList->setItem(i, 3, newItem);
	113
	114	newItem = new QTableWidgetItem(p_elf->getSymbolLinkType(i));
	115	newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
	116	this->ui->symbolsList->setItem(i, 4, newItem);
	117
	118	newItem = new QTableWidgetItem(p_elf->getSymbolSectionName(i));
	119	newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
	120	this->ui->symbolsList->setItem(i, 5, newItem);
	121
	122	newItem = new QTableWidgetItem(p_elf->getSymbolName(i));
	123	newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
	124	this->ui->symbolsList->setItem(i, 6, newItem);
	125	}
	126	this->ui->symbolsList->resizeColumnsToContents();
	127	}
	128
	129
	130
	131	void elfFileWidget::updateSections()
	132	{
	133	this->ui->sectionsList->clear();
	134	this->ui->sectionsList->setRowCount(p_elf->getSectionCount());
	135	this->ui->sectionsList->setHorizontalHeaderLabels(QStringList()<<"Index"<<"Name"<<"Address"<<"Size"<<"File Size"<<"Type");
	136	for(int i=0;i<p_elf->getSectionCount();i++)
	137	{
	138	QTableWidgetItem newItem = (QTableWidgetItem) new QTableWidgetIntItem(QString("%1").arg(i),DecimalItem);
	139	newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
	140	this->ui->sectionsList->setItem(i,0, newItem);
	141
	142	newItem = new QTableWidgetItem(p_elf->getSectionName(i));
	143	newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
	144	this->ui->sectionsList->setItem(i, 1, newItem);
	145
	146	newItem = (QTableWidgetItem*) new QTableWidgetIntItem(QString("0x%1").arg(p_elf->getSectionPaddr(i),8,16).replace(" ","0"),HexaDecimalItem);
	147	newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
	148	this->ui->sectionsList->setItem(i, 2, newItem);
	149
	150	newItem = (QTableWidgetItem*) new QTableWidgetIntItem(QString("%1").arg(p_elf->getSectionMemsz(i)),DecimalItem);
	151	newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
	152	this->ui->sectionsList->setItem(i, 3, newItem);
	153
	154	newItem = (QTableWidgetItem*) new QTableWidgetIntItem(QString("%1").arg(p_elf->getSectionDatasz(i)),DecimalItem);
	155	newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
	156	this->ui->sectionsList->setItem(i, 4, newItem);
	157
	158	newItem = new QTableWidgetItem(p_elf->getSectionType(i));
	159	newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
	160	this->ui->sectionsList->setItem(i, 5, newItem);
	161	}
	162	this->ui->sectionsList->resizeColumnsToContents();
	163	}
	164
	165	void elfFileWidget::sectionCellActivated(int row, int column)
	166	{
	167	Q_UNUSED(column)
	168	char* buff=NULL;
	169	int sectionIndex = p_elf->getSectionIndex(this->ui->sectionsList->item(row,1)->text());
	170	if(sectionIndex!=-1)
	171	{
	172	QString type = p_elf->getSectionType(sectionIndex);
	173	if(!p_elf->sectionIsNobits(sectionIndex))
	174	{
	175	this->p_elf->getSectionData(sectionIndex,&buff);
	176	this->ui->sectionsHexView->setData(QByteArray(buff,this->p_elf->getSectionDatasz(sectionIndex)));
	177	this->ui->sectionsHexView->setAddressOffset(this->p_elf->getSectionPaddr(sectionIndex));
	178	}
	179	}
	180	}
	181
	182	void elfFileWidget::exportToSREC()
	183	{
	184	QList<codeFragment *> fragments;
	185	if(this->ui->tabWidget->currentWidget()==this->ui->symbolsTab)
	186	{
	187	fragments = getSelectedSymbolsFragments();
	188	}
	189	if(this->ui->tabWidget->currentWidget()==this->ui->sectionsTab)
	190	{
	191	QStringList sectionList=getSelectedSectionsNames();
	192	if(sectionList.count()>0)
	193	fragments = p_elf->getFragments(sectionList);
	194	}
	195	if(fragments.count()>0)
	196	{
	197	QString fileName = QFileDialog::getSaveFileName(this, tr("Save File"),
	198	NULL,
	199	tr("SREC Files (*.srec)"));
	200	if(!fileName.isEmpty())
	201	{
	202	srecFile::toSrec(fragments,fileName);
	203	}
	204	}
	205
	206	}
	207
	208	void elfFileWidget::exportToBIN()
	209	{
	210	QList<codeFragment *> fragments;
	211	if(this->ui->tabWidget->currentWidget()==this->ui->symbolsTab)
	212	{
	213	fragments = getSelectedSymbolsFragments();
	214	}
	215	if(this->ui->tabWidget->currentWidget()==this->ui->sectionsTab)
	216	{
	217	QStringList sectionList=getSelectedSectionsNames();
	218	if(sectionList.count()>0)
	219	fragments = p_elf->getFragments(sectionList);
	220	}
	221	if(fragments.count()>0)
	222	{
	223	QString fileName = QFileDialog::getSaveFileName(this, tr("Save File"),
	224	NULL,
	225	tr("Binary Files (*.bin)"));
	226	if(!fileName.isEmpty())
	227	{
	228	binaryFile::toBinary(fragments,fileName);
	229	}
	230	}
	231
	232	}
	233
	234	void elfFileWidget::viewSymbolInHexViewer()
	235	{
	236	int row=this->ui->symbolsList->item(this->ui->symbolsList->currentRow(),0)->text().toInt();
	237	int section = p_elf->getSectionIndex(p_elf->getSymbolSectionName(row));
	238	qint64 address = p_elf->getSymbolAddress(row);
	239	qint64 secAddress = p_elf->getSectionPaddr(section);
	240	qint64 size = p_elf->getSymbolSize(row);
	241	char* buff=NULL;
	242	char* symBuff=NULL;
	243	if(size && !p_elf->sectionIsNobits(section))
	244	{
	245	if(section!=-1)
	246	{
	247	symBuff = (char*)malloc(size);
	248	this->p_elf->getSectionData(section,&buff);
	249	memcpy(symBuff,buff+(address-secAddress),size);
	250	this->p_hexviewer->setData(QByteArray(symBuff,size));
	251	this->p_hexviewer->setAddressOffset(address);
	252	this->p_hexviewer->show();
	253	}
	254	}
	255	}
	256
	257	void elfFileWidget::filterSymbols(const QString &pattern)
	258	{
	259	Qt::MatchFlags flag = Qt::MatchContains \| Qt::MatchStartsWith \| Qt::MatchEndsWith \| Qt::MatchRegExp \| Qt::MatchWildcard \| Qt::MatchWrap \|Qt::MatchRecursive;
	260	if(this->ui->caseSensitive->isChecked())
	261	flag \|= Qt::MatchCaseSensitive;
	262	if(pattern.isEmpty())
	263	{
	264	for(int i=0;i<this->ui->symbolsList->rowCount();i++)
	265	this->ui->symbolsList->setRowHidden(i,false);
	266	}
	267	else
	268	{
	269	for(int i=0;i<this->ui->symbolsList->rowCount();i++)
	270	this->ui->symbolsList->setRowHidden(i,true);
	271	QList<QTableWidgetItem*> items = this->ui->symbolsList->findItems(pattern,flag);
	272	for(int i=0;i<items.count();i++)
	273	this->ui->symbolsList->setRowHidden(items.at(i)->row(),false);
	274	}
	275	}
	276
	277	void elfFileWidget::filterSymbolsCaseUpdate(bool toggled)
	278	{
	279	Q_UNUSED(toggled)
	280	this->filterSymbols(this->ui->symbolsFilter->text());
	281	}
	282
	283	QList<codeFragment *> elfFileWidget::getSelectedSymbolsFragments()
	284	{
	285	QList<codeFragment *> fragments;
	286	codeFragment * fragment;
	287	if(p_elf->isopened())
	288	{
	289	QList<QTableWidgetItem*> items = this->ui->symbolsList->selectedItems();
	290	for(int i=0;i<items.count();i++)
	291	{
	292	int row=this->ui->symbolsList->item(items.at(i)->row(),0)->text().toInt();
	293	int section = p_elf->getSectionIndex(p_elf->getSymbolSectionName(row));
	294	qint64 address = p_elf->getSymbolAddress(row);
	295	qint64 secAddress = p_elf->getSectionPaddr(section);
	296	qint64 size = p_elf->getSymbolSize(row);
	297	char* buff=NULL;
	298	if(size && !p_elf->sectionIsNobits(section))
	299	{
	300	if(section!=-1)
	301	{
	302	fragment= new codeFragment();
	303	fragment->data = (char*)malloc(size);
	304	fragment->address = address;
	305	fragment->size = size;
	306	this->p_elf->getSectionData(section,&buff);
	307	memcpy(fragment->data,buff+(address-secAddress),size);
	308	fragments.append(fragment);
	309	}
	310	}
	311	}
	312	}
	313	return fragments;
	314
	315	}
	316
	317
	318
	319	QStringList elfFileWidget::getSelectedSectionsNames()
	320	{
	321	QStringList sectionList;
	322	QList<QTableWidgetItem*> items = this->ui->sectionsList->selectedItems();
	323	for(int i=0;i<items.count();i++)
	324	{
	325	QString section = p_elf->getSectionName(items.at(i)->row());
	326	if(!sectionList.contains(section))
	327	{
	328	sectionList.append(section);
	329	}
	330	}
	331	return sectionList;
	332	}
	333
	334
	335
	336
	337
	338
	339
	340
	341
	342
	343
	344
	345
	346

src/common/genericBinaryFiles/elf/elffilewidget.h created 644 +66 0

@@ -0,0 +1,66
	1	/*------------------------------------------------------------------------------
	2	-- This file is a part of the SocExplorer Software
	3	-- Copyright (C) 2014, Plasma Physics Laboratory - CNRS
	4	--
	5	-- This program is free software; you can redistribute it and/or modify
	6	-- it under the terms of the GNU General Public License as published by
	7	-- the Free Software Foundation; either version 2 of the License, or
	8	-- (at your option) any later version.
	9	--
	10	-- This program is distributed in the hope that it will be useful,
	11	-- but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	-- GNU General Public License for more details.
	14	--
	15	-- You should have received a copy of the GNU General Public License
	16	-- along with this program; if not, write to the Free Software
	17	-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	18	-------------------------------------------------------------------------------*/
	19	/*-- Author : Alexis Jeandet
	20	-- Mail : alexis.jeandet@member.fsf.org
	21	----------------------------------------------------------------------------*/
	22	#ifndef ELFFILEWIDGET_H
	23	#define ELFFILEWIDGET_H
	24
	25	#include <QtWidgets/QWidget>
	26	#include "elffile.h"
	27	#include <QtWidgets/QAction>
	28	#include <qhexedit.h>
	29
	30	namespace Ui {
	31	class elfFileWidget;
	32	}
	33
	34	class elfFileWidget : public abstractBinFileWidget
	35	{
	36	Q_OBJECT
	37
	38	public:
	39	elfFileWidget(QWidget *parent = 0);
	40	~elfFileWidget();
	41
	42	public slots:
	43	void setFile(ElfFile* file);
	44	void reloadFile();
	45	void updateSymbols();
	46	void updateSections();
	47
	48	private slots:
	49	void sectionCellActivated(int row, int column);
	50	void exportToSREC();
	51	void exportToBIN();
	52	void viewSymbolInHexViewer();
	53	void filterSymbols(const QString& pattern);
	54	void filterSymbolsCaseUpdate(bool toggled);
	55	private:
	56	QList<codeFragment*> getSelectedSymbolsFragments();
	57	Ui::elfFileWidget *ui;
	58	QStringList getSelectedSectionsNames();
	59	ElfFile* p_elf;
	60	QAction* exportToSREC_action;
	61	QAction* exportToBIN_action;
	62	QAction* viewSymbolInHexViewer_action;
	63	QHexEdit* p_hexviewer;
	64	};
	65
	66	#endif // ELFFILEWIDGET_H

src/common/genericBinaryFiles/elf/elffilewidget.ui created 644 +337 0

@@ -0,0 +1,337
	1	<?xml version="1.0" encoding="UTF-8"?>
	2	<ui version="4.0">
	3	<class>elfFileWidget</class>
	4	<widget class="QWidget" name="elfFileWidget">
	5	<property name="geometry">
	6	<rect>
	7	<x>0</x>
	8	<y>0</y>
	9	<width>786</width>
	10	<height>387</height>
	11	</rect>
	12	</property>
	13	<property name="minimumSize">
	14	<size>
	15	<width>0</width>
	16	<height>0</height>
	17	</size>
	18	</property>
	19	<property name="focusPolicy">
	20	<enum>Qt::NoFocus</enum>
	21	</property>
	22	<property name="windowTitle">
	23	<string>Form</string>
	24	</property>
	25	<layout class="QGridLayout" name="gridLayout">
	26	<item row="0" column="0">
	27	<widget class="QTabWidget" name="tabWidget">
	28	<property name="currentIndex">
	29	<number>0</number>
	30	</property>
	31	<widget class="QWidget" name="generalInfoTab">
	32	<attribute name="title">
	33	<string>File Informations</string>
	34	</attribute>
	35	<layout class="QGridLayout" name="gridLayout_4">
	36	<item row="0" column="0">
	37	<widget class="QGroupBox" name="groupBox">
	38	<property name="title">
	39	<string>Elf header</string>
	40	</property>
	41	<layout class="QFormLayout" name="formLayout">
	42	<item row="0" column="0">
	43	<widget class="QLabel" name="label">
	44	<property name="text">
	45	<string>Class:</string>
	46	</property>
	47	</widget>
	48	</item>
	49	<item row="0" column="1">
	50	<widget class="QLabel" name="classLabel">
	51	<property name="text">
	52	<string>none</string>
	53	</property>
	54	</widget>
	55	</item>
	56	<item row="1" column="0">
	57	<widget class="QLabel" name="label_3">
	58	<property name="text">
	59	<string>Endianness:</string>
	60	</property>
	61	</widget>
	62	</item>
	63	<item row="1" column="1">
	64	<widget class="QLabel" name="endiannesLabel">
	65	<property name="text">
	66	<string>none</string>
	67	</property>
	68	</widget>
	69	</item>
	70	<item row="2" column="0">
	71	<widget class="QLabel" name="label_5">
	72	<property name="text">
	73	<string>Version:</string>
	74	</property>
	75	</widget>
	76	</item>
	77	<item row="3" column="0">
	78	<widget class="QLabel" name="label_6">
	79	<property name="text">
	80	<string>Type:</string>
	81	</property>
	82	</widget>
	83	</item>
	84	<item row="4" column="0">
	85	<widget class="QLabel" name="label_7">
	86	<property name="text">
	87	<string>Machine:</string>
	88	</property>
	89	</widget>
	90	</item>
	91	<item row="6" column="0">
	92	<widget class="QLabel" name="label_8">
	93	<property name="text">
	94	<string>Entry point address:</string>
	95	</property>
	96	</widget>
	97	</item>
	98	<item row="2" column="1">
	99	<widget class="QLabel" name="VersionLabel">
	100	<property name="text">
	101	<string>none</string>
	102	</property>
	103	</widget>
	104	</item>
	105	<item row="3" column="1">
	106	<widget class="QLabel" name="typeLabel">
	107	<property name="text">
	108	<string>none</string>
	109	</property>
	110	</widget>
	111	</item>
	112	<item row="4" column="1">
	113	<widget class="QLabel" name="machineLabel">
	114	<property name="text">
	115	<string>none</string>
	116	</property>
	117	</widget>
	118	</item>
	119	<item row="6" column="1">
	120	<widget class="QLabel" name="entryPointLabel">
	121	<property name="text">
	122	<string>none</string>
	123	</property>
	124	</widget>
	125	</item>
	126	<item row="5" column="0">
	127	<widget class="QLabel" name="label_17">
	128	<property name="text">
	129	<string>OS/ABI:</string>
	130	</property>
	131	</widget>
	132	</item>
	133	<item row="5" column="1">
	134	<widget class="QLabel" name="abiLabel">
	135	<property name="text">
	136	<string>none</string>
	137	</property>
	138	</widget>
	139	</item>
	140	</layout>
	141	</widget>
	142	</item>
	143	<item row="1" column="0">
	144	<widget class="QGroupBox" name="groupBox_2">
	145	<property name="title">
	146	<string>Sections & Symbols</string>
	147	</property>
	148	<layout class="QFormLayout" name="formLayout_2">
	149	<item row="0" column="0">
	150	<widget class="QLabel" name="label_9">
	151	<property name="text">
	152	<string>Section count:</string>
	153	</property>
	154	</widget>
	155	</item>
	156	<item row="1" column="0">
	157	<widget class="QLabel" name="label_10">
	158	<property name="text">
	159	<string>Symbols count:</string>
	160	</property>
	161	</widget>
	162	</item>
	163	<item row="0" column="1">
	164	<widget class="QLabel" name="sectionCountLabel">
	165	<property name="text">
	166	<string>none</string>
	167	</property>
	168	</widget>
	169	</item>
	170	<item row="1" column="1">
	171	<widget class="QLabel" name="symbolCountLabel">
	172	<property name="text">
	173	<string>none</string>
	174	</property>
	175	</widget>
	176	</item>
	177	</layout>
	178	</widget>
	179	</item>
	180	</layout>
	181	</widget>
	182	<widget class="QWidget" name="symbolsTab">
	183	<attribute name="title">
	184	<string>Symbols</string>
	185	</attribute>
	186	<layout class="QGridLayout" name="gridLayout_2">
	187	<item row="0" column="1">
	188	<widget class="QLineEdit" name="symbolsFilter"/>
	189	</item>
	190	<item row="0" column="0">
	191	<widget class="QLabel" name="label_2">
	192	<property name="text">
	193	<string>Filter:</string>
	194	</property>
	195	</widget>
	196	</item>
	197	<item row="0" column="2">
	198	<widget class="QCheckBox" name="caseSensitive">
	199	<property name="text">
	200	<string>Case Sensitive</string>
	201	</property>
	202	</widget>
	203	</item>
	204	<item row="2" column="0" colspan="3">
	205	<widget class="QTableWidget" name="symbolsList">
	206	<property name="contextMenuPolicy">
	207	<enum>Qt::ActionsContextMenu</enum>
	208	</property>
	209	<property name="sortingEnabled">
	210	<bool>true</bool>
	211	</property>
	212	<attribute name="verticalHeaderVisible">
	213	<bool>false</bool>
	214	</attribute>
	215	<attribute name="verticalHeaderShowSortIndicator" stdset="0">
	216	<bool>false</bool>
	217	</attribute>
	218	<column>
	219	<property name="text">
	220	<string>Index</string>
	221	</property>
	222	</column>
	223	<column>
	224	<property name="text">
	225	<string>Value</string>
	226	</property>
	227	</column>
	228	<column>
	229	<property name="text">
	230	<string>Size</string>
	231	</property>
	232	</column>
	233	<column>
	234	<property name="text">
	235	<string>Type</string>
	236	</property>
	237	</column>
	238	<column>
	239	<property name="text">
	240	<string>Link</string>
	241	</property>
	242	</column>
	243	<column>
	244	<property name="text">
	245	<string>Section</string>
	246	</property>
	247	</column>
	248	<column>
	249	<property name="text">
	250	<string>Name</string>
	251	</property>
	252	</column>
	253	</widget>
	254	</item>
	255	</layout>
	256	</widget>
	257	<widget class="QWidget" name="sectionsTab">
	258	<attribute name="title">
	259	<string>Sections</string>
	260	</attribute>
	261	<layout class="QGridLayout" name="gridLayout_3">
	262	<item row="0" column="0">
	263	<widget class="QSplitter" name="splitter">
	264	<property name="orientation">
	265	<enum>Qt::Horizontal</enum>
	266	</property>
	267	<widget class="QHexEdit" name="sectionsHexView" native="true">
	268	<property name="minimumSize">
	269	<size>
	270	<width>100</width>
	271	<height>0</height>
	272	</size>
	273	</property>
	274	</widget>
	275	<widget class="QTableWidget" name="sectionsList">
	276	<property name="contextMenuPolicy">
	277	<enum>Qt::ActionsContextMenu</enum>
	278	</property>
	279	<property name="sortingEnabled">
	280	<bool>true</bool>
	281	</property>
	282	<attribute name="verticalHeaderVisible">
	283	<bool>false</bool>
	284	</attribute>
	285	<attribute name="verticalHeaderShowSortIndicator" stdset="0">
	286	<bool>false</bool>
	287	</attribute>
	288	<column>
	289	<property name="text">
	290	<string>Index</string>
	291	</property>
	292	</column>
	293	<column>
	294	<property name="text">
	295	<string>Name</string>
	296	</property>
	297	</column>
	298	<column>
	299	<property name="text">
	300	<string>Address</string>
	301	</property>
	302	</column>
	303	<column>
	304	<property name="text">
	305	<string>Size</string>
	306	</property>
	307	</column>
	308	<column>
	309	<property name="text">
	310	<string>File Size</string>
	311	</property>
	312	</column>
	313	<column>
	314	<property name="text">
	315	<string>Type</string>
	316	</property>
	317	</column>
	318	</widget>
	319	</widget>
	320	</item>
	321	</layout>
	322	</widget>
	323	</widget>
	324	</item>
	325	</layout>
	326	</widget>
	327	<customwidgets>
	328	<customwidget>
	329	<class>QHexEdit</class>
	330	<extends>QWidget</extends>
	331	<header location="global">qhexedit.h</header>
	332	<container>1</container>
	333	</customwidget>
	334	</customwidgets>
	335	<resources/>
	336	<connections/>
	337	</ui>

src/common/genericBinaryFiles/elf/elfinfowdgt.cpp created 644 +164 0

@@ -0,0 +1,164
	1	/*------------------------------------------------------------------------------
	2	-- This file is a part of the SocExplorer Software
	3	-- Copyright (C) 2013, Plasma Physics Laboratory - CNRS
	4	--
	5	-- This program is free software; you can redistribute it and/or modify
	6	-- it under the terms of the GNU General Public License as published by
	7	-- the Free Software Foundation; either version 3 of the License, or
	8	-- (at your option) any later version.
	9	--
	10	-- This program is distributed in the hope that it will be useful,
	11	-- but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	-- GNU General Public License for more details.
	14	--
	15	-- You should have received a copy of the GNU General Public License
	16	-- along with this program; if not, write to the Free Software
	17	-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	18	-------------------------------------------------------------------------------*/
	19	/*-- Author : Alexis Jeandet
	20	-- Mail : alexis.jeandet@lpp.polytechnique.fr
	21	----------------------------------------------------------------------------*/
	22
	23	#include "elfinfowdgt.h"
	24
	25	elfInfoWdgt::elfInfoWdgt(QWidget *parent) :
	26	QWidget(parent)
	27	{
	28	this->mainLayout = new QVBoxLayout;
	29	this->ElfArchitecture= new QLabel;
	30	this->ElfType = new QLabel;
	31	this->ElfVersion = new QLabel;
	32	this->splitter = new QSplitter;
	33	this->hexViewer = new QHexEdit;
	34	this->elfInfoWdgtLay = new QWidget;
	35	this->elfInfoWdgtLayout = new QVBoxLayout;
	36	this->segmentsListTableWdgt = new QTableWidget;
	37	this->segmentsListTableWdgt->setColumnCount(7);
	38	this->segmentsListTableWdgt->setHorizontalHeaderLabels(QStringList()<<"Type"<<"Offset"<<"Vaddr"<<"Paddr"<<"File Size"<<"Mem Size"<<"Flags");
	39	this->sectionsListTableWdgt = new QTableWidget;
	40	this->sectionsListTableWdgt->setColumnCount(2);
	41	this->sectionsListTableWdgt->setHorizontalHeaderLabels(QStringList()<<"Name"<<"Type");
	42	this->ElfArchitecture->setText(QString("Architecture: "));
	43	this->ElfType->setText(QString("Type: "));
	44	this->ElfVersion->setText(QString("Version: "));
	45	this->elfInfoWdgtLayout->addWidget(this->ElfArchitecture);
	46	this->elfInfoWdgtLayout->addWidget(this->ElfType);
	47	this->elfInfoWdgtLayout->addWidget(this->ElfVersion);
	48	this->elfInfoWdgtLayout->addWidget(this->segmentsListTableWdgt);
	49	this->elfInfoWdgtLayout->addWidget(this->sectionsListTableWdgt);
	50	this->splitter->addWidget(this->hexViewer);
	51	this->splitter->addWidget(this->elfInfoWdgtLay);
	52	this->elfInfoWdgtLay->setLayout(this->elfInfoWdgtLayout);
	53	this->mainLayout->addWidget(this->splitter);
	54	this->setLayout(this->mainLayout);
	55	connect(this->segmentsListTableWdgt,SIGNAL(cellActivated(int,int)),this,SLOT(cellActivated(int,int)));
	56	connect(this->sectionsListTableWdgt,SIGNAL(cellActivated(int,int)),this,SLOT(cellActivated(int,int)));
	57	}
	58
	59
	60	void elfInfoWdgt::updateInfo(elfparser *parser)
	61	{
	62	if(parser!=NULL)
	63	{
	64	this->ElfArchitecture->setText(QString("Architecture: ")+parser->getArchitecture());
	65	this->ElfType->setText(QString("Type: ")+parser->getType());
	66	this->ElfVersion->setText(QString("Version: 0x")+QString::number(parser->getVersion(),16));
	67	this->updateSectionsTable(parser);
	68	this->updateSegmentsTable(parser);
	69	}
	70
	71	}
	72
	73	void elfInfoWdgt::cellActivated(int row, int column)
	74	{
	75	char* buff=NULL;
	76	this->parser->getSectionData(row,&buff);
	77	this->hexViewer->setData(QByteArray(buff,this->parser->getSectionDatasz(row)));
	78	}
	79
	80
	81	void elfInfoWdgt::updateSectionsTable(elfparser* parser)
	82	{
	83	if(parser!=NULL)
	84	{
	85	this->parser = parser;
	86	QTableWidgetItem *item;
	87	for(int i=0 ;i<this->sectionsListTableWdgt->rowCount();i++)
	88	{
	89	for(int l=0;l<this->sectionsListTableWdgt->columnCount();l++)
	90	{
	91	item = this->sectionsListTableWdgt->item(i,l);
	92	delete item;
	93	}
	94	}
	95	this->sectionsListTableWdgt->setRowCount(parser->getSectioncount());
	96	for(int i=0;i<parser->getSectioncount();i++)
	97	{
	98	item = new QTableWidgetItem(parser->getSectionName(i));
	99	item->setFlags(item->flags() &~ Qt::ItemIsEditable);
	100	this->sectionsListTableWdgt->setItem(i,0,item);
	101	item = new QTableWidgetItem(parser->getSectionType(i));
	102	item->setFlags(item->flags() &~ Qt::ItemIsEditable);
	103	this->sectionsListTableWdgt->setItem(i,1,item);
	104	}
	105	this->sectionsListTableWdgt->resizeColumnsToContents();
	106	this->sectionsListTableWdgt->resizeRowsToContents();
	107	}
	108	}
	109
	110
	111	void elfInfoWdgt::updateSegmentsTable(elfparser* parser)
	112	{
	113	if(parser!=NULL)
	114	{
	115	this->parser = parser;
	116	QTableWidgetItem *item;
	117	for(int i=0 ;i<this->segmentsListTableWdgt->rowCount();i++)
	118	{
	119	for(int l=0;l<this->segmentsListTableWdgt->columnCount();l++)
	120	{
	121	item = this->segmentsListTableWdgt->item(i,l);
	122	delete item;
	123	}
	124	}
	125	this->segmentsListTableWdgt->setRowCount(parser->getSegmentcount());
	126	for(int i=0;i<parser->getSegmentcount();i++)
	127	{
	128	item = new QTableWidgetItem(parser->getSegmentType(i));
	129	item->setFlags(item->flags() &~ Qt::ItemIsEditable);
	130	this->segmentsListTableWdgt->setItem(i,0,item);
	131	item = new QTableWidgetItem("0x"+QString::number(parser->getSegmentOffset(i),16));
	132	item->setFlags(item->flags() &~ Qt::ItemIsEditable);
	133	this->segmentsListTableWdgt->setItem(i,1,item);
	134	item = new QTableWidgetItem("0x"+QString::number(parser->getSegmentVaddr(i),16));
	135	item->setFlags(item->flags() &~ Qt::ItemIsEditable);
	136	this->segmentsListTableWdgt->setItem(i,2,item);
	137	item = new QTableWidgetItem("0x"+QString::number(parser->getSegmentPaddr(i),16));
	138	item->setFlags(item->flags() &~ Qt::ItemIsEditable);
	139	this->segmentsListTableWdgt->setItem(i,3,item);
	140	item = new QTableWidgetItem("0x"+QString::number(parser->getSegmentFilesz(i),16));
	141	item->setFlags(item->flags() &~ Qt::ItemIsEditable);
	142	this->segmentsListTableWdgt->setItem(i,4,item);
	143	item = new QTableWidgetItem("0x"+QString::number(parser->getSegmentMemsz(i),16));
	144	item->setFlags(item->flags() &~ Qt::ItemIsEditable);
	145	this->segmentsListTableWdgt->setItem(i,5,item);
	146	item = new QTableWidgetItem(parser->getSegmentFlags(i));
	147	item->setFlags(item->flags() &~ Qt::ItemIsEditable);
	148	this->segmentsListTableWdgt->setItem(i,6,item);
	149	}
	150	this->segmentsListTableWdgt->resizeColumnsToContents();
	151	this->segmentsListTableWdgt->resizeRowsToContents();
	152	}
	153	}
	154
	155
	156
	157
	158
	159
	160
	161
	162
	163
	164

src/common/genericBinaryFiles/elf/elfinfowdgt.h created 644 +64 0

@@ -0,0 +1,64
	1	/*------------------------------------------------------------------------------
	2	-- This file is a part of the SocExplorer Software
	3	-- Copyright (C) 2013, Plasma Physics Laboratory - CNRS
	4	--
	5	-- This program is free software; you can redistribute it and/or modify
	6	-- it under the terms of the GNU General Public License as published by
	7	-- the Free Software Foundation; either version 3 of the License, or
	8	-- (at your option) any later version.
	9	--
	10	-- This program is distributed in the hope that it will be useful,
	11	-- but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	-- GNU General Public License for more details.
	14	--
	15	-- You should have received a copy of the GNU General Public License
	16	-- along with this program; if not, write to the Free Software
	17	-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	18	-------------------------------------------------------------------------------*/
	19	/*-- Author : Alexis Jeandet
	20	-- Mail : alexis.jeandet@lpp.polytechnique.fr
	21	----------------------------------------------------------------------------*/
	22	#ifndef ELFINFOWDGT_H
	23	#define ELFINFOWDGT_H
	24
	25	#include <QtWidgets/QWidget>
	26	#include "elfparser.h"
	27	#include <QtWidgets/QVBoxLayout>
	28	#include <QtWidgets/QHBoxLayout>
	29	#include <QtWidgets/QLabel>
	30	#include <QtWidgets/QTextEdit>
	31	#include <QtWidgets/QTableWidget>
	32	#include <qhexedit.h>
	33	#include <QtWidgets/QSplitter>
	34
	35	class elfInfoWdgt : public QWidget
	36	{
	37	Q_OBJECT
	38	public:
	39	explicit elfInfoWdgt(QWidget *parent = 0);
	40
	41	signals:
	42
	43
	44	public slots:
	45	void updateInfo(elfparser* parser);
	46	void cellActivated ( int row, int column );
	47
	48	private:
	49	void updateSectionsTable(elfparser* parser);
	50	void updateSegmentsTable(elfparser* parser);
	51	QVBoxLayout* mainLayout;
	52	QLabel* ElfArchitecture;
	53	QLabel* ElfType;
	54	QLabel* ElfVersion;
	55	QTableWidget* segmentsListTableWdgt,*sectionsListTableWdgt;
	56	QHexEdit* hexViewer;
	57	QSplitter* splitter;
	58	QWidget* elfInfoWdgtLay;
	59	QVBoxLayout* elfInfoWdgtLayout;
	60	elfparser* parser;
	61
	62	};
	63
	64	#endif // ELFINFOWDGT_H

src/common/genericBinaryFiles/elf/elfparser.cpp created 644 +522 0

This diff has been collapsed as it changes many lines, (522 lines changed) Show them Hide them
	@@ -0,0 +1,522
		1	/*------------------------------------------------------------------------------
		2	-- This file is a part of the SocExplorer Software
		3	-- Copyright (C) 2013, Plasma Physics Laboratory - CNRS
		4	--
		5	-- This program is free software; you can redistribute it and/or modify
		6	-- it under the terms of the GNU General Public License as published by
		7	-- the Free Software Foundation; either version 3 of the License, or
		8	-- (at your option) any later version.
		9	--
		10	-- This program is distributed in the hope that it will be useful,
		11	-- but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	-- GNU General Public License for more details.
		14	--
		15	-- You should have received a copy of the GNU General Public License
		16	-- along with this program; if not, write to the Free Software
		17	-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
		18	-------------------------------------------------------------------------------*/
		19	/*-- Author : Alexis Jeandet
		20	-- Mail : alexis.jeandet@lpp.polytechnique.fr
		21	----------------------------------------------------------------------------*/
		22	#include "elfparser.h"
		23	#include <sys/types.h>
		24	#include <sys/stat.h>
		25	#include <fcntl.h>
		26	#include <unistd.h>
		27
		28	extern QString elfresolveMachine(Elf64_Half e_machine);
		29
		30
		31	elfparser::elfparser()
		32	{
		33	this->opened = false;
		34	this->type_elf = false;
		35	this->elfFile = (int)NULL;
		36	this->e = NULL;
		37	}
		38
		39
		40	int elfparser::setFilename(const QString &name)
		41	{
		42	this->closeFile();
		43	if(elf_version(EV_CURRENT)==EV_NONE)return 0;
		44	#ifdef _ELF_WINDOWS_
		45	this->elfFile = open(name.toStdString().c_str(),O_RDONLY\|O_BINARY ,0);
		46	#else
		47	this->elfFile = open(name.toStdString().c_str(),O_RDONLY ,0);
		48	#endif
		49	if(this->elfFile==(int)NULL)return 0;
		50	this->e = elf_begin(this->elfFile,ELF_C_READ,NULL);
		51	if(this->e==NULL)return 0;
		52	this->ek = elf_kind(this->e);
		53	gelf_getehdr (this->e, &this->ehdr );
		54	elf_getshdrstrndx (this->e, &this->shstrndx);
		55	this->updateSegments();
		56	this->updateSections();
		57	return 1;
		58	}
		59
		60
		61	int elfparser::closeFile()
		62	{
		63	if(this->elfFile!=(int)NULL)
		64	{
		65	if(this->e!=NULL)
		66	{
		67	elf_end(this->e);
		68	this->e = NULL;
		69	}
		70	close(this->elfFile);
		71	this->elfFile = (int)NULL;
		72	}
		73	return 0;
		74	}
		75
		76	QString elfparser::getClass()
		77	{
		78	if(this->e!=NULL)
		79	{
		80	int eclass = gelf_getclass(this->e);
		81	if(eclass==ELFCLASS32)return "ELF32";
		82	if(eclass==ELFCLASS64)return "ELF64";
		83	}
		84	return "none";
		85	}
		86
		87
		88	bool elfparser::isopened()
		89	{
		90	return this->opened;
		91	}
		92
		93
		94	bool elfparser::iself()
		95	{
		96	return this->type_elf;
		97	}
		98
		99
		100	QString elfparser::getArchitecture()
		101	{
		102	if(this->e!=NULL)
		103	{
		104	return elfresolveMachine(this->ehdr.e_machine);
		105	}
		106	return "";
		107	}
		108
		109
		110	QString elfparser::getType()
		111	{
		112	QString kind("");
		113	if(this->e!=NULL)
		114	{
		115	switch(this->ek)
		116	{
		117	case ELF_K_AR:
		118	kind = "Archive";
		119	break;
		120	case ELF_K_ELF:
		121	kind = "Elf";
		122	break;
		123	case ELF_K_COFF:
		124	kind = "COFF";
		125	break;
		126	case ELF_K_NUM:
		127	kind = "NUM";
		128	break;
		129	case ELF_K_NONE:
		130	kind = "Data";
		131	break;
		132	default:
		133	kind = "Unknow";
		134	break;
		135	}
		136	}
		137	return kind;
		138	}
		139
		140	QString elfparser::getEndianness()
		141	{
		142	if(this->e!=NULL)
		143	{
		144	if(this->ehdr.e_ident[EI_DATA]==ELFDATA2LSB)return "2's complement, little endian";
		145	if(this->ehdr.e_ident[EI_DATA]==ELFDATA2MSB)return "2's complement, big endian";
		146	}
		147	return "none";
		148	}
		149
		150	QString elfparser::getABI()
		151	{
		152	if(this->e!=NULL)
		153	{
		154	if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_NONE)return "UNIX System V ABI";
		155	if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_SYSV)return "Alias";
		156	if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_HPUX)return "HP-UX";
		157	if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_NETBSD)return "NetBSD";
		158	if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_LINUX)return "Object uses GNU ELF extensions";
		159	if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_SOLARIS)return "Sun Solaris";
		160	if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_AIX)return "IBM AIX";
		161	if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_IRIX)return "SGI Irix";
		162	if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_FREEBSD)return "FreeBSD";
		163	if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_TRU64)return "Compaq TRU64 UNIX";
		164	if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_MODESTO)return " Novell Modesto";
		165	if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_OPENBSD)return "OpenBSD";
		166	if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_ARM_AEABI)return "ARM EABI";
		167	if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_ARM)return "ARM";
		168	if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_STANDALONE)return "Standalone (embedded) application";
		169	}
		170	return "none";
		171	}
		172
		173
		174	qint64 elfparser::getVersion()
		175	{
		176	if(this->e!=NULL)
		177	{
		178	return this->ehdr.e_version;
		179	}
		180	return -1;
		181	}
		182
		183	qint64 elfparser::getEntryPointAddress()
		184	{
		185	if(this->e!=NULL)
		186	{
		187	return this->ehdr.e_entry;
		188	}
		189	return -1;
		190	}
		191
		192
		193	int elfparser::getSectioncount()
		194	{
		195	return (int)this->SectionCount;
		196	}
		197
		198
		199	int elfparser::getSegmentcount()
		200	{
		201	return (int)this->SegmentCount;
		202	}
		203
		204
		205	QString elfparser::getSegmentType(int index)
		206	{
		207	QString type("");
		208	if(this->e!=NULL)
		209	{
		210	if(index < this->Segments.count())
		211	{
		212	switch(this->Segments.at(index)->p_type)
		213	{
		214	case PT_NULL:
		215	type = "Program header table entry unused";
		216	break;
		217	case PT_LOAD:
		218	type = "Loadable program segment";
		219	break;
		220	case PT_DYNAMIC :
		221	type = "Dynamic linking information";
		222	break;
		223	case PT_INTERP:
		224	type ="Program interpreter";
		225	break;
		226	case PT_NOTE:
		227	type = "Auxiliary information";
		228	break;
		229	case PT_SHLIB:
		230	type = "Reserved";
		231	break;
		232	case PT_PHDR:
		233	type = "Entry for header table itself";
		234	break;
		235	case PT_TLS:
		236	type = "Thread-local storage segment";
		237	break;
		238	case PT_NUM:
		239	type = "Number of defined types";
		240	break;
		241	case PT_LOOS:
		242	type = "Start of OS-specific";
		243	break;
		244	case PT_SUNWSTACK:
		245	type = "Stack segment";
		246	break;
		247	case PT_LOPROC:
		248	type = "Start of processor-specific";
		249	break;
		250	case PT_HIPROC:
		251	type = "End of processor-specific";
		252	break;
		253	default:
		254	type = "Unknow Section Type";
		255	break;
		256	}
		257	}
		258	}
		259
		260	return type;
		261	}
		262
		263
		264	qint64 elfparser::getSegmentOffset(int index)
		265	{
		266	qint64 Offset=-1;
		267	if(this->e!=NULL)
		268	{
		269	if(index < this->Segments.count())
		270	{
		271	Offset = (qint64)this->Segments.at(index)->p_offset;
		272	}
		273	}
		274	return Offset;
		275	}
		276
		277
		278	qint64 elfparser::getSegmentVaddr(int index)
		279	{
		280	int64_t Vaddr = 0;
		281	if(this->e!=NULL)
		282	{
		283	if(index < this->Segments.count())
		284	{
		285	Vaddr = (int64_t)this->Segments.at(index)->p_vaddr;
		286	}
		287	}
		288	return Vaddr;
		289	}
		290
		291
		292	qint64 elfparser::getSegmentPaddr(int index)
		293	{
		294	int64_t Paddr=0;
		295	if(this->e!=NULL)
		296	{
		297	if(index < this->Segments.count())
		298	{
		299	Paddr = (int64_t)this->Segments.at(index)->p_paddr;
		300	}
		301	}
		302	return Paddr;
		303	}
		304
		305	qint64 elfparser::getSectionPaddr(int index)
		306	{
		307	int64_t Paddr=0;
		308	if(this->e!=NULL)
		309	{
		310	if(index < this->sections.count())
		311	{
		312	Paddr = (int64_t)this->sections.at(index)->section_header->sh_addr;
		313	}
		314	}
		315	return Paddr;
		316	}
		317
		318
		319	qint64 elfparser::getSegmentFilesz(int index)
		320	{
		321	int64_t FileSz=0;
		322	if(this->e!=NULL)
		323	{
		324	if(index < this->Segments.count())
		325	{
		326	FileSz = (int64_t)this->Segments.at(index)->p_filesz;
		327	}
		328	}
		329	return FileSz;
		330	}
		331
		332	qint64 elfparser::getSectionDatasz(int index)
		333	{
		334	int64_t DataSz=0;
		335	if(this->e!=NULL)
		336	{
		337	if(index < this->sections.count())
		338	{
		339	DataSz = (int64_t)this->sections.at(index)->data->d_size;
		340	}
		341	}
		342	return DataSz;
		343	}
		344
		345	bool elfparser::getSectionData(int index, char **buffer)
		346	{
		347	if(this->e!=NULL)
		348	{
		349	if(index < this->sections.count())
		350	{
		351	buffer = (char )this->sections.at(index)->data->d_buf;
		352	return true;
		353	}
		354	}
		355	return false;
		356	}
		357
		358
		359	qint64 elfparser::getSegmentMemsz(int index)
		360	{
		361	int64_t MemSz=0;
		362	if(this->e!=NULL)
		363	{
		364	if(index < this->Segments.count())
		365	{
		366	MemSz = (int64_t)this->Segments.at(index)->p_memsz;
		367	}
		368	}
		369	return MemSz;
		370	}
		371
		372	qint64 elfparser::getSectionMemsz(int index)
		373	{
		374	int64_t MemSz=0;
		375	if(this->e!=NULL)
		376	{
		377	if(index < this->sections.count())
		378	{
		379	MemSz = (int64_t)this->sections.at(index)->section_header->sh_size;
		380	}
		381	}
		382	return MemSz;
		383	}
		384
		385
		386	QString elfparser::getSegmentFlags(int index)
		387	{
		388	QString flags("");
		389	if(this->e!=NULL)
		390	{
		391	if(index < this->Segments.count())
		392	{
		393	if((this->Segments.at(index)->p_flags&PF_X) == PF_X)flags+="x";
		394	if((this->Segments.at(index)->p_flags&PF_W) == PF_W)flags+="w";
		395	if((this->Segments.at(index)->p_flags&PF_R) == PF_R)flags+="r";
		396	if((this->Segments.at(index)->p_flags&PF_MASKOS) == PF_MASKOS)flags+=" OS-specific";
		397	if((this->Segments.at(index)->p_flags&PF_MASKPROC) == PF_MASKPROC)flags+=" Processor-specific";
		398	}
		399	}
		400	return flags;
		401	}
		402
		403
		404	QString elfparser::getSectionName(int index)
		405	{
		406	char* nameChr = elf_strptr(this->e , this->shstrndx , this->sections.at(index)->section_header->sh_name);
		407	return QString(nameChr);
		408	}
		409
		410
		411	void elfparser::updateSections()
		412	{
		413	for(int i=0;i<this->sections.count();i++)
		414	{
		415	delete this->sections.at(i);
		416	}
		417	this->sections.clear();
		418	this->scn = elf_nextscn (this->e , NULL );
		419	this->SectionCount = 0;
		420	while( this->scn != NULL )
		421	{
		422	GElf_Shdr* shdr = (GElf_Shdr*)malloc(sizeof(GElf_Shdr));
		423	gelf_getshdr ( this->scn , shdr );
		424	Elf_Data* data = elf_getdata(this->scn, NULL);
		425	this->sections.append(new Elf_Section(data,shdr));
		426	this->SectionCount+=1;
		427	this->scn = elf_nextscn(e , scn);
		428	}
		429	}
		430
		431
		432	void elfparser::updateSegments()
		433	{
		434	elf_getphdrnum (this->e , &this->SegmentCount);
		435	for(int i=0;i<this->Segments.count();i++)
		436	{
		437	free(this->Segments.at(i));
		438	}
		439	this->Segments.clear();
		440	for(int i=0;i<(int)this->SegmentCount;i++)
		441	{
		442	GElf_Phdr* header=(GElf_Phdr*)malloc(sizeof(GElf_Phdr));
		443	gelf_getphdr (this->e , i , header );
		444	this->Segments.append(header);
		445	}
		446	}
		447
		448
		449
		450
		451
		452	QString elfparser::getSectionType(int index)
		453	{
		454	QString type("");
		455	if(this->e!=NULL)
		456	{
		457	if(index < this->Segments.count())
		458	{
		459	switch(this->Segments.at(index)->p_type)
		460	{
		461	case SHT_NULL : type = "Section header table entry unused"; break;
		462	case SHT_PROGBITS : type = "Program data"; break;
		463	case SHT_SYMTAB : type = "Symbol table"; break;
		464	case SHT_STRTAB : type = "String table"; break;
		465	case SHT_RELA : type = "Relocation entries with addends"; break;
		466	case SHT_HASH : type = "Symbol hash table"; break;
		467	case SHT_DYNAMIC : type = "Dynamic linking information"; break;
		468	case SHT_NOTE : type = "Notes"; break;
		469	case SHT_NOBITS :type = "Program space with no data (bss)"; break;
		470	case SHT_REL :type = "Relocation entries, no addends"; break;
		471	case SHT_SHLIB : type = "Reserved"; break;
		472	case SHT_DYNSYM : type = "Dynamic linker symbol table"; break;
		473	case SHT_INIT_ARRAY : type = "Array of constructors"; break;
		474	case SHT_FINI_ARRAY : type = "Array of destructors"; break;
		475	case SHT_PREINIT_ARRAY : type = "Array of pre-constructors"; break;
		476	case SHT_GROUP : type = "Section group"; break;
		477	case SHT_SYMTAB_SHNDX : type = "Extended section indeces"; break;
		478	case SHT_NUM : type = "Number of defined types. "; break;
		479	case SHT_LOOS : type = "Start OS-specific. "; break;
		480	case SHT_LOSUNW : type = "Sun-specific low bound. "; break;
		481	case SHT_SUNW_COMDAT : type = " "; break;
		482	case SHT_SUNW_syminfo : type = " "; break;
		483	case SHT_GNU_verdef : type = "Version definition section. "; break;
		484	case SHT_GNU_verneed : type = "Version needs section. "; break;
		485	case SHT_GNU_versym : type = "Version symbol table. "; break;
		486	case SHT_LOPROC : type = "Start of processor-specific"; break;
		487	case SHT_HIPROC : type = "End of processor-specific"; break;
		488	case SHT_HIUSER : type = "End of application-specific"; break;
		489	}
		490	}
		491	}
		492	return type;
		493	}
		494
		495	bool elfparser::isElf(const QString &File)
		496	{
		497	int file =0;
		498	#ifdef _ELF_WINDOWS_
		499	file = open(File.toStdString().c_str(),O_RDONLY\|O_BINARY ,0);
		500	#else
		501	file = open(File.toStdString().c_str(),O_RDONLY ,0);
		502	#endif
		503	char Magic[4];
		504	if(file!=-1)
		505	{
		506	size_t res = read(file,Magic,4);
		507	close(file);
		508	if((res == 4) && (Magic[0]==0x7f) && (Magic[1]==0x45) && (Magic[2]==0x4c) && (Magic[3]==0x46))
		509	{
		510	return true;
		511	}
		512	}
		513	return false;
		514	}
		515
		516
		517
		518
		519
		520
		521
		522

src/common/genericBinaryFiles/elf/elfparser.h created 644 +89 0

@@ -0,0 +1,89
	1	/*------------------------------------------------------------------------------
	2	-- This file is a part of the SocExplorer Software
	3	-- Copyright (C) 2013, Plasma Physics Laboratory - CNRS
	4	--
	5	-- This program is free software; you can redistribute it and/or modify
	6	-- it under the terms of the GNU General Public License as published by
	7	-- the Free Software Foundation; either version 3 of the License, or
	8	-- (at your option) any later version.
	9	--
	10	-- This program is distributed in the hope that it will be useful,
	11	-- but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	-- GNU General Public License for more details.
	14	--
	15	-- You should have received a copy of the GNU General Public License
	16	-- along with this program; if not, write to the Free Software
	17	-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	18	-------------------------------------------------------------------------------*/
	19	/*-- Author : Alexis Jeandet
	20	-- Mail : alexis.jeandet@lpp.polytechnique.fr
	21	----------------------------------------------------------------------------*/
	22	#ifndef ELFPARSER_H
	23	#define ELFPARSER_H
	24	#include <libelf.h>
	25	#include <gelf.h>
	26	#include <QString>
	27	#include <stdio.h>
	28	#include <QList>
	29	#include <stdint.h>
	30	#include "elffile.h"
	31
	32	class elfparser
	33	{
	34	public:
	35	elfparser();
	36	bool iself();
	37	bool isopened();
	38	int setFilename(const QString& name);
	39	int closeFile();
	40	QString getClass();
	41	QString getArchitecture();
	42	QString getType();
	43	QString getEndianness();
	44	QString getABI();
	45	qint64 getVersion();
	46	qint64 getEntryPointAddress();
	47	int getSectioncount();
	48	int getSegmentcount();
	49	QString getSegmentType(int index);
	50	qint64 getSegmentOffset(int index);
	51	qint64 getSegmentVaddr(int index);
	52	qint64 getSegmentPaddr(int index);
	53	qint64 getSectionPaddr(int index);
	54	qint64 getSegmentFilesz(int index);
	55	qint64 getSectionDatasz(int index);
	56	bool getSectionData(int index, char **buffer);
	57	qint64 getSegmentMemsz(int index);
	58	qint64 getSectionMemsz(int index);
	59	QString getSegmentFlags(int index);
	60	QString getSectionName(int index);
	61	QString getSectionType(int index);
	62	static bool isElf(const QString& File);
	63
	64	private:
	65	void updateSections();
	66	void updateSegments();
	67	int elfFile;
	68	bool opened;
	69	bool type_elf;
	70	Elf* e;
	71	Elf_Kind ek;
	72	GElf_Ehdr ehdr;
	73	Elf_Scn * scn;
	74	Elf_Data * data;
	75	size_t SectionCount,SegmentCount, shstrndx;
	76	QList<GElf_Phdr*> Segments;
	77	QList<Elf_Section*> sections;
	78
	79	};
	80
	81	#endif // ELFPARSER_H
	82
	83
	84
	85
	86
	87
	88
	89

src/common/genericBinaryFiles/elf/libelfWin32/COPYING.LIB created 644 +481 0

@@ -0,0 +1,481
	1	GNU LIBRARY GENERAL PUBLIC LICENSE
	2	Version 2, June 1991
	3
	4	Copyright (C) 1991 Free Software Foundation, Inc.
	5	59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	6	Everyone is permitted to copy and distribute verbatim copies
	7	of this license document, but changing it is not allowed.
	8
	9	[This is the first released version of the library GPL. It is
	10	numbered 2 because it goes with version 2 of the ordinary GPL.]
	11
	12	Preamble
	13
	14	The licenses for most software are designed to take away your
	15	freedom to share and change it. By contrast, the GNU General Public
	16	Licenses are intended to guarantee your freedom to share and change
	17	free software--to make sure the software is free for all its users.
	18
	19	This license, the Library General Public License, applies to some
	20	specially designated Free Software Foundation software, and to any
	21	other libraries whose authors decide to use it. You can use it for
	22	your libraries, too.
	23
	24	When we speak of free software, we are referring to freedom, not
	25	price. Our General Public Licenses are designed to make sure that you
	26	have the freedom to distribute copies of free software (and charge for
	27	this service if you wish), that you receive source code or can get it
	28	if you want it, that you can change the software or use pieces of it
	29	in new free programs; and that you know you can do these things.
	30
	31	To protect your rights, we need to make restrictions that forbid
	32	anyone to deny you these rights or to ask you to surrender the rights.
	33	These restrictions translate to certain responsibilities for you if
	34	you distribute copies of the library, or if you modify it.
	35
	36	For example, if you distribute copies of the library, whether gratis
	37	or for a fee, you must give the recipients all the rights that we gave
	38	you. You must make sure that they, too, receive or can get the source
	39	code. If you link a program with the library, you must provide
	40	complete object files to the recipients so that they can relink them
	41	with the library, after making changes to the library and recompiling
	42	it. And you must show them these terms so they know their rights.
	43
	44	Our method of protecting your rights has two steps: (1) copyright
	45	the library, and (2) offer you this license which gives you legal
	46	permission to copy, distribute and/or modify the library.
	47
	48	Also, for each distributor's protection, we want to make certain
	49	that everyone understands that there is no warranty for this free
	50	library. If the library is modified by someone else and passed on, we
	51	want its recipients to know that what they have is not the original
	52	version, so that any problems introduced by others will not reflect on
	53	the original authors' reputations.
	54
	55	Finally, any free program is threatened constantly by software
	56	patents. We wish to avoid the danger that companies distributing free
	57	software will individually obtain patent licenses, thus in effect
	58	transforming the program into proprietary software. To prevent this,
	59	we have made it clear that any patent must be licensed for everyone's
	60	free use or not licensed at all.
	61
	62	Most GNU software, including some libraries, is covered by the ordinary
	63	GNU General Public License, which was designed for utility programs. This
	64	license, the GNU Library General Public License, applies to certain
	65	designated libraries. This license is quite different from the ordinary
	66	one; be sure to read it in full, and don't assume that anything in it is
	67	the same as in the ordinary license.
	68
	69	The reason we have a separate public license for some libraries is that
	70	they blur the distinction we usually make between modifying or adding to a
	71	program and simply using it. Linking a program with a library, without
	72	changing the library, is in some sense simply using the library, and is
	73	analogous to running a utility program or application program. However, in
	74	a textual and legal sense, the linked executable is a combined work, a
	75	derivative of the original library, and the ordinary General Public License
	76	treats it as such.
	77
	78	Because of this blurred distinction, using the ordinary General
	79	Public License for libraries did not effectively promote software
	80	sharing, because most developers did not use the libraries. We
	81	concluded that weaker conditions might promote sharing better.
	82
	83	However, unrestricted linking of non-free programs would deprive the
	84	users of those programs of all benefit from the free status of the
	85	libraries themselves. This Library General Public License is intended to
	86	permit developers of non-free programs to use free libraries, while
	87	preserving your freedom as a user of such programs to change the free
	88	libraries that are incorporated in them. (We have not seen how to achieve
	89	this as regards changes in header files, but we have achieved it as regards
	90	changes in the actual functions of the Library.) The hope is that this
	91	will lead to faster development of free libraries.
	92
	93	The precise terms and conditions for copying, distribution and
	94	modification follow. Pay close attention to the difference between a
	95	"work based on the library" and a "work that uses the library". The
	96	former contains code derived from the library, while the latter only
	97	works together with the library.
	98
	99	Note that it is possible for a library to be covered by the ordinary
	100	General Public License rather than by this special one.
	101
	102	GNU LIBRARY GENERAL PUBLIC LICENSE
	103	TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
	104
	105	0. This License Agreement applies to any software library which
	106	contains a notice placed by the copyright holder or other authorized
	107	party saying it may be distributed under the terms of this Library
	108	General Public License (also called "this License"). Each licensee is
	109	addressed as "you".
	110
	111	A "library" means a collection of software functions and/or data
	112	prepared so as to be conveniently linked with application programs
	113	(which use some of those functions and data) to form executables.
	114
	115	The "Library", below, refers to any such software library or work
	116	which has been distributed under these terms. A "work based on the
	117	Library" means either the Library or any derivative work under
	118	copyright law: that is to say, a work containing the Library or a
	119	portion of it, either verbatim or with modifications and/or translated
	120	straightforwardly into another language. (Hereinafter, translation is
	121	included without limitation in the term "modification".)
	122
	123	"Source code" for a work means the preferred form of the work for
	124	making modifications to it. For a library, complete source code means
	125	all the source code for all modules it contains, plus any associated
	126	interface definition files, plus the scripts used to control compilation
	127	and installation of the library.
	128
	129	Activities other than copying, distribution and modification are not
	130	covered by this License; they are outside its scope. The act of
	131	running a program using the Library is not restricted, and output from
	132	such a program is covered only if its contents constitute a work based
	133	on the Library (independent of the use of the Library in a tool for
	134	writing it). Whether that is true depends on what the Library does
	135	and what the program that uses the Library does.
	136
	137	1. You may copy and distribute verbatim copies of the Library's
	138	complete source code as you receive it, in any medium, provided that
	139	you conspicuously and appropriately publish on each copy an
	140	appropriate copyright notice and disclaimer of warranty; keep intact
	141	all the notices that refer to this License and to the absence of any
	142	warranty; and distribute a copy of this License along with the
	143	Library.
	144
	145	You may charge a fee for the physical act of transferring a copy,
	146	and you may at your option offer warranty protection in exchange for a
	147	fee.
	148
	149	2. You may modify your copy or copies of the Library or any portion
	150	of it, thus forming a work based on the Library, and copy and
	151	distribute such modifications or work under the terms of Section 1
	152	above, provided that you also meet all of these conditions:
	153
	154	a) The modified work must itself be a software library.
	155
	156	b) You must cause the files modified to carry prominent notices
	157	stating that you changed the files and the date of any change.
	158
	159	c) You must cause the whole of the work to be licensed at no
	160	charge to all third parties under the terms of this License.
	161
	162	d) If a facility in the modified Library refers to a function or a
	163	table of data to be supplied by an application program that uses
	164	the facility, other than as an argument passed when the facility
	165	is invoked, then you must make a good faith effort to ensure that,
	166	in the event an application does not supply such function or
	167	table, the facility still operates, and performs whatever part of
	168	its purpose remains meaningful.
	169
	170	(For example, a function in a library to compute square roots has
	171	a purpose that is entirely well-defined independent of the
	172	application. Therefore, Subsection 2d requires that any
	173	application-supplied function or table used by this function must
	174	be optional: if the application does not supply it, the square
	175	root function must still compute square roots.)
	176
	177	These requirements apply to the modified work as a whole. If
	178	identifiable sections of that work are not derived from the Library,
	179	and can be reasonably considered independent and separate works in
	180	themselves, then this License, and its terms, do not apply to those
	181	sections when you distribute them as separate works. But when you
	182	distribute the same sections as part of a whole which is a work based
	183	on the Library, the distribution of the whole must be on the terms of
	184	this License, whose permissions for other licensees extend to the
	185	entire whole, and thus to each and every part regardless of who wrote
	186	it.
	187
	188	Thus, it is not the intent of this section to claim rights or contest
	189	your rights to work written entirely by you; rather, the intent is to
	190	exercise the right to control the distribution of derivative or
	191	collective works based on the Library.
	192
	193	In addition, mere aggregation of another work not based on the Library
	194	with the Library (or with a work based on the Library) on a volume of
	195	a storage or distribution medium does not bring the other work under
	196	the scope of this License.
	197
	198	3. You may opt to apply the terms of the ordinary GNU General Public
	199	License instead of this License to a given copy of the Library. To do
	200	this, you must alter all the notices that refer to this License, so
	201	that they refer to the ordinary GNU General Public License, version 2,
	202	instead of to this License. (If a newer version than version 2 of the
	203	ordinary GNU General Public License has appeared, then you can specify
	204	that version instead if you wish.) Do not make any other change in
	205	these notices.
	206
	207	Once this change is made in a given copy, it is irreversible for
	208	that copy, so the ordinary GNU General Public License applies to all
	209	subsequent copies and derivative works made from that copy.
	210
	211	This option is useful when you wish to copy part of the code of
	212	the Library into a program that is not a library.
	213
	214	4. You may copy and distribute the Library (or a portion or
	215	derivative of it, under Section 2) in object code or executable form
	216	under the terms of Sections 1 and 2 above provided that you accompany
	217	it with the complete corresponding machine-readable source code, which
	218	must be distributed under the terms of Sections 1 and 2 above on a
	219	medium customarily used for software interchange.
	220
	221	If distribution of object code is made by offering access to copy
	222	from a designated place, then offering equivalent access to copy the
	223	source code from the same place satisfies the requirement to
	224	distribute the source code, even though third parties are not
	225	compelled to copy the source along with the object code.
	226
	227	5. A program that contains no derivative of any portion of the
	228	Library, but is designed to work with the Library by being compiled or
	229	linked with it, is called a "work that uses the Library". Such a
	230	work, in isolation, is not a derivative work of the Library, and
	231	therefore falls outside the scope of this License.
	232
	233	However, linking a "work that uses the Library" with the Library
	234	creates an executable that is a derivative of the Library (because it
	235	contains portions of the Library), rather than a "work that uses the
	236	library". The executable is therefore covered by this License.
	237	Section 6 states terms for distribution of such executables.
	238
	239	When a "work that uses the Library" uses material from a header file
	240	that is part of the Library, the object code for the work may be a
	241	derivative work of the Library even though the source code is not.
	242	Whether this is true is especially significant if the work can be
	243	linked without the Library, or if the work is itself a library. The
	244	threshold for this to be true is not precisely defined by law.
	245
	246	If such an object file uses only numerical parameters, data
	247	structure layouts and accessors, and small macros and small inline
	248	functions (ten lines or less in length), then the use of the object
	249	file is unrestricted, regardless of whether it is legally a derivative
	250	work. (Executables containing this object code plus portions of the
	251	Library will still fall under Section 6.)
	252
	253	Otherwise, if the work is a derivative of the Library, you may
	254	distribute the object code for the work under the terms of Section 6.
	255	Any executables containing that work also fall under Section 6,
	256	whether or not they are linked directly with the Library itself.
	257
	258	6. As an exception to the Sections above, you may also compile or
	259	link a "work that uses the Library" with the Library to produce a
	260	work containing portions of the Library, and distribute that work
	261	under terms of your choice, provided that the terms permit
	262	modification of the work for the customer's own use and reverse
	263	engineering for debugging such modifications.
	264
	265	You must give prominent notice with each copy of the work that the
	266	Library is used in it and that the Library and its use are covered by
	267	this License. You must supply a copy of this License. If the work
	268	during execution displays copyright notices, you must include the
	269	copyright notice for the Library among them, as well as a reference
	270	directing the user to the copy of this License. Also, you must do one
	271	of these things:
	272
	273	a) Accompany the work with the complete corresponding
	274	machine-readable source code for the Library including whatever
	275	changes were used in the work (which must be distributed under
	276	Sections 1 and 2 above); and, if the work is an executable linked
	277	with the Library, with the complete machine-readable "work that
	278	uses the Library", as object code and/or source code, so that the
	279	user can modify the Library and then relink to produce a modified
	280	executable containing the modified Library. (It is understood
	281	that the user who changes the contents of definitions files in the
	282	Library will not necessarily be able to recompile the application
	283	to use the modified definitions.)
	284
	285	b) Accompany the work with a written offer, valid for at
	286	least three years, to give the same user the materials
	287	specified in Subsection 6a, above, for a charge no more
	288	than the cost of performing this distribution.
	289
	290	c) If distribution of the work is made by offering access to copy
	291	from a designated place, offer equivalent access to copy the above
	292	specified materials from the same place.
	293
	294	d) Verify that the user has already received a copy of these
	295	materials or that you have already sent this user a copy.
	296
	297	For an executable, the required form of the "work that uses the
	298	Library" must include any data and utility programs needed for
	299	reproducing the executable from it. However, as a special exception,
	300	the source code distributed need not include anything that is normally
	301	distributed (in either source or binary form) with the major
	302	components (compiler, kernel, and so on) of the operating system on
	303	which the executable runs, unless that component itself accompanies
	304	the executable.
	305
	306	It may happen that this requirement contradicts the license
	307	restrictions of other proprietary libraries that do not normally
	308	accompany the operating system. Such a contradiction means you cannot
	309	use both them and the Library together in an executable that you
	310	distribute.
	311
	312	7. You may place library facilities that are a work based on the
	313	Library side-by-side in a single library together with other library
	314	facilities not covered by this License, and distribute such a combined
	315	library, provided that the separate distribution of the work based on
	316	the Library and of the other library facilities is otherwise
	317	permitted, and provided that you do these two things:
	318
	319	a) Accompany the combined library with a copy of the same work
	320	based on the Library, uncombined with any other library
	321	facilities. This must be distributed under the terms of the
	322	Sections above.
	323
	324	b) Give prominent notice with the combined library of the fact
	325	that part of it is a work based on the Library, and explaining
	326	where to find the accompanying uncombined form of the same work.
	327
	328	8. You may not copy, modify, sublicense, link with, or distribute
	329	the Library except as expressly provided under this License. Any
	330	attempt otherwise to copy, modify, sublicense, link with, or
	331	distribute the Library is void, and will automatically terminate your
	332	rights under this License. However, parties who have received copies,
	333	or rights, from you under this License will not have their licenses
	334	terminated so long as such parties remain in full compliance.
	335
	336	9. You are not required to accept this License, since you have not
	337	signed it. However, nothing else grants you permission to modify or
	338	distribute the Library or its derivative works. These actions are
	339	prohibited by law if you do not accept this License. Therefore, by
	340	modifying or distributing the Library (or any work based on the
	341	Library), you indicate your acceptance of this License to do so, and
	342	all its terms and conditions for copying, distributing or modifying
	343	the Library or works based on it.
	344
	345	10. Each time you redistribute the Library (or any work based on the
	346	Library), the recipient automatically receives a license from the
	347	original licensor to copy, distribute, link with or modify the Library
	348	subject to these terms and conditions. You may not impose any further
	349	restrictions on the recipients' exercise of the rights granted herein.
	350	You are not responsible for enforcing compliance by third parties to
	351	this License.
	352
	353	11. If, as a consequence of a court judgment or allegation of patent
	354	infringement or for any other reason (not limited to patent issues),
	355	conditions are imposed on you (whether by court order, agreement or
	356	otherwise) that contradict the conditions of this License, they do not
	357	excuse you from the conditions of this License. If you cannot
	358	distribute so as to satisfy simultaneously your obligations under this
	359	License and any other pertinent obligations, then as a consequence you
	360	may not distribute the Library at all. For example, if a patent
	361	license would not permit royalty-free redistribution of the Library by
	362	all those who receive copies directly or indirectly through you, then
	363	the only way you could satisfy both it and this License would be to
	364	refrain entirely from distribution of the Library.
	365
	366	If any portion of this section is held invalid or unenforceable under any
	367	particular circumstance, the balance of the section is intended to apply,
	368	and the section as a whole is intended to apply in other circumstances.
	369
	370	It is not the purpose of this section to induce you to infringe any
	371	patents or other property right claims or to contest validity of any
	372	such claims; this section has the sole purpose of protecting the
	373	integrity of the free software distribution system which is
	374	implemented by public license practices. Many people have made
	375	generous contributions to the wide range of software distributed
	376	through that system in reliance on consistent application of that
	377	system; it is up to the author/donor to decide if he or she is willing
	378	to distribute software through any other system and a licensee cannot
	379	impose that choice.
	380
	381	This section is intended to make thoroughly clear what is believed to
	382	be a consequence of the rest of this License.
	383
	384	12. If the distribution and/or use of the Library is restricted in
	385	certain countries either by patents or by copyrighted interfaces, the
	386	original copyright holder who places the Library under this License may add
	387	an explicit geographical distribution limitation excluding those countries,
	388	so that distribution is permitted only in or among countries not thus
	389	excluded. In such case, this License incorporates the limitation as if
	390	written in the body of this License.
	391
	392	13. The Free Software Foundation may publish revised and/or new
	393	versions of the Library General Public License from time to time.
	394	Such new versions will be similar in spirit to the present version,
	395	but may differ in detail to address new problems or concerns.
	396
	397	Each version is given a distinguishing version number. If the Library
	398	specifies a version number of this License which applies to it and
	399	"any later version", you have the option of following the terms and
	400	conditions either of that version or of any later version published by
	401	the Free Software Foundation. If the Library does not specify a
	402	license version number, you may choose any version ever published by
	403	the Free Software Foundation.
	404
	405	14. If you wish to incorporate parts of the Library into other free
	406	programs whose distribution conditions are incompatible with these,
	407	write to the author to ask for permission. For software which is
	408	copyrighted by the Free Software Foundation, write to the Free
	409	Software Foundation; we sometimes make exceptions for this. Our
	410	decision will be guided by the two goals of preserving the free status
	411	of all derivatives of our free software and of promoting the sharing
	412	and reuse of software generally.
	413
	414	NO WARRANTY
	415
	416	15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
	417	WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
	418	EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
	419	OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
	420	KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
	421	IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	422	PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
	423	LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
	424	THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
	425
	426	16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
	427	WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
	428	AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
	429	FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
	430	CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
	431	LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
	432	RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
	433	FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
	434	SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
	435	DAMAGES.
	436
	437	END OF TERMS AND CONDITIONS
	438
	439	How to Apply These Terms to Your New Libraries
	440
	441	If you develop a new library, and you want it to be of the greatest
	442	possible use to the public, we recommend making it free software that
	443	everyone can redistribute and change. You can do so by permitting
	444	redistribution under these terms (or, alternatively, under the terms of the
	445	ordinary General Public License).
	446
	447	To apply these terms, attach the following notices to the library. It is
	448	safest to attach them to the start of each source file to most effectively
	449	convey the exclusion of warranty; and each file should have at least the
	450	"copyright" line and a pointer to where the full notice is found.
	451
	452	<one line to give the library's name and a brief idea of what it does.>
	453	Copyright (C) <year> <name of author>
	454
	455	This library is free software; you can redistribute it and/or
	456	modify it under the terms of the GNU Library General Public
	457	License as published by the Free Software Foundation; either
	458	version 2 of the License, or (at your option) any later version.
	459
	460	This library is distributed in the hope that it will be useful,
	461	but WITHOUT ANY WARRANTY; without even the implied warranty of
	462	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	463	Library General Public License for more details.
	464
	465	You should have received a copy of the GNU Library General Public
	466	License along with this library; if not, write to the Free
	467	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	468
	469	Also add information on how to contact you by electronic and paper mail.
	470
	471	You should also get your employer (if you work as a programmer) or your
	472	school, if any, to sign a "copyright disclaimer" for the library, if
	473	necessary. Here is a sample; alter the names:
	474
	475	Yoyodyne, Inc., hereby disclaims all copyright interest in the
	476	library `Frob' (a library for tweaking knobs) written by James Random Hacker.
	477
	478	<signature of Ty Coon>, 1 April 1990
	479	Ty Coon, President of Vice
	480
	481	That's all there is to it!

src/common/genericBinaryFiles/elf/libelfWin32/INSTALL created 644 +176 0

@@ -0,0 +1,176
	1	Basic Installation
	2	==================
	3
	4	These are generic installation instructions.
	5
	6	The `configure' shell script attempts to guess correct values for
	7	various system-dependent variables used during compilation. It uses
	8	those values to create a `Makefile' in each directory of the package.
	9	It may also create one or more `.h' files containing system-dependent
	10	definitions. Finally, it creates a shell script `config.status' that
	11	you can run in the future to recreate the current configuration, a file
	12	`config.cache' that saves the results of its tests to speed up
	13	reconfiguring, and a file `config.log' containing compiler output
	14	(useful mainly for debugging `configure').
	15
	16	If you need to do unusual things to compile the package, please try
	17	to figure out how `configure' could check whether to do them, and mail
	18	diffs or instructions to the address given in the `README' so they can
	19	be considered for the next release. If at some point `config.cache'
	20	contains results you don't want to keep, you may remove or edit it.
	21
	22	The file `configure.in' is used to create `configure' by a program
	23	called `autoconf'. You only need `configure.in' if you want to change
	24	it or regenerate `configure' using a newer version of `autoconf'.
	25
	26	The simplest way to compile this package is:
	27
	28	1. `cd' to the directory containing the package's source code and type
	29	`./configure' to configure the package for your system. If you're
	30	using `csh' on an old version of System V, you might need to type
	31	`sh ./configure' instead to prevent `csh' from trying to execute
	32	`configure' itself.
	33
	34	Running `configure' takes awhile. While running, it prints some
	35	messages telling which features it is checking for.
	36
	37	2. Type `make' to compile the package.
	38
	39	3. Optionally, type `make check' to run any self-tests that come with
	40	the package.
	41
	42	4. Type `make install' to install the programs and any data files and
	43	documentation.
	44
	45	5. You can remove the program binaries and object files from the
	46	source code directory by typing `make clean'. To also remove the
	47	files that `configure' created (so you can compile the package for
	48	a different kind of computer), type `make distclean'. There is
	49	also a `make maintainer-clean' target, but that is intended mainly
	50	for the package's developers. If you use it, you may have to get
	51	all sorts of other programs in order to regenerate files that came
	52	with the distribution.
	53
	54	Compilers and Options
	55	=====================
	56
	57	Some systems require unusual options for compilation or linking that
	58	the `configure' script does not know about. You can give `configure'
	59	initial values for variables by setting them in the environment. Using
	60	a Bourne-compatible shell, you can do that on the command line like
	61	this:
	62	CC=c89 CFLAGS=-O2 LIBS=-lposix ./configure
	63
	64	Or on systems that have the `env' program, you can do it like this:
	65	env CPPFLAGS=-I/usr/local/include LDFLAGS=-s ./configure
	66
	67	Compiling For Multiple Architectures
	68	====================================
	69
	70	You can compile the package for more than one kind of computer at the
	71	same time, by placing the object files for each architecture in their
	72	own directory. To do this, you must use a version of `make' that
	73	supports the `VPATH' variable, such as GNU `make'. `cd' to the
	74	directory where you want the object files and executables to go and run
	75	the `configure' script. `configure' automatically checks for the
	76	source code in the directory that `configure' is in and in `..'.
	77
	78	If you have to use a `make' that does not supports the `VPATH'
	79	variable, you have to compile the package for one architecture at a time
	80	in the source code directory. After you have installed the package for
	81	one architecture, use `make distclean' before reconfiguring for another
	82	architecture.
	83
	84	Installation Names
	85	==================
	86
	87	By default, `make install' will install the package's files in
	88	`/usr/local/bin', `/usr/local/man', etc. You can specify an
	89	installation prefix other than `/usr/local' by giving `configure' the
	90	option `--prefix=PATH'.
	91
	92	You can specify separate installation prefixes for
	93	architecture-specific files and architecture-independent files. If you
	94	give `configure' the option `--exec-prefix=PATH', the package will use
	95	PATH as the prefix for installing programs and libraries.
	96	Documentation and other data files will still use the regular prefix.
	97
	98	If the package supports it, you can cause programs to be installed
	99	with an extra prefix or suffix on their names by giving `configure' the
	100	option `--program-prefix=PREFIX' or `--program-suffix=SUFFIX'.
	101
	102	Optional Features
	103	=================
	104
	105	Some packages pay attention to `--enable-FEATURE' options to
	106	`configure', where FEATURE indicates an optional part of the package.
	107	They may also pay attention to `--with-PACKAGE' options, where PACKAGE
	108	is something like `gnu-as' or `x' (for the X Window System). The
	109	`README' should mention any `--enable-' and `--with-' options that the
	110	package recognizes.
	111
	112	For packages that use the X Window System, `configure' can usually
	113	find the X include and library files automatically, but if it doesn't,
	114	you can use the `configure' options `--x-includes=DIR' and
	115	`--x-libraries=DIR' to specify their locations.
	116
	117	Specifying the System Type
	118	==========================
	119
	120	There may be some features `configure' can not figure out
	121	automatically, but needs to determine by the type of host the package
	122	will run on. Usually `configure' can figure that out, but if it prints
	123	a message saying it can not guess the host type, give it the
	124	`--host=TYPE' option. TYPE can either be a short name for the system
	125	type, such as `sun4', or a canonical name with three fields:
	126	CPU-COMPANY-SYSTEM
	127
	128	See the file `config.sub' for the possible values of each field. If
	129	`config.sub' isn't included in this package, then this package doesn't
	130	need to know the host type.
	131
	132	If you are building compiler tools for cross-compiling, you can also
	133	use the `--target=TYPE' option to select the type of system they will
	134	produce code for and the `--build=TYPE' option to select the type of
	135	system on which you are compiling the package.
	136
	137	Sharing Defaults
	138	================
	139
	140	If you want to set default values for `configure' scripts to share,
	141	you can create a site shell script called `config.site' that gives
	142	default values for variables like `CC', `cache_file', and `prefix'.
	143	`configure' looks for `PREFIX/share/config.site' if it exists, then
	144	`PREFIX/etc/config.site' if it exists. Or, you can set the
	145	`CONFIG_SITE' environment variable to the location of the site script.
	146	A warning: not all `configure' scripts look for a site script.
	147
	148	Operation Controls
	149	==================
	150
	151	`configure' recognizes the following options to control how it
	152	operates.
	153
	154	`--cache-file=FILE'
	155	Use and save the results of the tests in FILE instead of
	156	`./config.cache'. Set FILE to `/dev/null' to disable caching, for
	157	debugging `configure'.
	158
	159	`--help'
	160	Print a summary of the options to `configure', and exit.
	161
	162	`--quiet'
	163	`--silent'
	164	`-q'
	165	Do not print messages saying which checks are being made.
	166
	167	`--srcdir=DIR'
	168	Look for the package's source code in directory DIR. Usually
	169	`configure' can determine that directory automatically.
	170
	171	`--version'
	172	Print the version of Autoconf used to generate the `configure'
	173	script, and exit.
	174
	175	`configure' also accepts some other, not widely useful, options.
	176

src/common/genericBinaryFiles/elf/libelfWin32/MANIFEST created 644 +96 0

@@ -0,0 +1,96
	1	25275 COPYING.LIB
	2	35406 ChangeLog
	3	7462 INSTALL
	4	5908 Makefile.in
	5	13232 README
	6	7 VERSION
	7	2955 acconfig.h
	8	9381 aclocal.m4
	9	43611 config.guess
	10	3987 config.h.in
	11	31160 config.sub
	12	110753 configure
	13	11736 configure.in
	14	2186 install-sh
	15	4798 lib/32.fsize.c
	16	1556 lib/32.getehdr.c
	17	1557 lib/32.getphdr.c
	18	1665 lib/32.getshdr.c
	19	2181 lib/32.newehdr.c
	20	3055 lib/32.newphdr.c
	21	12322 lib/32.xlatetof.c
	22	14221 lib/64.xlatetof.c
	23	8012 lib/Makefile.in
	24	4010 lib/Makefile.w32
	25	1119 lib/assert.c
	26	10463 lib/begin.c
	27	1685 lib/build.bat
	28	3566 lib/byteswap.h
	29	3937 lib/checksum.c
	30	1901 lib/cntl.c
	31	4851 lib/config.h.w32
	32	12554 lib/cook.c
	33	1183 lib/data.c
	34	24585 lib/elf_repl.h
	35	2899 lib/end.c
	36	2137 lib/errmsg.c
	37	1037 lib/errno.c
	38	6222 lib/errors.h
	39	8107 lib/ext_types.h
	40	997 lib/fill.c
	41	2400 lib/flag.c
	42	5103 lib/gelf.h
	43	4151 lib/gelfehdr.c
	44	3965 lib/gelfphdr.c
	45	3758 lib/gelfshdr.c
	46	9456 lib/gelftrans.c
	47	1175 lib/getarhdr.c
	48	1380 lib/getaroff.c
	49	2421 lib/getarsym.c
	50	1096 lib/getbase.c
	51	3841 lib/getdata.c
	52	1353 lib/getident.c
	53	1449 lib/getscn.c
	54	1212 lib/hash.c
	55	2562 lib/input.c
	56	1088 lib/kind.c
	57	1214 lib/libelf.def
	58	9050 lib/libelf.h
	59	1505 lib/memset.c
	60	1098 lib/ndxscn.c
	61	1558 lib/newdata.c
	62	3488 lib/newscn.c
	63	1356 lib/next.c
	64	1607 lib/nextscn.c
	65	5898 lib/nlist.c
	66	1452 lib/nlist.h
	67	5071 lib/opt.delscn.c
	68	13133 lib/private.h
	69	1286 lib/rand.c
	70	2543 lib/rawdata.c
	71	1541 lib/rawfile.c
	72	3393 lib/strptr.c
	73	2285 lib/swap64.c
	74	3812 lib/sys_elf.h.in
	75	4066 lib/sys_elf.h.w32
	76	26008 lib/update.c
	77	6884 lib/verdef.h
	78	1586 lib/verdef_32_tof.c
	79	1586 lib/verdef_32_tom.c
	80	1614 lib/verdef_64_tof.c
	81	1614 lib/verdef_64_tom.c
	82	7135 lib/verneed.h
	83	1435 lib/version.c
	84	4425 lib/x.elfext.c
	85	2721 lib/x.movscn.c
	86	2870 lib/x.remscn.c
	87	254 libelf.pc.in
	88	619 mkinstalldirs
	89	4593 po/Makefile.in
	90	8748 po/de.gmo
	91	52 po/de.msg
	92	11332 po/de.po
	93	3011 po/gmo2msg.c
	94	6483 po/libelf.pot
	95	10 po/stamp-po
	96	10 stamp-h.in

src/common/genericBinaryFiles/elf/libelfWin32/README created 644 +332 0

@@ -0,0 +1,332
	1	This is the public release of libelf-0.8.13, a free ELF object
	2	file access library. If you have problems with applications
	3	that use libelf and work with the commercial (SVR4, Solaris)
	4	version but not with this one, please contact me.
	5
	6	IMPORTANT NOTE: If you have libelf-0.5.2 installed, you probably
	7	have a file .../include/elf.h that contains the single line
	8	``#include <libelf/elf.h>''. REMOVE THIS FILE BEFORE YOU RUN
	9	configure.
	10
	11	Installation is straightforward - the package is autoconf'ed. Just do
	12	``cd libelf-0.8.13; ./configure; make; make install''. Header files
	13	will be installed in .../include/libelf/. If your system does not
	14	provide its own versions of libelf.h, nlist.h or gelf.h, ``make
	15	install'' will add the missing headers. If you prefer not to have
	16	these files installed in /usr/include, use ``--disable-compat'' and
	17	add ``-I /usr/include/libelf'' to your CFLAGS when compiling
	18	libelf-based programs.
	19
	20	Note to distribution makers: You can install libelf in a separate root
	21	hierarchy by using the command ``make instroot=/my/root install''.
	22	You should also use the ``--enable-compat'' configure option in that
	23	case, or run ``make instroot=/my/root install-compat'' manually, to
	24	install all the required header files.
	25
	26	If you are running Linux with libc 5.* as the default C library,
	27	and you plan to use the 64-bit functions, you must either use
	28	``-I.../include/libelf'', or remove /usr/include/libelf.h and use
	29	``--enable-compat'' when running configure. Libc 6.* (aka glibc2)
	30	doesn't have its own <libelf.h>, <nlist.h> or <gelf.h>.
	31
	32	You need an ANSI/ISO C compiler to build libelf. Gcc is optimal.
	33
	34	On some systems (in particular, Solaris and all variants of Linux),
	35	``make'' will try to build a shared library. If you run into problems
	36	on your system, please pass ``--disable-shared'' to configure.
	37	If you build a shared library and want it to be installed as
	38	``libelf-0.8.13.so'' rather than ``libelf.so.0.8.13'', please use
	39	``./configure --enable-gnu-names''. Other files, e.g. ``libelf.so'' and
	40	``libelf.so.0'' are NOT affected.
	41
	42	Another configure option, ``--enable-debug'', adds debugging code to
	43	libelf; if you don't run into problems, you will probably not need it.
	44
	45	When creating an ELF shared library, it is possible to add references
	46	to other shared libraries in the DYNAMIC section of the resulting
	47	file. The make variable DEPSHLIBS contains a list of libraries to add.
	48	It is set to ``-lc'' on Linux systems, and empty otherwise. To
	49	override this setting, use something like ``make DEPSHLIBS="-la -lb"''.
	50	For Linux, `-lc' is included automagically.
	51
	52	NLS is available and enabled by default. To turn it off, pass the
	53	``--disable-nls'' option to configure.
	54
	55	Libelf can use gettext or catgets for accessing message
	56	catalogs. If gettext is available AND is part of libc (i.e. not
	57	in a separate library), it will be used. Otherwise, configure
	58	will look for catgets. If you have gettext in a separate
	59	library and want to use it, you should pass the library's name
	60	to configure, e.g. ``LIBS=-lintl ./configure''. Note that you
	61	MUST link your libelf-based applications with -lintl then,
	62	which is probably not what you want, or change the DEPSHLIBS variable
	63	described above (in case you're building a shared library).
	64
	65	If you have GNU gettext 0.10 installed on your system, and if GNU gettext
	66	runs on top of the catgets interface (rather old Linux systems, using
	67	libc5), configure will refuse to use it and use catgets instead. If you
	68	absolutely want to use GNU gettext, go ahead and rebuild it (which is
	69	IMHO a good idea in general in this case):
	70
	71	cd .../gettext-0.10
	72	ac_cv_func_catgets=no ac_cv_func_gettext=no ./configure
	73	make
	74	make install
	75
	76	After that, return to the libelf build directory, remove
	77	config.cache, and start over.
	78
	79	* Large File Support (LFS) applications *
	80
	81	Some 32-bit systems support files that are larger than the address space
	82	of the architecture. On these, the `off_t' data type may have 32 or
	83	64 bits, depending on the API you choose. Since off_t is also part of
	84	the libelf API, in particular the Elf_Data and Elf_Arhdr structures,
	85	an application compiled with large file support will need a version of
	86	libelf that has also been compiled with LFS; otherwise, it won't work
	87	correctly. Similarly, a program compiled without LFS needs a library
	88	compiled without LFS.
	89
	90	Note that libelf is currently unable to process large files on 32-bit
	91	architectures, whether you compile it for LFS or not, for the simple
	92	reason that the files won't fit into the processes' address space.
	93	Therefore, libelf is compiled without LFS by default. It can of course
	94	read and write ELF files for 64-bit architectures, but they will be
	95	limited in length on a 32-bit system.
	96
	97	You may compile libelf with large file support by setting CPPFLAGS at
	98	configuration time:
	99
	100	CPPFLAGS=`getconf LFS_CFLAGS` ./configure
	101
	102	But I really, really recommend you don't, because it breaks binary
	103	compatibility with existing libelf based applications.
	104
	105	* 64-bit support *
	106
	107	Starting with libelf-0.7.0, libelf also supports 64-bit ELF files.
	108	This is enabled by default unless your system (or your compiler) does
	109	not support 64-bit integers, or lacks 64-bit declarations in <elf.h>.
	110	If you have problems building with 64-bit support, please do
	111
	112	./configure --disable-elf64
	113
	114	for the moment, and contact me. Please note that I haven't tested 64-bit
	115	support much. There are still some unresolved problems, e.g. IRIX
	116	uses different Elf64_Rel and Elf64_Rela structures (they replaced the
	117	r_info member), and the enumeration values for Elf_Type differ from
	118	the commercial (SVR4) implementation of libelf - they broke binary
	119	compatibility for no good reason, and I'm not willing to follow their
	120	footsteps. The result is that libelf-0.7.* ist upward compatible with
	121	libelf-0.6.4 (as it should be) but INCOMPATIBLE WITH SVR4 LIBELF. If you
	122	have both versions installed, you'd better make sure that you link with
	123	the library that matches the <libelf.h> you're #include'ing.
	124
	125	* Symbol Versioning *
	126
	127	Libelf >= 0.8.0 supports the data structures and definitions used for
	128	symbol versioning on Solaris and Linux, in particular, the Elfxx_Verdef,
	129	Elfxx_Verdaux, Elfxx_Verneed, Elfxx_Vernaux and Elfxx_Versym structures
	130	and the SHT_XXX_verdef, SHT_XXX_verneed and SHT_XXX_versym section types
	131	(where `xx' is either `32' or `64', and `XXX' is either `SUNW' or `GNU').
	132	Libelf now translates versioning sections to/from their external
	133	representation properly (earlier versions left them in `raw' format,
	134	with the data type set to ELF_T_BYTE). This may cause problems on
	135	systems which use the same (OS-specific) section types for different
	136	purposes. The configure program tries to figure out if your OS uses
	137	versioning; if that check fails, you can use
	138
	139	./configure --disable-versioning
	140
	141	to turn off versioning translation support.
	142
	143	* W32 Support *
	144
	145	There is now some support for building on W32 systems (requires Microsoft
	146	VC++). In order to build a W32 DLL, cd into the `lib' subdirectory, edit
	147	build.bat if necessary (it needs the path to your compiler binaries) and
	148	run it. If you're lucky, libelf.dll and the import/export libraries will
	149	be built. If not, please drop me a line.
	150
	151	I tested it on XP Pro (SP2), using VC++ 2005 Express Edition.
	152	Apparently, Visual Studio .NET 2003 works fine as well.
	153
	154	Various notes regarding the W32 port:
	155
	156	- When you open() an ELF file, remember to use the O_BINARY flag.
	157	- You may have to add /MD to the linker command line.
	158
	159	* Missing things *
	160
	161	* There is no documentation. You can use the Solaris
	162	manpages instead (available at http://docs.sun.com/).
	163	The ELF file format is described in several places;
	164	among them Suns "Linker and Libraries Guide" and the
	165	"System V Application Binary Interface" documents;
	166	http://www.caldera.com/developer/devspecs/gabi41.pdf and
	167	http://www.caldera.com/developer/gabi/ are probably good
	168	starting points. Processor-specific documentation is spread
	169	across a number of `Processor Supplement' documents, one
	170	for each architecture; you'll have to use a search engine to
	171	find them.
	172
	173	* The COFF file format is not understood. This is so obsolete
	174	that it will probably never be implemented.
	175
	176	* nlist(3) is incomplete; the n_type and n_sclass
	177	members of struct nl are set to zero even if type
	178	(that is, debug) information is available.
	179
	180	* Libelf does not translate Solaris' `Move' and `Syminfo'
	181	sections. You can read them using elf_getdata(), but you'll
	182	only get raw (untranslated) bytes.
	183
	184	Changes since 0.8.12:
	185
	186	* New function elf_getaroff().
	187
	188	* Build fixes.
	189
	190	Changes since 0.8.11:
	191
	192	* Due to some unfortunate confusion, the elf_getphnum(),
	193	elf_getshnum() and elf_getshstrndx() are not compatible
	194	between libelf implementations. Therefore, the developers
	195	decided to replace them with new functions: elf_getphdrnum(),
	196	elf_getshdrnum() and elf_getshdrstrndx(), which will always
	197	return -1 on failure and 0 on success. Code using the old
	198	interface should be upgraded to increase portability.
	199
	200	Changes since 0.8.10:
	201
	202	* Fixed a bug in elf_rawfile().
	203	* If you use ELF_F_LAYOUT together with ELF_F_LAYOUT_OVERLAP,
	204	elf_update() will now tolerate overlapping sections.
	205
	206	Changes since 0.8.9:
	207
	208	* Ported to QNX Neutrino.
	209	* Fixed Windows build errors.
	210	* Parallel (make -j) installation should work now.
	211
	212	* It's now possible to enable and disable select sanity checks
	213	libelf performs. Currently, this affects the "NUL terminated
	214	string table entry" check performed in elf_strptr(). By
	215	default, the function will return an error if the string
	216	requested is not properly terminated - because some
	217	applications might dump core otherwise. If you configure
	218	libelf with `--disable-sanity-checks', however, the check
	219	(and, in the future, probably others as well) is disabled
	220	by default. You can still turn it on and off at runtime by
	221	setting the LIBELF_SANITY_CHECKS environment variable to
	222	an integer value:
	223
	224	# disable all sanity checks
	225	export LIBELF_SANITY_CHECKS=0
	226
	227	# enable all sanity checks
	228	export LIBELF_SANITY_CHECKS=-1
	229
	230	Each bit of the value corresponds to a particular check,
	231	so you could use LIBELF_SANITY_CHECKS=1 to enable only
	232	the elf_strptr() check. You may also use a value in hex
	233	(0x...) or octal (0...) format.
	234
	235	Changes since 0.8.8:
	236
	237	* Improved translator for symbol versioning sections.
	238	* The W32 library is now built in the `lib' subdirectory.
	239	* Windows DLLs should work now.
	240
	241	Changes since 0.8.6:
	242
	243	* added elf_getphnum().
	244	* added elf_getshnum().
	245	* added elf_getshstrndx().
	246	* added elfx_update_shstrndx().
	247	* handle interrupted reads/writes more gracefully.
	248	* added (partial) support for unusual e_[ps]hentsize values.
	249	* fixed the bugs introduced in 0.8.7.
	250
	251	Changes since 0.8.5:
	252
	253	* added W32 support.
	254	* added workaround for alignment errors in archive members.
	255	* my email address has changed again ;)
	256
	257	Changes since 0.8.4:
	258
	259	* elf_strptr() should now work more safely with fragmented
	260	or badly formatted string tables.
	261
	262	Changes since 0.8.3:
	263
	264	* Fixed a bug in elf_update() that was introduced in 0.8.3.
	265
	266	Changes since 0.8.2:
	267
	268	* Should compile on MacOSX now.
	269
	270	* Can read and write files with more than 65280 sections
	271
	272	* Tries to handle 64-bit ELF files that use 8-byte hash table
	273	entries. In particular, libelf tries to guess the data type in
	274	elf_getdata(), and doesn't override sh_entsize in elf_update()
	275	any longer. If you want the library to pick the entry size,
	276	you must set its value to 0 before you call elf_update().
	277
	278	* No longer dumps core in elf_update() when a versioning section
	279	has no data. Instead, it returns an error message. Note that
	280	you're supposed to provide a valid d_buf for any section, unless
	281	it's empty or has SHT_NOBITS type.
	282
	283	* Building a shared library is now the default (if supported).
	284
	285	Changes since 0.8.0:
	286
	287	* Corrected typo in lib/{32,64}.xlatetof.c that sometimes
	288	caused a compilation failure.
	289
	290	* Use open(name, O_RDONLY\|O_BINARY) in lib/nlist.c.
	291
	292	Changes since 0.7.0:
	293
	294	* I implemented the gelf_* interface, as found on Solaris.
	295	I don't know whether it's compatible -- the Solaris manpage
	296	isn't very specific, so I had to guess return values etc. in
	297	some cases.
	298
	299	* Added elf{32,64}_checksum (supposed to be compatible with
	300	Solaris).
	301
	302	* Added symbol versioning support.
	303
	304	Changes since 0.6.4:
	305
	306	* Fixed configure for IRIX systems
	307	* Added check for truncated archive members
	308	* Added check for misaligned SHDR/PHDR tables
	309	* Support for building libelf together with GNU libc
	310	* Added elf_memory(3)
	311	* Added 64-bit support
	312
	313	Changes since 0.5.2:
	314
	315	* some bug fixes
	316	* mmap support
	317	* new directory layout
	318	* There is a new function, elf_delscn(), that deletes
	319	a section from an ELF file. It also adjusts the
	320	sh_link and sh_info members in the section header
	321	table, if (and ONLY if) the ELF standard indicates
	322	that these values are section indices. References
	323	to the deleted section will be cleared, so be careful.
	324	* my email address has changed ;)
	325
	326	Where to get libelf:
	327
	328	ftp://ftp.ibiblio.org/pub/Linux/libs/
	329	http://www.mr511.de/software/
	330
	331	Michael "Tired" Riepe
	332	<libelf@mr511.de>

src/common/genericBinaryFiles/elf/libelfWin32/VERSION created 644 +1 0

	@@ -0,0 +1,1
				1	0.8.13

src/common/genericBinaryFiles/elf/libelfWin32/include/libelf/byteswap.h created 644 +95 0

@@ -0,0 +1,95
	1	/*
	2	byteswap.h - functions and macros for byte swapping.
	3	Copyright (C) 1995 - 2001 Michael Riepe
	4
	5	This library is free software; you can redistribute it and/or
	6	modify it under the terms of the GNU Library General Public
	7	License as published by the Free Software Foundation; either
	8	version 2 of the License, or (at your option) any later version.
	9
	10	This library is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	13	Library General Public License for more details.
	14
	15	You should have received a copy of the GNU Library General Public
	16	License along with this library; if not, write to the Free Software
	17	Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
	18	*/
	19
	20	/* @(#) $Id: byteswap.h,v 1.7 2008/05/23 08:15:34 michael Exp $ */
	21
	22	#ifndef _BYTESWAP_H
	23	#define _BYTESWAP_H
	24
	25	#define lu(from,i,s) (((__libelf_u32_t)((unsigned char*)(from))[i])<<(s))
	26	#define li(from,i,s) (((__libelf_i32_t)(( signed char*)(from))[i])<<(s))
	27
	28	#define __load_u16L(from) ((__libelf_u32_t) \
	29	(lu(from,1,8) \| lu(from,0,0)))
	30	#define __load_u16M(from) ((__libelf_u32_t) \
	31	(lu(from,0,8) \| lu(from,1,0)))
	32	#define __load_i16L(from) ((__libelf_i32_t) \
	33	(li(from,1,8) \| lu(from,0,0)))
	34	#define __load_i16M(from) ((__libelf_i32_t) \
	35	(li(from,0,8) \| lu(from,1,0)))
	36
	37	#define __load_u32L(from) ((__libelf_u32_t) \
	38	(lu(from,3,24) \| lu(from,2,16) \| lu(from,1,8) \| lu(from,0,0)))
	39	#define __load_u32M(from) ((__libelf_u32_t) \
	40	(lu(from,0,24) \| lu(from,1,16) \| lu(from,2,8) \| lu(from,3,0)))
	41	#define __load_i32L(from) ((__libelf_i32_t) \
	42	(li(from,3,24) \| lu(from,2,16) \| lu(from,1,8) \| lu(from,0,0)))
	43	#define __load_i32M(from) ((__libelf_i32_t) \
	44	(li(from,0,24) \| lu(from,1,16) \| lu(from,2,8) \| lu(from,3,0)))
	45
	46	#define su(to,i,v,s) (((char*)(to))[i]=((__libelf_u32_t)(v)>>(s)))
	47	#define si(to,i,v,s) (((char*)(to))[i]=((__libelf_i32_t)(v)>>(s)))
	48
	49	#define __store_u16L(to,v) \
	50	(su(to,1,v,8), su(to,0,v,0))
	51	#define __store_u16M(to,v) \
	52	(su(to,0,v,8), su(to,1,v,0))
	53	#define __store_i16L(to,v) \
	54	(si(to,1,v,8), si(to,0,v,0))
	55	#define __store_i16M(to,v) \
	56	(si(to,0,v,8), si(to,1,v,0))
	57
	58	#define __store_u32L(to,v) \
	59	(su(to,3,v,24), su(to,2,v,16), su(to,1,v,8), su(to,0,v,0))
	60	#define __store_u32M(to,v) \
	61	(su(to,0,v,24), su(to,1,v,16), su(to,2,v,8), su(to,3,v,0))
	62	#define __store_i32L(to,v) \
	63	(si(to,3,v,24), si(to,2,v,16), si(to,1,v,8), si(to,0,v,0))
	64	#define __store_i32M(to,v) \
	65	(si(to,0,v,24), si(to,1,v,16), si(to,2,v,8), si(to,3,v,0))
	66
	67	#if __LIBELF64
	68
	69	/*
	70	* conversion functions from swap64.c
	71	*/
	72	extern __libelf_u64_t _elf_load_u64L(const unsigned char *from);
	73	extern __libelf_u64_t _elf_load_u64M(const unsigned char *from);
	74	extern __libelf_i64_t _elf_load_i64L(const unsigned char *from);
	75	extern __libelf_i64_t _elf_load_i64M(const unsigned char *from);
	76	extern void _elf_store_u64L(unsigned char *to, __libelf_u64_t v);
	77	extern void _elf_store_u64M(unsigned char *to, __libelf_u64_t v);
	78	extern void _elf_store_i64L(unsigned char *to, __libelf_u64_t v);
	79	extern void _elf_store_i64M(unsigned char *to, __libelf_u64_t v);
	80
	81	/*
	82	* aliases for existing conversion code
	83	*/
	84	#define __load_u64L _elf_load_u64L
	85	#define __load_u64M _elf_load_u64M
	86	#define __load_i64L _elf_load_i64L
	87	#define __load_i64M _elf_load_i64M
	88	#define __store_u64L _elf_store_u64L
	89	#define __store_u64M _elf_store_u64M
	90	#define __store_i64L _elf_store_i64L
	91	#define __store_i64M _elf_store_i64M
	92
	93	#endif /* __LIBELF64 */
	94
	95	#endif /* _BYTESWAP_H */

src/common/genericBinaryFiles/elf/libelfWin32/include/libelf/elf_repl.h created 644 +1002 0

This diff has been collapsed as it changes many lines, (1002 lines changed) Show them Hide them
	@@ -0,0 +1,1002
		1	/*
		2	* elf_repl.h - public header file for systems that lack it.
		3	* Copyright (C) 1995 - 2006 Michael Riepe
		4	*
		5	* This library is free software; you can redistribute it and/or
		6	* modify it under the terms of the GNU Library General Public
		7	* License as published by the Free Software Foundation; either
		8	* version 2 of the License, or (at your option) any later version.
		9	*
		10	* This library is distributed in the hope that it will be useful,
		11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
		13	* Library General Public License for more details.
		14	*
		15	* You should have received a copy of the GNU Library General Public
		16	* License along with this library; if not, write to the Free Software
		17	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
		18	*/
		19
		20	/* @(#) $Id: elf_repl.h,v 1.22 2009/11/01 13:04:19 michael Exp $ */
		21
		22	/*
		23	* NEVER INCLUDE THIS FILE DIRECTLY - USE <libelf.h> INSTEAD!
		24	*/
		25
		26	#ifndef _ELF_REPL_H
		27	#define _ELF_REPL_H
		28
		29	#ifdef __cplusplus
		30	extern "C" {
		31	#endif /* __cplusplus */
		32
		33	/*
		34	* Scalar data types
		35	*/
		36	typedef __libelf_u32_t Elf32_Addr;
		37	typedef __libelf_u16_t Elf32_Half;
		38	typedef __libelf_u32_t Elf32_Off;
		39	typedef __libelf_i32_t Elf32_Sword;
		40	typedef __libelf_u32_t Elf32_Word;
		41
		42	#define ELF32_FSZ_ADDR 4
		43	#define ELF32_FSZ_HALF 2
		44	#define ELF32_FSZ_OFF 4
		45	#define ELF32_FSZ_SWORD 4
		46	#define ELF32_FSZ_WORD 4
		47
		48	#if __LIBELF64
		49
		50	typedef __libelf_u64_t Elf64_Addr;
		51	typedef __libelf_u16_t Elf64_Half;
		52	typedef __libelf_u64_t Elf64_Off;
		53	typedef __libelf_i32_t Elf64_Sword;
		54	typedef __libelf_u32_t Elf64_Word;
		55	typedef __libelf_i64_t Elf64_Sxword;
		56	typedef __libelf_u64_t Elf64_Xword;
		57
		58	#define ELF64_FSZ_ADDR 8
		59	#define ELF64_FSZ_HALF 2
		60	#define ELF64_FSZ_OFF 8
		61	#define ELF64_FSZ_SWORD 4
		62	#define ELF64_FSZ_WORD 4
		63	#define ELF64_FSZ_SXWORD 8
		64	#define ELF64_FSZ_XWORD 8
		65
		66	/*
		67	* Blame Sun for this...
		68	*/
		69	typedef __libelf_u64_t Elf64_Lword;
		70	typedef __libelf_u64_t Elf32_Lword;
		71
		72	#endif /* __LIBELF64 */
		73
		74	/*
		75	* ELF header
		76	*/
		77	#define EI_NIDENT 16
		78
		79	typedef struct {
		80	unsigned char e_ident[EI_NIDENT];
		81	Elf32_Half e_type;
		82	Elf32_Half e_machine;
		83	Elf32_Word e_version;
		84	Elf32_Addr e_entry;
		85	Elf32_Off e_phoff;
		86	Elf32_Off e_shoff;
		87	Elf32_Word e_flags;
		88	Elf32_Half e_ehsize;
		89	Elf32_Half e_phentsize;
		90	Elf32_Half e_phnum;
		91	Elf32_Half e_shentsize;
		92	Elf32_Half e_shnum;
		93	Elf32_Half e_shstrndx;
		94	} Elf32_Ehdr;
		95
		96	#if __LIBELF64
		97	typedef struct {
		98	unsigned char e_ident[EI_NIDENT];
		99	Elf64_Half e_type;
		100	Elf64_Half e_machine;
		101	Elf64_Word e_version;
		102	Elf64_Addr e_entry;
		103	Elf64_Off e_phoff;
		104	Elf64_Off e_shoff;
		105	Elf64_Word e_flags;
		106	Elf64_Half e_ehsize;
		107	Elf64_Half e_phentsize;
		108	Elf64_Half e_phnum;
		109	Elf64_Half e_shentsize;
		110	Elf64_Half e_shnum;
		111	Elf64_Half e_shstrndx;
		112	} Elf64_Ehdr;
		113	#endif /* __LIBELF64 */
		114
		115	/*
		116	* e_ident
		117	*/
		118	#define EI_MAG0 0
		119	#define EI_MAG1 1
		120	#define EI_MAG2 2
		121	#define EI_MAG3 3
		122	#define EI_CLASS 4
		123	#define EI_DATA 5
		124	#define EI_VERSION 6
		125	#define EI_OSABI 7
		126	#define EI_ABIVERSION 8
		127	#define EI_PAD 9
		128
		129	#define ELFMAG0 0x7f
		130	#define ELFMAG1 'E'
		131	#define ELFMAG2 'L'
		132	#define ELFMAG3 'F'
		133	#define ELFMAG "\177ELF"
		134	#define SELFMAG 4
		135
		136	/*
		137	* e_ident[EI_CLASS]
		138	*/
		139	#define ELFCLASSNONE 0
		140	#define ELFCLASS32 1
		141	#define ELFCLASS64 2
		142	#define ELFCLASSNUM 3
		143
		144	/*
		145	* e_ident[EI_DATA]
		146	*/
		147	#define ELFDATANONE 0
		148	#define ELFDATA2LSB 1
		149	#define ELFDATA2MSB 2
		150	#define ELFDATANUM 3
		151
		152	/*
		153	* e_ident[EI_OSABI]
		154	*/
		155	#define ELFOSABI_NONE 0 /* No extensions or unspecified */
		156	#define ELFOSABI_SYSV ELFOSABI_NONE
		157	#define ELFOSABI_HPUX 1 /* Hewlett-Packard HP-UX */
		158	#define ELFOSABI_NETBSD 2 /* NetBSD */
		159	#define ELFOSABI_LINUX 3 /* Linux */
		160	#define ELFOSABI_SOLARIS 6 /* Sun Solaris */
		161	#define ELFOSABI_AIX 7 /* AIX */
		162	#define ELFOSABI_IRIX 8 /* IRIX */
		163	#define ELFOSABI_FREEBSD 9 /* FreeBSD */
		164	#define ELFOSABI_TRU64 10 /* Compaq TRU64 UNIX */
		165	#define ELFOSABI_MODESTO 11 /* Novell Modesto */
		166	#define ELFOSABI_OPENBSD 12 /* Open BSD */
		167	#define ELFOSABI_OPENVMS 13 /* Open VMS */
		168	#define ELFOSABI_NSK 14 /* Hewlett-Packard Non-Stop Kernel */
		169	#define ELFOSABI_AROS 15 /* Amiga Research OS */
		170	/* these are probably obsolete: */
		171	#define ELFOSABI_ARM_AEABI 64 /* ARM EABI */
		172	#define ELFOSABI_ARM 97 /* ARM */
		173	#define ELFOSABI_STANDALONE 255 /* standalone (embedded) application */
		174
		175
		176	/*
		177	* e_type
		178	*/
		179	#define ET_NONE 0
		180	#define ET_REL 1
		181	#define ET_EXEC 2
		182	#define ET_DYN 3
		183	#define ET_CORE 4
		184	#define ET_NUM 5
		185	#define ET_LOOS 0xfe00
		186	#define ET_HIOS 0xfeff
		187	#define ET_LOPROC 0xff00
		188	#define ET_HIPROC 0xffff
		189
		190	/*
		191	* e_machine
		192	*/
		193	#define EM_NONE 0 /* No machine */
		194	#define EM_M32 1 /* AT&T WE 32100 */
		195	#define EM_SPARC 2 /* SPARC */
		196	#define EM_386 3 /* Intel 80386 */
		197	#define EM_68K 4 /* Motorola 68000 */
		198	#define EM_88K 5 /* Motorola 88000 */
		199	#define EM_486 6 /* Intel i486 (DO NOT USE THIS ONE) */
		200	#define EM_860 7 /* Intel 80860 */
		201	#define EM_MIPS 8 /* MIPS I Architecture */
		202	#define EM_S370 9 /* IBM System/370 Processor */
		203	#define EM_MIPS_RS3_LE 10 /* MIPS RS3000 Little-endian */
		204	#define EM_SPARC64 11 /* SPARC 64-bit */
		205	#define EM_PARISC 15 /* Hewlett-Packard PA-RISC */
		206	#define EM_VPP500 17 /* Fujitsu VPP500 */
		207	#define EM_SPARC32PLUS 18 /* Enhanced instruction set SPARC */
		208	#define EM_960 19 /* Intel 80960 */
		209	#define EM_PPC 20 /* PowerPC */
		210	#define EM_PPC64 21 /* 64-bit PowerPC */
		211	#define EM_S390 22 /* IBM System/390 Processor */
		212	#define EM_V800 36 /* NEC V800 */
		213	#define EM_FR20 37 /* Fujitsu FR20 */
		214	#define EM_RH32 38 /* TRW RH-32 */
		215	#define EM_RCE 39 /* Motorola RCE */
		216	#define EM_ARM 40 /* Advanced RISC Machines ARM */
		217	#define EM_FAKE_ALPHA 41 /* Digital Alpha */
		218	#define EM_SH 42 /* Hitachi SH */
		219	#define EM_SPARCV9 43 /* SPARC Version 9 */
		220	#define EM_TRICORE 44 /* Siemens TriCore embedded processor */
		221	#define EM_ARC 45 /* Argonaut RISC Core, Argonaut Technologies Inc. */
		222	#define EM_H8_300 46 /* Hitachi H8/300 */
		223	#define EM_H8_300H 47 /* Hitachi H8/300H */
		224	#define EM_H8S 48 /* Hitachi H8S */
		225	#define EM_H8_500 49 /* Hitachi H8/500 */
		226	#define EM_IA_64 50 /* Intel IA-64 processor architecture */
		227	#define EM_MIPS_X 51 /* Stanford MIPS-X */
		228	#define EM_COLDFIRE 52 /* Motorola ColdFire */
		229	#define EM_68HC12 53 /* Motorola M68HC12 */
		230	#define EM_MMA 54 /* Fujitsu MMA Multimedia Accelerator */
		231	#define EM_PCP 55 /* Siemens PCP */
		232	#define EM_NCPU 56 /* Sony nCPU embedded RISC processor */
		233	#define EM_NDR1 57 /* Denso NDR1 microprocessor */
		234	#define EM_STARCORE 58 /* Motorola StarCore processor /
		235	#define EM_ME16 59 /* Toyota ME16 processor */
		236	#define EM_ST100 60 /* STMicroelectronics ST100 processor */
		237	#define EM_TINYJ 61 /* Advanced Logic Corp. TinyJ embedded processor family */
		238	#define EM_X86_64 62 /* AMD x86-64 architecture */
		239	#define EM_AMD64 EM_X86_64
		240	#define EM_PDSP 63 /* Sony DSP Processor */
		241	#define EM_FX66 66 /* Siemens FX66 microcontroller */
		242	#define EM_ST9PLUS 67 /* STMicroelectronics ST9+ 8/16 bit microcontroller */
		243	#define EM_ST7 68 /* STMicroelectronics ST7 8-bit microcontroller */
		244	#define EM_68HC16 69 /* Motorola MC68HC16 Microcontroller */
		245	#define EM_68HC11 70 /* Motorola MC68HC11 Microcontroller */
		246	#define EM_68HC08 71 /* Motorola MC68HC08 Microcontroller */
		247	#define EM_68HC05 72 /* Motorola MC68HC05 Microcontroller */
		248	#define EM_SVX 73 /* Silicon Graphics SVx */
		249	#define EM_ST19 74 /* STMicroelectronics ST19 8-bit microcontroller */
		250	#define EM_VAX 75 /* Digital VAX */
		251	#define EM_CRIS 76 /* Axis Communications 32-bit embedded processor */
		252	#define EM_JAVELIN 77 /* Infineon Technologies 32-bit embedded processor */
		253	#define EM_FIREPATH 78 /* Element 14 64-bit DSP Processor */
		254	#define EM_ZSP 79 /* LSI Logic 16-bit DSP Processor */
		255	#define EM_MMIX 80 /* Donald Knuth's educational 64-bit processor */
		256	#define EM_HUANY 81 /* Harvard University machine-independent object files */
		257	#define EM_PRISM 82 /* SiTera Prism */
		258	#define EM_AVR 83 /* Atmel AVR 8-bit microcontroller */
		259	#define EM_FR30 84 /* Fujitsu FR30 */
		260	#define EM_D10V 85 /* Mitsubishi D10V */
		261	#define EM_D30V 86 /* Mitsubishi D30V */
		262	#define EM_V850 87 /* NEC v850 */
		263	#define EM_M32R 88 /* Mitsubishi M32R */
		264	#define EM_MN10300 89 /* Matsushita MN10300 */
		265	#define EM_MN10200 90 /* Matsushita MN10200 */
		266	#define EM_PJ 91 /* picoJava */
		267	#define EM_OPENRISC 92 /* OpenRISC 32-bit embedded processor */
		268	#define EM_ARC_A5 93 /* ARC Cores Tangent-A5 */
		269	#define EM_XTENSA 94 /* Tensilica Xtensa Architecture */
		270	#define EM_VIDEOCORE 95 /* Alphamosaic VideoCore processor */
		271	#define EM_TMM_GPP 96 /* Thompson Multimedia General Purpose Processor */
		272	#define EM_NS32K 97 /* National Semiconductor 32000 series */
		273	#define EM_TPC 98 /* Tenor Network TPC processor */
		274	#define EM_SNP1K 99 /* Trebia SNP 1000 processor */
		275	#define EM_ST200 100 /* STMicroelectronics (www.st.com) ST200 microcontroller */
		276	#define EM_IP2K 101 /* Ubicom IP2xxx microcontroller family */
		277	#define EM_MAX 102 /* MAX Processor */
		278	#define EM_CR 103 /* National Semiconductor CompactRISC microprocessor */
		279	#define EM_F2MC16 104 /* Fujitsu F2MC16 */
		280	#define EM_MSP430 105 /* Texas Instruments embedded microcontroller msp430 */
		281	#define EM_BLACKFIN 106 /* Analog Devices Blackfin (DSP) processor */
		282	#define EM_SE_C33 107 /* S1C33 Family of Seiko Epson processors */
		283	#define EM_SEP 108 /* Sharp embedded microprocessor */
		284	#define EM_ARCA 109 /* Arca RISC Microprocessor */
		285	#define EM_UNICORE 110 /* Microprocessor series from PKU-Unity Ltd. and MPRC of Peking University */
		286	#define EM_AARCH64 183 /* ARM AARCH64 */
		287	#define EM_TILEPRO 188 /* Tilera TILEPro */
		288	#define EM_MICROBLAZE 189 /* Xilinx MicroBlaze */
		289	#define EM_TILEGX 191 /* Tilera TILE-Gx */
		290	#define EM_NUM 192
		291
		292
		293	/*
		294	* e_ident[EI_VERSION], e_version
		295	*/
		296	#define EV_NONE 0
		297	#define EV_CURRENT 1
		298	#define EV_NUM 2
		299
		300	/*
		301	* Section header
		302	*/
		303	typedef struct {
		304	Elf32_Word sh_name;
		305	Elf32_Word sh_type;
		306	Elf32_Word sh_flags;
		307	Elf32_Addr sh_addr;
		308	Elf32_Off sh_offset;
		309	Elf32_Word sh_size;
		310	Elf32_Word sh_link;
		311	Elf32_Word sh_info;
		312	Elf32_Word sh_addralign;
		313	Elf32_Word sh_entsize;
		314	} Elf32_Shdr;
		315
		316	#if __LIBELF64
		317	typedef struct {
		318	Elf64_Word sh_name;
		319	Elf64_Word sh_type;
		320	Elf64_Xword sh_flags;
		321	Elf64_Addr sh_addr;
		322	Elf64_Off sh_offset;
		323	Elf64_Xword sh_size;
		324	Elf64_Word sh_link;
		325	Elf64_Word sh_info;
		326	Elf64_Xword sh_addralign;
		327	Elf64_Xword sh_entsize;
		328	} Elf64_Shdr;
		329	#endif /* __LIBELF64 */
		330
		331	/*
		332	* Special section indices
		333	*/
		334	#define SHN_UNDEF 0
		335	#define SHN_LORESERVE 0xff00
		336	#define SHN_LOPROC 0xff00
		337	#define SHN_HIPROC 0xff1f
		338	#define SHN_LOOS 0xff20
		339	#define SHN_HIOS 0xff3f
		340	#define SHN_ABS 0xfff1
		341	#define SHN_COMMON 0xfff2
		342	#define SHN_XINDEX 0xffff
		343	#define SHN_HIRESERVE 0xffff
		344
		345	/*
		346	* sh_type
		347	*/
		348	#define SHT_NULL 0
		349	#define SHT_PROGBITS 1
		350	#define SHT_SYMTAB 2
		351	#define SHT_STRTAB 3
		352	#define SHT_RELA 4
		353	#define SHT_HASH 5
		354	#define SHT_DYNAMIC 6
		355	#define SHT_NOTE 7
		356	#define SHT_NOBITS 8
		357	#define SHT_REL 9
		358	#define SHT_SHLIB 10
		359	#define SHT_DYNSYM 11
		360	#define SHT_INIT_ARRAY 14
		361	#define SHT_FINI_ARRAY 15
		362	#define SHT_PREINIT_ARRAY 16
		363	#define SHT_GROUP 17
		364	#define SHT_SYMTAB_SHNDX 18
		365	#define SHT_NUM 19
		366	#define SHT_LOOS 0x60000000
		367	#define SHT_HIOS 0x6fffffff
		368	#define SHT_LOPROC 0x70000000
		369	#define SHT_HIPROC 0x7fffffff
		370	#define SHT_LOUSER 0x80000000
		371	#define SHT_HIUSER 0xffffffff
		372
		373	/*
		374	* Solaris extensions
		375	*/
		376	#define SHT_LOSUNW 0x6ffffff4
		377	#define SHT_SUNW_dof 0x6ffffff4
		378	#define SHT_SUNW_cap 0x6ffffff5
		379	#define SHT_SUNW_SIGNATURE 0x6ffffff6
		380	#define SHT_SUNW_ANNOTATE 0x6ffffff7
		381	#define SHT_SUNW_DEBUGSTR 0x6ffffff8
		382	#define SHT_SUNW_DEBUG 0x6ffffff9
		383	#define SHT_SUNW_move 0x6ffffffa
		384	#define SHT_SUNW_COMDAT 0x6ffffffb
		385	#define SHT_SUNW_syminfo 0x6ffffffc
		386	#define SHT_SUNW_verdef 0x6ffffffd
		387	#define SHT_SUNW_verneed 0x6ffffffe
		388	#define SHT_SUNW_versym 0x6fffffff
		389	#define SHT_HISUNW 0x6fffffff
		390
		391	#define SHT_SPARC_GOTDATA 0x70000000
		392	#define SHT_AMD64_UNWIND 0x70000001
		393
		394	/*
		395	* GNU extensions
		396	*/
		397	#define SHT_GNU_verdef 0x6ffffffd
		398	#define SHT_GNU_verneed 0x6ffffffe
		399	#define SHT_GNU_versym 0x6fffffff
		400
		401	/*
		402	* sh_flags
		403	*/
		404	#define SHF_WRITE 0x1
		405	#define SHF_ALLOC 0x2
		406	#define SHF_EXECINSTR 0x4
		407	#define SHF_MERGE 0x10
		408	#define SHF_STRINGS 0x20
		409	#define SHF_INFO_LINK 0x40
		410	#define SHF_LINK_ORDER 0x80
		411	#define SHF_OS_NONCONFORMING 0x100
		412	#define SHF_GROUP 0x200
		413	#define SHF_TLS 0x400
		414	#define SHF_MASKOS 0x0ff00000
		415	#define SHF_MASKPROC 0xf0000000
		416
		417	/*
		418	* Solaris extensions
		419	*/
		420	#define SHF_AMD64_LARGE 0x10000000
		421	#define SHF_ORDERED 0x40000000
		422	#define SHF_EXCLUDE 0x80000000
		423
		424	/*
		425	* Section group flags
		426	*/
		427	#define GRP_COMDAT 0x1
		428	#define GRP_MASKOS 0x0ff00000
		429	#define GRP_MASKPROC 0xf0000000
		430
		431	/*
		432	* Symbol table
		433	*/
		434	typedef struct {
		435	Elf32_Word st_name;
		436	Elf32_Addr st_value;
		437	Elf32_Word st_size;
		438	unsigned char st_info;
		439	unsigned char st_other;
		440	Elf32_Half st_shndx;
		441	} Elf32_Sym;
		442
		443	#if __LIBELF64
		444	typedef struct {
		445	Elf64_Word st_name;
		446	unsigned char st_info;
		447	unsigned char st_other;
		448	Elf64_Half st_shndx;
		449	Elf64_Addr st_value;
		450	Elf64_Xword st_size;
		451	} Elf64_Sym;
		452	#endif /* __LIBELF64 */
		453
		454	/*
		455	* Special symbol indices
		456	*/
		457	#define STN_UNDEF 0
		458
		459	/*
		460	* Macros for manipulating st_info
		461	*/
		462	#define ELF32_ST_BIND(i) ((i)>>4)
		463	#define ELF32_ST_TYPE(i) ((i)&0xf)
		464	#define ELF32_ST_INFO(b,t) (((b)<<4)+((t)&0xf))
		465
		466	#if __LIBELF64
		467	#define ELF64_ST_BIND(i) ((i)>>4)
		468	#define ELF64_ST_TYPE(i) ((i)&0xf)
		469	#define ELF64_ST_INFO(b,t) (((b)<<4)+((t)&0xf))
		470	#endif /* __LIBELF64 */
		471
		472	/*
		473	* Symbol binding
		474	*/
		475	#define STB_LOCAL 0
		476	#define STB_GLOBAL 1
		477	#define STB_WEAK 2
		478	#define STB_NUM 3
		479	#define STB_LOOS 10
		480	#define STB_HIOS 12
		481	#define STB_LOPROC 13
		482	#define STB_HIPROC 15
		483
		484	/*
		485	* Symbol types
		486	*/
		487	#define STT_NOTYPE 0
		488	#define STT_OBJECT 1
		489	#define STT_FUNC 2
		490	#define STT_SECTION 3
		491	#define STT_FILE 4
		492	#define STT_COMMON 5
		493	#define STT_TLS 6
		494	#define STT_NUM 7
		495	#define STT_LOOS 10
		496	#define STT_HIOS 12
		497	#define STT_LOPROC 13
		498	#define STT_HIPROC 15
		499
		500	/*
		501	* Macros for manipulating st_other
		502	*/
		503	#define ELF32_ST_VISIBILITY(o) ((o)&0x3)
		504	#if __LIBELF64
		505	#define ELF64_ST_VISIBILITY(o) ((o)&0x3)
		506	#endif /* __LIBELF64 */
		507
		508	/*
		509	* Symbol visibility
		510	*/
		511	#define STV_DEFAULT 0
		512	#define STV_INTERNAL 1
		513	#define STV_HIDDEN 2
		514	#define STV_PROTECTED 3
		515
		516	/*
		517	* Relocation
		518	*/
		519	typedef struct {
		520	Elf32_Addr r_offset;
		521	Elf32_Word r_info;
		522	} Elf32_Rel;
		523
		524	typedef struct {
		525	Elf32_Addr r_offset;
		526	Elf32_Word r_info;
		527	Elf32_Sword r_addend;
		528	} Elf32_Rela;
		529
		530	#if __LIBELF64
		531	typedef struct {
		532	Elf64_Addr r_offset;
		533	Elf64_Xword r_info;
		534	} Elf64_Rel;
		535
		536	typedef struct {
		537	Elf64_Addr r_offset;
		538	Elf64_Xword r_info;
		539	Elf64_Sxword r_addend;
		540	} Elf64_Rela;
		541	#endif /* __LIBELF64 */
		542
		543	/*
		544	* Macros for manipulating r_info
		545	*/
		546	#define ELF32_R_SYM(i) ((i)>>8)
		547	#define ELF32_R_TYPE(i) ((unsigned char)(i))
		548	#define ELF32_R_INFO(s,t) (((s)<<8)+(unsigned char)(t))
		549
		550	#if __LIBELF64
		551	#define ELF64_R_SYM(i) ((Elf64_Xword)(i)>>32)
		552	#define ELF64_R_TYPE(i) ((i)&0xffffffffL)
		553	#define ELF64_R_INFO(s,t) (((Elf64_Xword)(s)<<32)+((t)&0xffffffffL))
		554	#endif /* __LIBELF64 */
		555
		556	/*
		557	* Note entry header
		558	*/
		559	typedef struct {
		560	Elf32_Word n_namesz; /* name size */
		561	Elf32_Word n_descsz; /* descriptor size */
		562	Elf32_Word n_type; /* descriptor type */
		563	} Elf32_Nhdr;
		564
		565	#if __LIBELF64
		566	/* Solaris and GNU use this layout. Be compatible. */
		567	/* XXX: Latest ELF specs say it's 64-bit!!! */
		568	typedef struct {
		569	Elf64_Word n_namesz; /* name size */
		570	Elf64_Word n_descsz; /* descriptor size */
		571	Elf64_Word n_type; /* descriptor type */
		572	} Elf64_Nhdr;
		573	#endif /* __LIBELF64 */
		574
		575	/*
		576	* Well-known descriptor types for ET_CORE files
		577	*/
		578	#define NT_PRSTATUS 1
		579	#define NT_PRFPREG 2
		580	#define NT_PRPSINFO 3
		581
		582	/*
		583	* Program header
		584	*/
		585	typedef struct {
		586	Elf32_Word p_type;
		587	Elf32_Off p_offset;
		588	Elf32_Addr p_vaddr;
		589	Elf32_Addr p_paddr;
		590	Elf32_Word p_filesz;
		591	Elf32_Word p_memsz;
		592	Elf32_Word p_flags;
		593	Elf32_Word p_align;
		594	} Elf32_Phdr;
		595
		596	#if __LIBELF64
		597	typedef struct {
		598	Elf64_Word p_type;
		599	Elf64_Word p_flags;
		600	Elf64_Off p_offset;
		601	Elf64_Addr p_vaddr;
		602	Elf64_Addr p_paddr;
		603	Elf64_Xword p_filesz;
		604	Elf64_Xword p_memsz;
		605	Elf64_Xword p_align;
		606	} Elf64_Phdr;
		607	#endif /* __LIBELF64 */
		608
		609	/*
		610	* Special numbers
		611	*/
		612	#define PN_XNUM 0xffff
		613
		614	/*
		615	* p_type
		616	*/
		617	#define PT_NULL 0
		618	#define PT_LOAD 1
		619	#define PT_DYNAMIC 2
		620	#define PT_INTERP 3
		621	#define PT_NOTE 4
		622	#define PT_SHLIB 5
		623	#define PT_PHDR 6
		624	#define PT_TLS 7
		625	#define PT_NUM 8
		626	#define PT_LOOS 0x60000000
		627	#define PT_HIOS 0x6fffffff
		628	#define PT_LOPROC 0x70000000
		629	#define PT_HIPROC 0x7fffffff
		630
		631	/*
		632	* Solaris extensions
		633	*/
		634
		635	#define PT_SUNW_UNWIND 0x6464e550
		636	#define PT_LOSUNW 0x6ffffffa
		637	#define PT_SUNWBSS 0x6ffffffa
		638	#define PT_SUNWSTACK 0x6ffffffb
		639	#define PT_SUNWDTRACE 0x6ffffffc
		640	#define PT_SUNWCAP 0x6ffffffd
		641	#define PT_HISUNW 0x6fffffff
		642
		643	/*
		644	* p_flags
		645	*/
		646	#define PF_X 0x1
		647	#define PF_W 0x2
		648	#define PF_R 0x4
		649	#define PF_MASKOS 0x0ff00000
		650	#define PF_MASKPROC 0xf0000000
		651
		652	/*
		653	* Dynamic structure
		654	*/
		655	typedef struct {
		656	Elf32_Sword d_tag;
		657	union {
		658	Elf32_Word d_val;
		659	Elf32_Addr d_ptr;
		660	} d_un;
		661	} Elf32_Dyn;
		662
		663	#if __LIBELF64
		664	typedef struct {
		665	Elf64_Sxword d_tag;
		666	union {
		667	Elf64_Xword d_val;
		668	Elf64_Addr d_ptr;
		669	} d_un;
		670	} Elf64_Dyn;
		671	#endif /* __LIBELF64 */
		672
		673	/*
		674	* Dynamic array tags
		675	*/
		676	/* d_un exec shared */
		677	#define DT_NULL 0 /* ign. mand. mand. */
		678	#define DT_NEEDED 1 /* d_val opt. opt. */
		679	#define DT_PLTRELSZ 2 /* d_val opt. opt. */
		680	#define DT_PLTGOT 3 /* d_ptr opt. opt. */
		681	#define DT_HASH 4 /* d_ptr mand. mand. */
		682	#define DT_STRTAB 5 /* d_ptr mand. mand. */
		683	#define DT_SYMTAB 6 /* d_ptr mand. mand. */
		684	#define DT_RELA 7 /* d_ptr mand. opt. */
		685	#define DT_RELASZ 8 /* d_val mand. opt. */
		686	#define DT_RELAENT 9 /* d_val mand. opt. */
		687	#define DT_STRSZ 10 /* d_val mand. mand. */
		688	#define DT_SYMENT 11 /* d_val mand. mand. */
		689	#define DT_INIT 12 /* d_ptr opt. opt. */
		690	#define DT_FINI 13 /* d_ptr opt. opt. */
		691	#define DT_SONAME 14 /* d_val ign. opt. */
		692	#define DT_RPATH 15 /* d_val opt. ign. */
		693	#define DT_SYMBOLIC 16 /* ign. ign. opt. */
		694	#define DT_REL 17 /* d_ptr mand. opt. */
		695	#define DT_RELSZ 18 /* d_val mand. opt. */
		696	#define DT_RELENT 19 /* d_val mand. opt. */
		697	#define DT_PLTREL 20 /* d_val opt. opt. */
		698	#define DT_DEBUG 21 /* d_ptr opt. ign. */
		699	#define DT_TEXTREL 22 /* ign. opt. opt. */
		700	#define DT_JMPREL 23 /* d_ptr opt. opt. */
		701	#define DT_BIND_NOW 24 /* ign. opt. opt. */
		702	#define DT_INIT_ARRAY 25 /* d_ptr opt. opt. */
		703	#define DT_FINI_ARRAY 26 /* d_ptr opt. opt. */
		704	#define DT_INIT_ARRAYSZ 27 /* d_val opt. opt. */
		705	#define DT_FINI_ARRAYSZ 28 /* d_val opt. opt. */
		706	#define DT_RUNPATH 29 /* d_val opt. opt. */
		707	#define DT_FLAGS 30 /* d_val opt. opt. */
		708	#define DT_ENCODING 32 /* odd/even encoding rule starts here */
		709	#define DT_PREINIT_ARRAY 32 /* d_ptr opt. ign. */
		710	#define DT_PREINIT_ARRAYSZ 33 /* d_val opt. ign. */
		711	#define DT_NUM 34
		712	#define DT_LOOS 0x6000000D
		713	#define DT_HIOS 0x6ffff000
		714	#define DT_LOPROC 0x70000000
		715	#define DT_HIPROC 0x7fffffff
		716
		717	/*
		718	* DT_FLAGS values
		719	*/
		720	#define DF_ORIGIN 0x1
		721	#define DF_SYMBOLIC 0x2
		722	#define DF_TEXTREL 0x4
		723	#define DF_BIND_NOW 0x8
		724	#define DF_STATIC_TLS 0x10
		725
		726	/*
		727	* Solaris extensions
		728	*/
		729	#define DT_VALRNGLO 0x6ffffd00
		730	#define DT_CHECKSUM 0x6ffffdf8
		731	#define DT_PLTPADSZ 0x6ffffdf9
		732	#define DT_MOVEENT 0x6ffffdfa
		733	#define DT_MOVESZ 0x6ffffdfb
		734	#define DT_FEATURE_1 0x6ffffdfc
		735	#define DT_POSFLAG_1 0x6ffffdfd
		736	#define DT_SYMINSZ 0x6ffffdfe
		737	#define DT_SYMINENT 0x6ffffdff
		738	#define DT_VALRNGHI 0x6ffffdff
		739
		740	#define DT_ADDRRNGLO 0x6ffffe00
		741	#define DT_CONFIG 0x6ffffefa
		742	#define DT_DEPAUDIT 0x6ffffefb
		743	#define DT_AUDIT 0x6ffffefc
		744	#define DT_PLTPAD 0x6ffffefd
		745	#define DT_MOVETAB 0x6ffffefe
		746	#define DT_SYMINFO 0x6ffffeff
		747	#define DT_ADDRRNGHI 0x6ffffeff
		748
		749	#define DT_RELACOUNT 0x6ffffff9
		750	#define DT_RELCOUNT 0x6ffffffa
		751	#define DT_FLAGS_1 0x6ffffffb
		752	#define DT_VERDEF 0x6ffffffc
		753	#define DT_VERDEFNUM 0x6ffffffd
		754	#define DT_VERNEED 0x6ffffffe
		755	#define DT_VERNEEDNUM 0x6fffffff
		756
		757	#define DT_AUXILIARY 0x7ffffffd
		758	#define DT_USED 0x7ffffffe
		759	#define DT_FILTER 0x7fffffff
		760
		761	/*
		762	* GNU extensions
		763	*/
		764	#define DT_VERSYM 0x6ffffff0
		765
		766	/*
		767	* DT_FEATURE_1 values
		768	*/
		769	#define DTF_1_PARINIT 0x1
		770	#define DTF_1_CONFEXP 0x2
		771
		772	/*
		773	* DT_POSFLAG_1 values
		774	*/
		775	#define DF_P1_LAZYLOAD 0x1
		776	#define DF_P1_GROUPPERM 0x2
		777
		778	/*
		779	* DT_FLAGS_1 values
		780	*/
		781	#define DF_1_NOW 0x00000001
		782	#define DF_1_GLOBAL 0x00000002
		783	#define DF_1_GROUP 0x00000004
		784	#define DF_1_NODELETE 0x00000008
		785	#define DF_1_LOADFLTR 0x00000010
		786	#define DF_1_INITFIRST 0x00000020
		787	#define DF_1_NOOPEN 0x00000040
		788	#define DF_1_ORIGIN 0x00000080
		789	#define DF_1_DIRECT 0x00000100
		790	#define DF_1_TRANS 0x00000200
		791	#define DF_1_INTERPOSE 0x00000400
		792	#define DF_1_NODEFLIB 0x00000800
		793	#define DF_1_NODUMP 0x00001000
		794	#define DF_1_CONFALT 0x00002000
		795	#define DF_1_ENDFILTEE 0x00004000
		796	#define DF_1_DISPRELDNE 0x00008000
		797	#define DF_1_DISPRELPND 0x00010000
		798
		799	/*
		800	* Syminfo structure
		801	*/
		802	typedef struct {
		803	Elf32_Half si_boundto;
		804	Elf32_Half si_flags;
		805	} Elf32_Syminfo;
		806
		807	#if __LIBELF64
		808	typedef struct {
		809	Elf64_Half si_boundto;
		810	Elf64_Half si_flags;
		811	} Elf64_Syminfo;
		812	#endif /* __LIBELF64 */
		813
		814	/*
		815	* Syminfo version (stored in unused first entry)
		816	*/
		817	#define SYMINFO_NONE 0
		818	#define SYMINFO_CURRENT 1
		819	#define SYMINFO_NUM 2
		820
		821	/*
		822	* si_boundto special values
		823	*/
		824	#define SYMINFO_BT_LOWRESERVE 0xff00
		825	#define SYMINFO_BT_PARENT 0xfffe /* bound to parent */
		826	#define SYMINFO_BT_SELF 0xffff /* bound to self */
		827
		828	/*
		829	* si_flags
		830	*/
		831	#define SYMINFO_FLG_DIRECT 0x01 /* bound to an object */
		832	#define SYMINFO_FLG_PASSTHRU 0x02 /* pass-thru symbol */
		833	#define SYMINFO_FLG_COPY 0x04 /* result of a copy relocation */
		834	#define SYMINFO_FLG_LAZYLOAD 0x08 /* bound to lazy-loaded object */
		835
		836	/*
		837	* Version definitions
		838	*/
		839	typedef struct {
		840	Elf32_Half vd_version;
		841	Elf32_Half vd_flags;
		842	Elf32_Half vd_ndx;
		843	Elf32_Half vd_cnt;
		844	Elf32_Word vd_hash;
		845	Elf32_Word vd_aux;
		846	Elf32_Word vd_next;
		847	} Elf32_Verdef;
		848
		849	typedef struct {
		850	Elf32_Word vda_name;
		851	Elf32_Word vda_next;
		852	} Elf32_Verdaux;
		853
		854	typedef struct {
		855	Elf32_Half vn_version;
		856	Elf32_Half vn_cnt;
		857	Elf32_Word vn_file;
		858	Elf32_Word vn_aux;
		859	Elf32_Word vn_next;
		860	} Elf32_Verneed;
		861
		862	typedef struct {
		863	Elf32_Word vna_hash;
		864	Elf32_Half vna_flags;
		865	Elf32_Half vna_other;
		866	Elf32_Word vna_name;
		867	Elf32_Word vna_next;
		868	} Elf32_Vernaux;
		869
		870	typedef Elf32_Half Elf32_Versym;
		871
		872	#if __LIBELF64
		873
		874	typedef struct {
		875	Elf64_Half vd_version;
		876	Elf64_Half vd_flags;
		877	Elf64_Half vd_ndx;
		878	Elf64_Half vd_cnt;
		879	Elf64_Word vd_hash;
		880	Elf64_Word vd_aux;
		881	Elf64_Word vd_next;
		882	} Elf64_Verdef;
		883
		884	typedef struct {
		885	Elf64_Word vda_name;
		886	Elf64_Word vda_next;
		887	} Elf64_Verdaux;
		888
		889	typedef struct {
		890	Elf64_Half vn_version;
		891	Elf64_Half vn_cnt;
		892	Elf64_Word vn_file;
		893	Elf64_Word vn_aux;
		894	Elf64_Word vn_next;
		895	} Elf64_Verneed;
		896
		897	typedef struct {
		898	Elf64_Word vna_hash;
		899	Elf64_Half vna_flags;
		900	Elf64_Half vna_other;
		901	Elf64_Word vna_name;
		902	Elf64_Word vna_next;
		903	} Elf64_Vernaux;
		904
		905	typedef Elf64_Half Elf64_Versym;
		906
		907	#endif /* __LIBELF64 */
		908
		909	/*
		910	* vd_version
		911	*/
		912	#define VER_DEF_NONE 0
		913	#define VER_DEF_CURRENT 1
		914	#define VER_DEF_NUM 2
		915
		916	/*
		917	* vn_version
		918	*/
		919	#define VER_NEED_NONE 0
		920	#define VER_NEED_CURRENT 1
		921	#define VER_NEED_NUM 2
		922
		923	/*
		924	* vd_flags / vna_flags
		925	*/
		926	#define VER_FLG_BASE 0x1 /* vd_flags only */
		927	#define VER_FLG_WEAK 0x2
		928
		929	/*
		930	* Elf*_Versym special values
		931	*/
		932	#define VER_NDX_LOCAL 0
		933	#define VER_NDX_GLOBAL 1
		934
		935	/*
		936	* Solaris extensions
		937	*/
		938
		939	/*
		940	* Move section
		941	*/
		942	#if __LIBELF64
		943
		944	typedef struct {
		945	Elf32_Lword m_value;
		946	Elf32_Word m_info;
		947	Elf32_Word m_poffset;
		948	Elf32_Half m_repeat;
		949	Elf32_Half m_stride;
		950	} Elf32_Move;
		951
		952	typedef struct {
		953	Elf64_Lword m_value;
		954	Elf64_Xword m_info;
		955	Elf64_Xword m_poffset;
		956	Elf64_Half m_repeat;
		957	Elf64_Half m_stride;
		958	} Elf64_Move;
		959
		960	#define ELF32_M_SYM(info) ((info)>>8)
		961	#define ELF32_M_SIZE(info) ((unsigned char)(info))
		962	#define ELF32_M_INFO(sym, sz) (((sym)<<8)+(unsigned char)(sz))
		963
		964	#define ELF64_M_SYM(info) ((Elf64_Xword)(info)>>8)
		965	#define ELF64_M_SIZE(info) ((unsigned char)(info))
		966	#define ELF64_M_INFO(sym, sz) (((Elf64_Xword)(sym)<<8)+(unsigned char)(sz))
		967
		968	#endif /* __LIBELF64 */
		969
		970	/*
		971	* Capabilities
		972	*/
		973
		974	typedef struct {
		975	Elf32_Word c_tag;
		976	union {
		977	Elf32_Word c_val;
		978	Elf32_Addr c_ptr;
		979	} c_un;
		980	} Elf32_Cap;
		981
		982	#if __LIBELF64
		983
		984	typedef struct {
		985	Elf64_Xword c_tag;
		986	union {
		987	Elf64_Xword c_val;
		988	Elf64_Addr c_ptr;
		989	} c_un;
		990	} Elf64_Cap;
		991
		992	#endif /* __LIBELF64 */
		993
		994	#define CA_SUNW_NULL 0 /* c_un ignored */
		995	#define CA_SUNW_HW_1 1 /* c_un.c_val */
		996	#define CA_SUNW_SF_1 2 /* c_un.c_val */
		997
		998	#ifdef __cplusplus
		999	}
		1000	#endif /* __cplusplus */
		1001
		1002	#endif /* _ELF_REPL_H */

src/common/genericBinaryFiles/elf/libelfWin32/include/libelf/errors.h created 644 +100 0

@@ -0,0 +1,100
	1	/*
	2	* errors.h - exhaustive list of all error codes and messages for libelf.
	3	* Copyright (C) 1995 - 2003, 2006 Michael Riepe
	4	*
	5	* This library is free software; you can redistribute it and/or
	6	* modify it under the terms of the GNU Library General Public
	7	* License as published by the Free Software Foundation; either
	8	* version 2 of the License, or (at your option) any later version.
	9	*
	10	* This library is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	13	* Library General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU Library General Public
	16	* License along with this library; if not, write to the Free Software
	17	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
	18	*/
	19
	20	/* @(#) $Id: errors.h,v 1.18 2008/05/23 08:15:34 michael Exp $ */
	21
	22	/* dummy for xgettext */
	23	#define _(str) str
	24
	25	__err__(ERROR_OK, _("no error"))
	26	__err__(ERROR_UNKNOWN, _("unknown error"))
	27	__err__(ERROR_INTERNAL, _("Internal error: unknown reason"))
	28	__err__(ERROR_UNIMPLEMENTED, _("Internal error: not implemented"))
	29	__err__(ERROR_WRONLY, _("Request error: cntl(ELF_C_FDREAD) on write-only file"))
	30	__err__(ERROR_INVALID_CMD, _("Request error: invalid ELF_C_* argument"))
	31	__err__(ERROR_FDDISABLED, _("Request error: file descriptor disabled"))
	32	__err__(ERROR_NOTARCHIVE, _("Request error: not an archive"))
	33	__err__(ERROR_BADOFF, _("Request error: offset out of range"))
	34	__err__(ERROR_UNKNOWN_VERSION, _("Request error: unknown ELF version"))
	35	__err__(ERROR_CMDMISMATCH, _("Request error: ELF_C_* argument does not match"))
	36	__err__(ERROR_MEMBERWRITE, _("Request error: archive member begin() for writing"))
	37	__err__(ERROR_FDMISMATCH, _("Request error: archive/member file descriptor mismatch"))
	38	__err__(ERROR_NOTELF, _("Request error: not an ELF file"))
	39	__err__(ERROR_CLASSMISMATCH, _("Request error: class file/memory mismatch"))
	40	__err__(ERROR_UNKNOWN_TYPE, _("Request error: invalid ELF_T_* argument"))
	41	__err__(ERROR_UNKNOWN_ENCODING, _("Request error: unknown data encoding"))
	42	__err__(ERROR_DST2SMALL, _("Request error: destination buffer too small"))
	43	__err__(ERROR_NULLBUF, _("Request error: d_buf is NULL"))
	44	__err__(ERROR_UNKNOWN_CLASS, _("Request error: unknown ELF class"))
	45	__err__(ERROR_ELFSCNMISMATCH, _("Request error: section does not belong to file"))
	46	__err__(ERROR_NOSUCHSCN, _("Request error: no section at index"))
	47	__err__(ERROR_NULLSCN, _("Request error: can't manipulate null section"))
	48	__err__(ERROR_SCNDATAMISMATCH, _("Request error: data does not belong to section"))
	49	__err__(ERROR_NOSTRTAB, _("Request error: no string table"))
	50	__err__(ERROR_BADSTROFF, _("Request error: string table offset out of range"))
	51	__err__(ERROR_RDONLY, _("Request error: update(ELF_C_WRITE) on read-only file"))
	52	__err__(ERROR_IO_SEEK, _("I/O error: seek"))
	53	__err__(ERROR_IO_2BIG, _("I/O error: file too big for memory"))
	54	__err__(ERROR_IO_READ, _("I/O error: raw read"))
	55	__err__(ERROR_IO_GETSIZE, _("I/O error: get file size"))
	56	__err__(ERROR_IO_WRITE, _("I/O error: output write"))
	57	__err__(ERROR_IO_TRUNC, _("I/O error: can't truncate output file"))
	58	__err__(ERROR_VERSION_UNSET, _("Sequence error: must set ELF version first"))
	59	__err__(ERROR_NOEHDR, _("Sequence error: must create ELF header first"))
	60	__err__(ERROR_OUTSIDE, _("Format error: reference outside file"))
	61	__err__(ERROR_TRUNC_ARHDR, _("Format error: archive header truncated"))
	62	__err__(ERROR_ARFMAG, _("Format error: archive fmag"))
	63	__err__(ERROR_ARHDR, _("Format error: archive header"))
	64	__err__(ERROR_TRUNC_MEMBER, _("Format error: archive member truncated"))
	65	__err__(ERROR_SIZE_ARSYMTAB, _("Format error: archive symbol table size"))
	66	__err__(ERROR_ARSTRTAB, _("Format error: archive string table"))
	67	__err__(ERROR_ARSPECIAL, _("Format error: archive special name unknown"))
	68	__err__(ERROR_TRUNC_EHDR, _("Format error: ELF header truncated"))
	69	__err__(ERROR_TRUNC_PHDR, _("Format error: program header table truncated"))
	70	__err__(ERROR_TRUNC_SHDR, _("Format error: section header table truncated"))
	71	__err__(ERROR_TRUNC_SCN, _("Format error: data region truncated"))
	72	__err__(ERROR_ALIGN_PHDR, _("Format error: program header table alignment"))
	73	__err__(ERROR_ALIGN_SHDR, _("Format error: section header table alignment"))
	74	__err__(ERROR_VERDEF_FORMAT, _("Format error: bad parameter in Verdef record"))
	75	__err__(ERROR_VERDEF_VERSION, _("Format error: unknown Verdef version"))
	76	__err__(ERROR_VERNEED_FORMAT, _("Format error: bad parameter in Verneed record"))
	77	__err__(ERROR_VERNEED_VERSION, _("Format error: unknown Verneed version"))
	78	__err__(ERROR_EHDR_SHNUM, _("Format error: bad e_shnum value"))
	79	__err__(ERROR_EHDR_SHENTSIZE, _("Format error: bad e_shentsize value"))
	80	__err__(ERROR_EHDR_PHENTSIZE, _("Format error: bad e_phentsize value"))
	81	__err__(ERROR_UNTERM, _("Format error: unterminated string in string table"))
	82	__err__(ERROR_SCN2SMALL, _("Layout error: section size too small for data"))
	83	__err__(ERROR_SCN_OVERLAP, _("Layout error: overlapping sections"))
	84	__err__(ERROR_MEM_ELF, _("Memory error: elf descriptor"))
	85	__err__(ERROR_MEM_ARSYMTAB, _("Memory error: archive symbol table"))
	86	__err__(ERROR_MEM_ARHDR, _("Memory error: archive member header"))
	87	__err__(ERROR_MEM_EHDR, _("Memory error: ELF header"))
	88	__err__(ERROR_MEM_PHDR, _("Memory error: program header table"))
	89	__err__(ERROR_MEM_SHDR, _("Memory error: section header table"))
	90	__err__(ERROR_MEM_SCN, _("Memory error: section descriptor"))
	91	__err__(ERROR_MEM_SCNDATA, _("Memory error: section data"))
	92	__err__(ERROR_MEM_OUTBUF, _("Memory error: output file space"))
	93	__err__(ERROR_MEM_TEMPORARY, _("Memory error: temporary buffer"))
	94	__err__(ERROR_BADVALUE, _("GElf error: value out of range"))
	95	__err__(ERROR_BADINDEX, _("GElf error: index out of range"))
	96	__err__(ERROR_BADTYPE, _("GElf error: type mismatch"))
	97	__err__(ERROR_MEM_SYM, _("GElf error: not enough memory for GElf_Sym"))
	98	__err__(ERROR_MEM_DYN, _("GElf error: not enough memory for GElf_Dyn"))
	99	__err__(ERROR_MEM_RELA, _("GElf error: not enough memory for GElf_Rela"))
	100	__err__(ERROR_MEM_REL, _("GElf error: not enough memory for GElf_Rel"))

src/common/genericBinaryFiles/elf/libelfWin32/include/libelf/ext_types.h created 644 +334 0

@@ -0,0 +1,334
	1	/*
	2	ext_types.h - external representation of ELF data types.
	3	Copyright (C) 1995 - 1998 Michael Riepe
	4
	5	This library is free software; you can redistribute it and/or
	6	modify it under the terms of the GNU Library General Public
	7	License as published by the Free Software Foundation; either
	8	version 2 of the License, or (at your option) any later version.
	9
	10	This library is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	13	Library General Public License for more details.
	14
	15	You should have received a copy of the GNU Library General Public
	16	License along with this library; if not, write to the Free Software
	17	Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
	18	*/
	19
	20	/* @(#) $Id: ext_types.h,v 1.9 2008/05/23 08:15:34 michael Exp $ */
	21
	22	#ifndef _EXT_TYPES_H
	23	#define _EXT_TYPES_H
	24
	25	#ifdef __cplusplus
	26	extern "C" {
	27	#endif /* __cplusplus */
	28
	29	/*
	30	* Scalar data types
	31	*/
	32	typedef unsigned char __ext_Elf32_Addr [ELF32_FSZ_ADDR];
	33	typedef unsigned char __ext_Elf32_Half [ELF32_FSZ_HALF];
	34	typedef unsigned char __ext_Elf32_Off [ELF32_FSZ_OFF];
	35	typedef unsigned char __ext_Elf32_Sword [ELF32_FSZ_SWORD];
	36	typedef unsigned char __ext_Elf32_Word [ELF32_FSZ_WORD];
	37
	38	#if __LIBELF64
	39
	40	typedef unsigned char __ext_Elf32_Lword [8];
	41
	42	typedef unsigned char __ext_Elf64_Addr [ELF64_FSZ_ADDR];
	43	typedef unsigned char __ext_Elf64_Half [ELF64_FSZ_HALF];
	44	typedef unsigned char __ext_Elf64_Off [ELF64_FSZ_OFF];
	45	typedef unsigned char __ext_Elf64_Sword [ELF64_FSZ_SWORD];
	46	typedef unsigned char __ext_Elf64_Word [ELF64_FSZ_WORD];
	47	typedef unsigned char __ext_Elf64_Sxword[ELF64_FSZ_SXWORD];
	48	typedef unsigned char __ext_Elf64_Xword [ELF64_FSZ_XWORD];
	49
	50	typedef unsigned char __ext_Elf64_Lword [8];
	51
	52	#endif /* __LIBELF64 */
	53
	54	/*
	55	* ELF header
	56	*/
	57	typedef struct {
	58	unsigned char e_ident[EI_NIDENT];
	59	__ext_Elf32_Half e_type;
	60	__ext_Elf32_Half e_machine;
	61	__ext_Elf32_Word e_version;
	62	__ext_Elf32_Addr e_entry;
	63	__ext_Elf32_Off e_phoff;
	64	__ext_Elf32_Off e_shoff;
	65	__ext_Elf32_Word e_flags;
	66	__ext_Elf32_Half e_ehsize;
	67	__ext_Elf32_Half e_phentsize;
	68	__ext_Elf32_Half e_phnum;
	69	__ext_Elf32_Half e_shentsize;
	70	__ext_Elf32_Half e_shnum;
	71	__ext_Elf32_Half e_shstrndx;
	72	} __ext_Elf32_Ehdr;
	73
	74	#if __LIBELF64
	75	typedef struct {
	76	unsigned char e_ident[EI_NIDENT];
	77	__ext_Elf64_Half e_type;
	78	__ext_Elf64_Half e_machine;
	79	__ext_Elf64_Word e_version;
	80	__ext_Elf64_Addr e_entry;
	81	__ext_Elf64_Off e_phoff;
	82	__ext_Elf64_Off e_shoff;
	83	__ext_Elf64_Word e_flags;
	84	__ext_Elf64_Half e_ehsize;
	85	__ext_Elf64_Half e_phentsize;
	86	__ext_Elf64_Half e_phnum;
	87	__ext_Elf64_Half e_shentsize;
	88	__ext_Elf64_Half e_shnum;
	89	__ext_Elf64_Half e_shstrndx;
	90	} __ext_Elf64_Ehdr;
	91	#endif /* __LIBELF64 */
	92
	93	/*
	94	* Section header
	95	*/
	96	typedef struct {
	97	__ext_Elf32_Word sh_name;
	98	__ext_Elf32_Word sh_type;
	99	__ext_Elf32_Word sh_flags;
	100	__ext_Elf32_Addr sh_addr;
	101	__ext_Elf32_Off sh_offset;
	102	__ext_Elf32_Word sh_size;
	103	__ext_Elf32_Word sh_link;
	104	__ext_Elf32_Word sh_info;
	105	__ext_Elf32_Word sh_addralign;
	106	__ext_Elf32_Word sh_entsize;
	107	} __ext_Elf32_Shdr;
	108
	109	#if __LIBELF64
	110	typedef struct {
	111	__ext_Elf64_Word sh_name;
	112	__ext_Elf64_Word sh_type;
	113	__ext_Elf64_Xword sh_flags;
	114	__ext_Elf64_Addr sh_addr;
	115	__ext_Elf64_Off sh_offset;
	116	__ext_Elf64_Xword sh_size;
	117	__ext_Elf64_Word sh_link;
	118	__ext_Elf64_Word sh_info;
	119	__ext_Elf64_Xword sh_addralign;
	120	__ext_Elf64_Xword sh_entsize;
	121	} __ext_Elf64_Shdr;
	122	#endif /* __LIBELF64 */
	123
	124	/*
	125	* Symbol table
	126	*/
	127	typedef struct {
	128	__ext_Elf32_Word st_name;
	129	__ext_Elf32_Addr st_value;
	130	__ext_Elf32_Word st_size;
	131	unsigned char st_info;
	132	unsigned char st_other;
	133	__ext_Elf32_Half st_shndx;
	134	} __ext_Elf32_Sym;
	135
	136	#if __LIBELF64
	137	typedef struct {
	138	__ext_Elf64_Word st_name;
	139	unsigned char st_info;
	140	unsigned char st_other;
	141	__ext_Elf64_Half st_shndx;
	142	__ext_Elf64_Addr st_value;
	143	__ext_Elf64_Xword st_size;
	144	} __ext_Elf64_Sym;
	145	#endif /* __LIBELF64 */
	146
	147	/*
	148	* Relocation
	149	*/
	150	typedef struct {
	151	__ext_Elf32_Addr r_offset;
	152	__ext_Elf32_Word r_info;
	153	} __ext_Elf32_Rel;
	154
	155	typedef struct {
	156	__ext_Elf32_Addr r_offset;
	157	__ext_Elf32_Word r_info;
	158	__ext_Elf32_Sword r_addend;
	159	} __ext_Elf32_Rela;
	160
	161	#if __LIBELF64
	162	typedef struct {
	163	__ext_Elf64_Addr r_offset;
	164	#if __LIBELF64_IRIX
	165	__ext_Elf64_Word r_sym;
	166	unsigned char r_ssym;
	167	unsigned char r_type3;
	168	unsigned char r_type2;
	169	unsigned char r_type;
	170	#else /* __LIBELF64_IRIX */
	171	__ext_Elf64_Xword r_info;
	172	#endif /* __LIBELF64_IRIX */
	173	} __ext_Elf64_Rel;
	174
	175	typedef struct {
	176	__ext_Elf64_Addr r_offset;
	177	#if __LIBELF64_IRIX
	178	__ext_Elf64_Word r_sym;
	179	unsigned char r_ssym;
	180	unsigned char r_type3;
	181	unsigned char r_type2;
	182	unsigned char r_type;
	183	#else /* __LIBELF64_IRIX */
	184	__ext_Elf64_Xword r_info;
	185	#endif /* __LIBELF64_IRIX */
	186	__ext_Elf64_Sxword r_addend;
	187	} __ext_Elf64_Rela;
	188	#endif /* __LIBELF64 */
	189
	190	/*
	191	* Program header
	192	*/
	193	typedef struct {
	194	__ext_Elf32_Word p_type;
	195	__ext_Elf32_Off p_offset;
	196	__ext_Elf32_Addr p_vaddr;
	197	__ext_Elf32_Addr p_paddr;
	198	__ext_Elf32_Word p_filesz;
	199	__ext_Elf32_Word p_memsz;
	200	__ext_Elf32_Word p_flags;
	201	__ext_Elf32_Word p_align;
	202	} __ext_Elf32_Phdr;
	203
	204	#if __LIBELF64
	205	typedef struct {
	206	__ext_Elf64_Word p_type;
	207	__ext_Elf64_Word p_flags;
	208	__ext_Elf64_Off p_offset;
	209	__ext_Elf64_Addr p_vaddr;
	210	__ext_Elf64_Addr p_paddr;
	211	__ext_Elf64_Xword p_filesz;
	212	__ext_Elf64_Xword p_memsz;
	213	__ext_Elf64_Xword p_align;
	214	} __ext_Elf64_Phdr;
	215	#endif /* __LIBELF64 */
	216
	217	/*
	218	* Dynamic structure
	219	*/
	220	typedef struct {
	221	__ext_Elf32_Sword d_tag;
	222	union {
	223	__ext_Elf32_Word d_val;
	224	__ext_Elf32_Addr d_ptr;
	225	} d_un;
	226	} __ext_Elf32_Dyn;
	227
	228	#if __LIBELF64
	229	typedef struct {
	230	__ext_Elf64_Sxword d_tag;
	231	union {
	232	__ext_Elf64_Xword d_val;
	233	__ext_Elf64_Addr d_ptr;
	234	} d_un;
	235	} __ext_Elf64_Dyn;
	236	#endif /* __LIBELF64 */
	237
	238	/*
	239	* Version definitions
	240	*/
	241	typedef struct {
	242	__ext_Elf32_Half vd_version;
	243	__ext_Elf32_Half vd_flags;
	244	__ext_Elf32_Half vd_ndx;
	245	__ext_Elf32_Half vd_cnt;
	246	__ext_Elf32_Word vd_hash;
	247	__ext_Elf32_Word vd_aux;
	248	__ext_Elf32_Word vd_next;
	249	} __ext_Elf32_Verdef;
	250
	251	typedef struct {
	252	__ext_Elf32_Word vda_name;
	253	__ext_Elf32_Word vda_next;
	254	} __ext_Elf32_Verdaux;
	255
	256	typedef struct {
	257	__ext_Elf32_Half vn_version;
	258	__ext_Elf32_Half vn_cnt;
	259	__ext_Elf32_Word vn_file;
	260	__ext_Elf32_Word vn_aux;
	261	__ext_Elf32_Word vn_next;
	262	} __ext_Elf32_Verneed;
	263
	264	typedef struct {
	265	__ext_Elf32_Word vna_hash;
	266	__ext_Elf32_Half vna_flags;
	267	__ext_Elf32_Half vna_other;
	268	__ext_Elf32_Word vna_name;
	269	__ext_Elf32_Word vna_next;
	270	} __ext_Elf32_Vernaux;
	271
	272	#if __LIBELF64
	273
	274	typedef struct {
	275	__ext_Elf64_Half vd_version;
	276	__ext_Elf64_Half vd_flags;
	277	__ext_Elf64_Half vd_ndx;
	278	__ext_Elf64_Half vd_cnt;
	279	__ext_Elf64_Word vd_hash;
	280	__ext_Elf64_Word vd_aux;
	281	__ext_Elf64_Word vd_next;
	282	} __ext_Elf64_Verdef;
	283
	284	typedef struct {
	285	__ext_Elf64_Word vda_name;
	286	__ext_Elf64_Word vda_next;
	287	} __ext_Elf64_Verdaux;
	288
	289	typedef struct {
	290	__ext_Elf64_Half vn_version;
	291	__ext_Elf64_Half vn_cnt;
	292	__ext_Elf64_Word vn_file;
	293	__ext_Elf64_Word vn_aux;
	294	__ext_Elf64_Word vn_next;
	295	} __ext_Elf64_Verneed;
	296
	297	typedef struct {
	298	__ext_Elf64_Word vna_hash;
	299	__ext_Elf64_Half vna_flags;
	300	__ext_Elf64_Half vna_other;
	301	__ext_Elf64_Word vna_name;
	302	__ext_Elf64_Word vna_next;
	303	} __ext_Elf64_Vernaux;
	304
	305	#endif /* __LIBELF64 */
	306
	307	/*
	308	* Move section
	309	*/
	310	#if __LIBELF64
	311
	312	typedef struct {
	313	__ext_Elf32_Lword m_value;
	314	__ext_Elf32_Word m_info;
	315	__ext_Elf32_Word m_poffset;
	316	__ext_Elf32_Half m_repeat;
	317	__ext_Elf32_Half m_stride;
	318	} __ext_Elf32_Move;
	319
	320	typedef struct {
	321	__ext_Elf64_Lword m_value;
	322	__ext_Elf64_Xword m_info;
	323	__ext_Elf64_Xword m_poffset;
	324	__ext_Elf64_Half m_repeat;
	325	__ext_Elf64_Half m_stride;
	326	} __ext_Elf64_Move;
	327
	328	#endif /* __LIBELF64 */
	329
	330	#ifdef __cplusplus
	331	}
	332	#endif /* __cplusplus */
	333
	334	#endif /* _EXT_TYPES_H */

src/common/genericBinaryFiles/elf/libelfWin32/include/libelf/gelf.h created 644 +155 0

@@ -0,0 +1,155
	1	/*
	2	* gelf.h - public header file for libelf.
	3	* Copyright (C) 2000 - 2006 Michael Riepe
	4	*
	5	* This library is free software; you can redistribute it and/or
	6	* modify it under the terms of the GNU Library General Public
	7	* License as published by the Free Software Foundation; either
	8	* version 2 of the License, or (at your option) any later version.
	9	*
	10	* This library is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	13	* Library General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU Library General Public
	16	* License along with this library; if not, write to the Free Software
	17	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
	18	*/
	19
	20	/* @(#) $Id: gelf.h,v 1.16 2008/05/23 08:15:34 michael Exp $ */
	21
	22	#ifndef _GELF_H
	23	#define _GELF_H
	24
	25	#if __LIBELF_INTERNAL__
	26	#include <libelf.h>
	27	#else /* __LIBELF_INTERNAL__ */
	28	#include <libelf/libelf.h>
	29	#endif /* __LIBELF_INTERNAL__ */
	30
	31	#if __LIBELF_NEED_LINK_H
	32	#include <link.h>
	33	#elif __LIBELF_NEED_SYS_LINK_H
	34	#include <sys/link.h>
	35	#endif /* __LIBELF_NEED_LINK_H */
	36
	37	#ifdef __cplusplus
	38	extern "C" {
	39	#endif /* __cplusplus */
	40
	41	#ifndef __P
	42	# if (__STDC__ + 0) \|\| defined(__cplusplus) \|\| defined(_WIN32)
	43	# define __P(args) args
	44	# else /* __STDC__ \|\| defined(__cplusplus) */
	45	# define __P(args) ()
	46	# endif /* __STDC__ \|\| defined(__cplusplus) */
	47	#endif /* __P */
	48
	49	#if !__LIBELF64
	50
	51	#error "GElf is not supported on this system."
	52
	53	#else /* __LIBELF64 */
	54
	55	typedef Elf64_Addr GElf_Addr;
	56	typedef Elf64_Half GElf_Half;
	57	typedef Elf64_Off GElf_Off;
	58	typedef Elf64_Sword GElf_Sword;
	59	typedef Elf64_Word GElf_Word;
	60	typedef Elf64_Sxword GElf_Sxword;
	61	typedef Elf64_Xword GElf_Xword;
	62
	63	typedef Elf64_Ehdr GElf_Ehdr;
	64	typedef Elf64_Phdr GElf_Phdr;
	65	typedef Elf64_Shdr GElf_Shdr;
	66	typedef Elf64_Dyn GElf_Dyn;
	67	typedef Elf64_Rel GElf_Rel;
	68	typedef Elf64_Rela GElf_Rela;
	69	typedef Elf64_Sym GElf_Sym;
	70
	71	/*
	72	* Symbol versioning
	73	*/
	74	#if __LIBELF_SYMBOL_VERSIONS
	75	typedef Elf64_Verdef GElf_Verdef;
	76	typedef Elf64_Verneed GElf_Verneed;
	77	typedef Elf64_Verdaux GElf_Verdaux;
	78	typedef Elf64_Vernaux GElf_Vernaux;
	79	#endif /* __LIBELF_SYMBOL_VERSIONS */
	80
	81	/*
	82	* These types aren't implemented (yet)
	83	*
	84	typedef Elf64_Move GElf_Move;
	85	typedef Elf64_Syminfo GElf_Syminfo;
	86	*/
	87
	88	/*
	89	* Generic macros
	90	*/
	91	#define GELF_ST_BIND ELF64_ST_BIND
	92	#define GELF_ST_TYPE ELF64_ST_TYPE
	93	#define GELF_ST_INFO ELF64_ST_INFO
	94
	95	#define GELF_R_TYPE ELF64_R_TYPE
	96	#define GELF_R_SYM ELF64_R_SYM
	97	#define GELF_R_INFO ELF64_R_INFO
	98
	99	/*
	100	* Function declarations
	101	*/
	102	extern int gelf_getclass __P((Elf *__elf));
	103
	104	extern size_t gelf_fsize __P((Elf *__elf, Elf_Type __type, size_t __count, unsigned __ver));
	105
	106	extern Elf_Data gelf_xlatetof __P((Elf __elf, Elf_Data __dst, const Elf_Data __src, unsigned __encode));
	107	extern Elf_Data gelf_xlatetom __P((Elf __elf, Elf_Data __dst, const Elf_Data __src, unsigned __encode));
	108
	109	extern GElf_Ehdr gelf_getehdr __P((Elf __elf, GElf_Ehdr *__dst));
	110	extern int gelf_update_ehdr __P((Elf __elf, GElf_Ehdr __src));
	111	extern unsigned long gelf_newehdr __P((Elf *__elf, int __elfclass));
	112
	113	extern GElf_Phdr gelf_getphdr __P((Elf __elf, int ndx, GElf_Phdr *__dst));
	114	extern int gelf_update_phdr __P((Elf __elf, int ndx, GElf_Phdr __src));
	115	extern unsigned long gelf_newphdr __P((Elf *__elf, size_t __phnum));
	116
	117	extern GElf_Shdr gelf_getshdr __P((Elf_Scn __scn, GElf_Shdr *__dst));
	118	extern int gelf_update_shdr __P((Elf_Scn __scn, GElf_Shdr __src));
	119
	120	extern GElf_Dyn gelf_getdyn __P((Elf_Data __src, int __ndx, GElf_Dyn *__dst));
	121	extern int gelf_update_dyn __P((Elf_Data __dst, int __ndx, GElf_Dyn __src));
	122
	123	extern GElf_Rel gelf_getrel __P((Elf_Data __src, int __ndx, GElf_Rel *__dst));
	124	extern int gelf_update_rel __P((Elf_Data __dst, int __ndx, GElf_Rel __src));
	125
	126	extern GElf_Rela gelf_getrela __P((Elf_Data __src, int __ndx, GElf_Rela *__dst));
	127	extern int gelf_update_rela __P((Elf_Data __dst, int __ndx, GElf_Rela __src));
	128
	129	extern GElf_Sym gelf_getsym __P((Elf_Data __src, int __ndx, GElf_Sym *__dst));
	130	extern int gelf_update_sym __P((Elf_Data __dst, int __ndx, GElf_Sym __src));
	131
	132	extern long gelf_checksum __P((Elf *__elf));
	133
	134	/*
	135	* These functions aren't implemented (yet)
	136	*
	137	extern GElf_Move gelf_getmove __P((Elf_Data __src, int __ndx, GElf_Move *__src));
	138	extern int gelf_update_move __P((Elf_Data __dst, int __ndx, GElf_Move __src));
	139	*
	140	extern GElf_Syminfo* gelf_getsyminfo __P((Elf_Data __src, int __ndx, GElf_Syminfo __dst));
	141	extern int gelf_update_syminfo __P((Elf_Data __dst, int __ndx, GElf_Syminfo __src));
	142	*/
	143
	144	/*
	145	* Extensions (not available in other versions of libelf)
	146	*/
	147	extern size_t gelf_msize __P((Elf *__elf, Elf_Type __type, size_t __count, unsigned __ver));
	148
	149	#endif /* __LIBELF64 */
	150
	151	#ifdef __cplusplus
	152	}
	153	#endif /* __cplusplus */
	154
	155	#endif /* _GELF_H */

src/common/genericBinaryFiles/elf/libelfWin32/include/libelf/libelf.h created 644 +305 0

@@ -0,0 +1,305
	1	/*
	2	* libelf.h - public header file for libelf.
	3	* Copyright (C) 1995 - 2008 Michael Riepe
	4	*
	5	* This library is free software; you can redistribute it and/or
	6	* modify it under the terms of the GNU Library General Public
	7	* License as published by the Free Software Foundation; either
	8	* version 2 of the License, or (at your option) any later version.
	9	*
	10	* This library is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	13	* Library General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU Library General Public
	16	* License along with this library; if not, write to the Free Software
	17	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
	18	*/
	19
	20	/* @(#) $Id: libelf.h,v 1.29 2009/07/07 17:57:43 michael Exp $ */
	21
	22	#ifndef _LIBELF_H
	23	#define _LIBELF_H
	24
	25	#include <stddef.h> /* for size_t */
	26	#include <sys/types.h>
	27
	28	#if __LIBELF_INTERNAL__
	29	#include <sys_elf.h>
	30	#else /* __LIBELF_INTERNAL__ */
	31	#include <libelf/sys_elf.h>
	32	#endif /* __LIBELF_INTERNAL__ */
	33
	34	#if defined __GNUC__ && !defined __cplusplus
	35	#define DEPRECATED __attribute__((deprecated))
	36	#else
	37	#define DEPRECATED /* nothing */
	38	#endif
	39
	40	#ifdef __cplusplus
	41	extern "C" {
	42	#endif /* __cplusplus */
	43
	44	#ifndef __P
	45	# if (__STDC__ + 0) \|\| defined(__cplusplus) \|\| defined(_WIN32)
	46	# define __P(args) args
	47	# else /* __STDC__ \|\| defined(__cplusplus) */
	48	# define __P(args) ()
	49	# endif /* __STDC__ \|\| defined(__cplusplus) */
	50	#endif /* __P */
	51
	52	/*
	53	* Commands
	54	*/
	55	typedef enum {
	56	ELF_C_NULL = 0, /* must be first, 0 */
	57	ELF_C_READ,
	58	ELF_C_WRITE,
	59	ELF_C_CLR,
	60	ELF_C_SET,
	61	ELF_C_FDDONE,
	62	ELF_C_FDREAD,
	63	ELF_C_RDWR,
	64	ELF_C_NUM /* must be last */
	65	} Elf_Cmd;
	66
	67	/*
	68	* Flags
	69	*/
	70	#define ELF_F_DIRTY 0x1
	71	#define ELF_F_LAYOUT 0x4
	72	/*
	73	* Allow sections to overlap when ELF_F_LAYOUT is in effect.
	74	* Note that this flag ist NOT portable, and that it may render
	75	* the output file unusable. Use with extreme caution!
	76	*/
	77	#define ELF_F_LAYOUT_OVERLAP 0x10000000
	78
	79	/*
	80	* File types
	81	*/
	82	typedef enum {
	83	ELF_K_NONE = 0, /* must be first, 0 */
	84	ELF_K_AR,
	85	ELF_K_COFF,
	86	ELF_K_ELF,
	87	ELF_K_NUM /* must be last */
	88	} Elf_Kind;
	89
	90	/*
	91	* Data types
	92	*/
	93	typedef enum {
	94	ELF_T_BYTE = 0, /* must be first, 0 */
	95	ELF_T_ADDR,
	96	ELF_T_DYN,
	97	ELF_T_EHDR,
	98	ELF_T_HALF,
	99	ELF_T_OFF,
	100	ELF_T_PHDR,
	101	ELF_T_RELA,
	102	ELF_T_REL,
	103	ELF_T_SHDR,
	104	ELF_T_SWORD,
	105	ELF_T_SYM,
	106	ELF_T_WORD,
	107	/*
	108	* New stuff for 64-bit.
	109	*
	110	* Most implementations add ELF_T_SXWORD after ELF_T_SWORD
	111	* which breaks binary compatibility with earlier versions.
	112	* If this causes problems for you, contact me.
	113	*/
	114	ELF_T_SXWORD,
	115	ELF_T_XWORD,
	116	/*
	117	* Symbol versioning. Sun broke binary compatibility (again!),
	118	* but I won't.
	119	*/
	120	ELF_T_VDEF,
	121	ELF_T_VNEED,
	122	ELF_T_NUM /* must be last */
	123	} Elf_Type;
	124
	125	/*
	126	* Elf descriptor
	127	*/
	128	typedef struct Elf Elf;
	129
	130	/*
	131	* Section descriptor
	132	*/
	133	typedef struct Elf_Scn Elf_Scn;
	134
	135	/*
	136	* Archive member header
	137	*/
	138	typedef struct {
	139	char* ar_name;
	140	time_t ar_date;
	141	long ar_uid;
	142	long ar_gid;
	143	unsigned long ar_mode;
	144	off_t ar_size;
	145	char* ar_rawname;
	146	} Elf_Arhdr;
	147
	148	/*
	149	* Archive symbol table
	150	*/
	151	typedef struct {
	152	char* as_name;
	153	size_t as_off;
	154	unsigned long as_hash;
	155	} Elf_Arsym;
	156
	157	/*
	158	* Data descriptor
	159	*/
	160	typedef struct {
	161	void* d_buf;
	162	Elf_Type d_type;
	163	size_t d_size;
	164	off_t d_off;
	165	size_t d_align;
	166	unsigned d_version;
	167	} Elf_Data;
	168
	169	/*
	170	* Function declarations
	171	*/
	172	extern Elf elf_begin __P((int __fd, Elf_Cmd __cmd, Elf __ref));
	173	extern Elf elf_memory __P((char __image, size_t __size));
	174	extern int elf_cntl __P((Elf *__elf, Elf_Cmd __cmd));
	175	extern int elf_end __P((Elf *__elf));
	176	extern const char *elf_errmsg __P((int __err));
	177	extern int elf_errno __P((void));
	178	extern void elf_fill __P((int __fill));
	179	extern unsigned elf_flagdata __P((Elf_Data *__data, Elf_Cmd __cmd,
	180	unsigned __flags));
	181	extern unsigned elf_flagehdr __P((Elf *__elf, Elf_Cmd __cmd,
	182	unsigned __flags));
	183	extern unsigned elf_flagelf __P((Elf *__elf, Elf_Cmd __cmd,
	184	unsigned __flags));
	185	extern unsigned elf_flagphdr __P((Elf *__elf, Elf_Cmd __cmd,
	186	unsigned __flags));
	187	extern unsigned elf_flagscn __P((Elf_Scn *__scn, Elf_Cmd __cmd,
	188	unsigned __flags));
	189	extern unsigned elf_flagshdr __P((Elf_Scn *__scn, Elf_Cmd __cmd,
	190	unsigned __flags));
	191	extern size_t elf32_fsize __P((Elf_Type __type, size_t __count,
	192	unsigned __ver));
	193	extern Elf_Arhdr elf_getarhdr __P((Elf __elf));
	194	extern Elf_Arsym elf_getarsym __P((Elf __elf, size_t *__ptr));
	195	extern off_t elf_getbase __P((Elf *__elf));
	196	extern Elf_Data elf_getdata __P((Elf_Scn __scn, Elf_Data *__data));
	197	extern Elf32_Ehdr elf32_getehdr __P((Elf __elf));
	198	extern char elf_getident __P((Elf __elf, size_t *__ptr));
	199	extern Elf32_Phdr elf32_getphdr __P((Elf __elf));
	200	extern Elf_Scn elf_getscn __P((Elf __elf, size_t __index));
	201	extern Elf32_Shdr elf32_getshdr __P((Elf_Scn __scn));
	202	extern unsigned long elf_hash __P((const unsigned char *__name));
	203	extern Elf_Kind elf_kind __P((Elf *__elf));
	204	extern size_t elf_ndxscn __P((Elf_Scn *__scn));
	205	extern Elf_Data elf_newdata __P((Elf_Scn __scn));
	206	extern Elf32_Ehdr elf32_newehdr __P((Elf __elf));
	207	extern Elf32_Phdr elf32_newphdr __P((Elf __elf, size_t __count));
	208	extern Elf_Scn elf_newscn __P((Elf __elf));
	209	extern Elf_Cmd elf_next __P((Elf *__elf));
	210	extern Elf_Scn elf_nextscn __P((Elf __elf, Elf_Scn *__scn));
	211	extern size_t elf_rand __P((Elf *__elf, size_t __offset));
	212	extern Elf_Data elf_rawdata __P((Elf_Scn __scn, Elf_Data *__data));
	213	extern char elf_rawfile __P((Elf __elf, size_t *__ptr));
	214	extern char elf_strptr __P((Elf __elf, size_t __section, size_t __offset));
	215	extern off_t elf_update __P((Elf *__elf, Elf_Cmd __cmd));
	216	extern unsigned elf_version __P((unsigned __ver));
	217	extern Elf_Data elf32_xlatetof __P((Elf_Data __dst, const Elf_Data *__src,
	218	unsigned __encode));
	219	extern Elf_Data elf32_xlatetom __P((Elf_Data __dst, const Elf_Data *__src,
	220	unsigned __encode));
	221
	222	/*
	223	* Additional functions found on Solaris
	224	*/
	225	extern long elf32_checksum __P((Elf *__elf));
	226
	227	#if __LIBELF64
	228	/*
	229	* 64-bit ELF functions
	230	* Not available on all platforms
	231	*/
	232	extern Elf64_Ehdr elf64_getehdr __P((Elf __elf));
	233	extern Elf64_Ehdr elf64_newehdr __P((Elf __elf));
	234	extern Elf64_Phdr elf64_getphdr __P((Elf __elf));
	235	extern Elf64_Phdr elf64_newphdr __P((Elf __elf, size_t __count));
	236	extern Elf64_Shdr elf64_getshdr __P((Elf_Scn __scn));
	237	extern size_t elf64_fsize __P((Elf_Type __type, size_t __count,
	238	unsigned __ver));
	239	extern Elf_Data elf64_xlatetof __P((Elf_Data __dst, const Elf_Data *__src,
	240	unsigned __encode));
	241	extern Elf_Data elf64_xlatetom __P((Elf_Data __dst, const Elf_Data *__src,
	242	unsigned __encode));
	243
	244	/*
	245	* Additional functions found on Solaris
	246	*/
	247	extern long elf64_checksum __P((Elf *__elf));
	248
	249	#endif /* __LIBELF64 */
	250
	251	/*
	252	* ELF format extensions
	253	*
	254	* These functions return 0 on failure, 1 on success. Since other
	255	* implementations of libelf may behave differently (there was quite
	256	* some confusion about the correct values), they are now officially
	257	* deprecated and should be replaced with the three new functions below.
	258	*/
	259	DEPRECATED extern int elf_getphnum __P((Elf __elf, size_t __resultp));
	260	DEPRECATED extern int elf_getshnum __P((Elf __elf, size_t __resultp));
	261	DEPRECATED extern int elf_getshstrndx __P((Elf __elf, size_t __resultp));
	262	/*
	263	* Replacement functions (return -1 on failure, 0 on success).
	264	*/
	265	extern int elf_getphdrnum __P((Elf __elf, size_t __resultp));
	266	extern int elf_getshdrnum __P((Elf __elf, size_t __resultp));
	267	extern int elf_getshdrstrndx __P((Elf __elf, size_t __resultp));
	268
	269	/*
	270	* Convenience functions
	271	*
	272	* elfx_update_shstrndx is elf_getshstrndx's counterpart.
	273	* It should be used to set the e_shstrndx member.
	274	* There is no update function for e_shnum or e_phnum
	275	* because libelf handles them internally.
	276	*/
	277	extern int elfx_update_shstrndx __P((Elf *__elf, size_t __index));
	278
	279	/*
	280	* Experimental extensions:
	281	*
	282	* elfx_movscn() moves section `__scn' directly after section `__after'.
	283	* elfx_remscn() removes section `__scn'. Both functions update
	284	* the section indices; elfx_remscn() also adjusts the ELF header's
	285	* e_shnum member. The application is responsible for updating other
	286	* data (in particular, e_shstrndx and the section headers' sh_link and
	287	* sh_info members).
	288	*
	289	* elfx_movscn() returns the new index of the moved section.
	290	* elfx_remscn() returns the original index of the removed section.
	291	* A return value of zero indicates an error.
	292	*/
	293	extern size_t elfx_movscn __P((Elf __elf, Elf_Scn __scn, Elf_Scn *__after));
	294	extern size_t elfx_remscn __P((Elf __elf, Elf_Scn __scn));
	295
	296	/*
	297	* elf_delscn() is obsolete. Please use elfx_remscn() instead.
	298	*/
	299	extern size_t elf_delscn __P((Elf __elf, Elf_Scn __scn));
	300
	301	#ifdef __cplusplus
	302	}
	303	#endif /* __cplusplus */
	304
	305	#endif /* _LIBELF_H */

src/common/genericBinaryFiles/elf/libelfWin32/include/libelf/nlist.h created 644 +48 0

@@ -0,0 +1,48
	1	/*
	2	* nlist.h - public header file for nlist(3).
	3	* Copyright (C) 1995 - 2006 Michael Riepe
	4	*
	5	* This library is free software; you can redistribute it and/or
	6	* modify it under the terms of the GNU Library General Public
	7	* License as published by the Free Software Foundation; either
	8	* version 2 of the License, or (at your option) any later version.
	9	*
	10	* This library is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	13	* Library General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU Library General Public
	16	* License along with this library; if not, write to the Free Software
	17	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
	18	*/
	19
	20	/* @(#) $Id: nlist.h,v 1.10 2008/05/23 08:15:35 michael Exp $ */
	21
	22	#ifndef _NLIST_H
	23	#define _NLIST_H
	24
	25	#ifdef __cplusplus
	26	extern "C" {
	27	#endif /* __cplusplus */
	28
	29	struct nlist {
	30	char* n_name;
	31	long n_value;
	32	short n_scnum;
	33	unsigned short n_type;
	34	char n_sclass;
	35	char n_numaux;
	36	};
	37
	38	#if (__STDC__ + 0) \|\| defined(__cplusplus) \|\| defined(_WIN32)
	39	extern int nlist(const char __filename, struct nlist __nl);
	40	#else /* __STDC__ \|\| defined(__cplusplus) */
	41	extern int nlist();
	42	#endif /* __STDC__ \|\| defined(__cplusplus) */
	43
	44	#ifdef __cplusplus
	45	}
	46	#endif /* __cplusplus */
	47
	48	#endif /* _NLIST_H */

src/common/genericBinaryFiles/elf/libelfWin32/include/libelf/private.h created 644 +446 0

@@ -0,0 +1,446
	1	/*
	2	* private.h - private definitions for libelf.
	3	* Copyright (C) 1995 - 2007 Michael Riepe
	4	*
	5	* This library is free software; you can redistribute it and/or
	6	* modify it under the terms of the GNU Library General Public
	7	* License as published by the Free Software Foundation; either
	8	* version 2 of the License, or (at your option) any later version.
	9	*
	10	* This library is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	13	* Library General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU Library General Public
	16	* License along with this library; if not, write to the Free Software
	17	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
	18	*/
	19
	20	/* @(#) $Id: private.h,v 1.40 2009/11/01 13:04:19 michael Exp $ */
	21
	22	#ifndef _PRIVATE_H
	23	#define _PRIVATE_H
	24
	25	#define __LIBELF_INTERNAL__ 1
	26
	27	#if HAVE_CONFIG_H
	28	# include <config.h>
	29	#endif /* HAVE_CONFIG_H */
	30
	31	/*
	32	* Workaround for GLIBC bug:
	33	* include <stdint.h> before <sys/types.h>
	34	*/
	35	#if HAVE_STDINT_H
	36	#include <stdint.h>
	37	#endif
	38	#include <sys/types.h>
	39
	40	#if STDC_HEADERS
	41	# include <stdlib.h>
	42	# include <string.h>
	43	#else /* STDC_HEADERS */
	44	extern void malloc(), realloc();
	45	extern void free(), bcopy(), abort();
	46	extern int strcmp(), strncmp(), memcmp();
	47	extern void memcpy(), memmove(), *memset();
	48	#endif /* STDC_HEADERS */
	49
	50	#if defined(_WIN32)
	51	#include <io.h>
	52	#else
	53	#if HAVE_UNISTD_H
	54	# include <unistd.h>
	55	#else /* HAVE_UNISTD_H */
	56	extern int read(), write(), close();
	57	extern off_t lseek();
	58	#if HAVE_FTRUNCATE
	59	extern int ftruncate();
	60	#endif /* HAVE_FTRUNCATE */
	61	#endif /* HAVE_UNISTD_H */
	62	#endif /* defined(_WIN32) */
	63
	64	#ifndef SEEK_SET
	65	#define SEEK_SET 0
	66	#endif /* SEEK_SET */
	67	#ifndef SEEK_CUR
	68	#define SEEK_CUR 1
	69	#endif /* SEEK_CUR */
	70	#ifndef SEEK_END
	71	#define SEEK_END 2
	72	#endif /* SEEK_END */
	73
	74	#if !HAVE_MEMCMP
	75	# define memcmp strncmp
	76	#endif /* !HAVE_MEMCMP */
	77	#if !HAVE_MEMCPY
	78	# define memcpy(d,s,n) bcopy(s,d,n)
	79	#endif /* !HAVE_MEMCPY */
	80	#if !HAVE_MEMMOVE
	81	# define memmove(d,s,n) bcopy(s,d,n)
	82	#endif /* !HAVE_MEMMOVE */
	83
	84	#if !HAVE_MEMSET
	85	# define memset _elf_memset
	86	extern void *_elf_memset();
	87	#endif /* !HAVE_MEMSET */
	88
	89	#if HAVE_STRUCT_NLIST_DECLARATION
	90	# define nlist __override_nlist_declaration
	91	#endif /* HAVE_STRUCT_NLIST_DECLARATION */
	92
	93	#if __LIBELF_NEED_LINK_H
	94	# include <link.h>
	95	#elif __LIBELF_NEED_SYS_LINK_H
	96	# include <sys/link.h>
	97	#endif /* __LIBELF_NEED_LINK_H */
	98
	99	#if HAVE_AR_H
	100	#include <ar.h>
	101	#else /* HAVE_AR_H */
	102
	103	#define ARMAG "!<arch>\n"
	104	#define SARMAG 8
	105
	106	struct ar_hdr {
	107	char ar_name[16];
	108	char ar_date[12];
	109	char ar_uid[6];
	110	char ar_gid[6];
	111	char ar_mode[8];
	112	char ar_size[10];
	113	char ar_fmag[2];
	114	};
	115
	116	#define ARFMAG "`\n"
	117
	118	#endif /* HAVE_AR_H */
	119
	120	#include <libelf.h>
	121
	122	#if HAVE_STRUCT_NLIST_DECLARATION
	123	# undef nlist
	124	#endif /* HAVE_STRUCT_NLIST_DECLARATION */
	125
	126	#if __LIBELF64
	127	#include <gelf.h>
	128	#endif /* __LIBELF64 */
	129
	130	typedef struct Scn_Data Scn_Data;
	131
	132	/*
	133	* ELF descriptor
	134	*/
	135	struct Elf {
	136	/* common */
	137	size_t e_size; /* file/member size */
	138	size_t e_dsize; /* size of memory image */
	139	Elf_Kind e_kind; /* kind of file */
	140	char* e_data; /* file/member data */
	141	char* e_rawdata; /* file/member raw data */
	142	size_t e_idlen; /* identifier size */
	143	int e_fd; /* file descriptor */
	144	unsigned e_count; /* activation count */
	145	/* archive members (still common) */
	146	Elf* e_parent; /* NULL if not an archive member */
	147	size_t e_next; /* 0 if not an archive member */
	148	size_t e_base; /* 0 if not an archive member */
	149	Elf* e_link; /* next archive member or NULL */
	150	Elf_Arhdr* e_arhdr; /* archive member header or NULL */
	151	/* archives */
	152	size_t e_off; /* current member offset (for elf_begin) */
	153	Elf* e_members; /* linked list of active archive members */
	154	char* e_symtab; /* archive symbol table */
	155	size_t e_symlen; /* length of archive symbol table */
	156	char* e_strtab; /* archive string table */
	157	size_t e_strlen; /* length of archive string table */
	158	/* ELF files */
	159	unsigned e_class; /* ELF class */
	160	unsigned e_encoding; /* ELF data encoding */
	161	unsigned e_version; /* ELF version */
	162	char* e_ehdr; /* ELF header */
	163	char* e_phdr; /* ELF program header table */
	164	size_t e_phnum; /* size of program header table */
	165	Elf_Scn* e_scn_1; /* first section */
	166	Elf_Scn* e_scn_n; /* last section */
	167	unsigned e_elf_flags; /* elf flags (ELF_F_) /
	168	unsigned e_ehdr_flags; /* ehdr flags (ELF_F_) /
	169	unsigned e_phdr_flags; /* phdr flags (ELF_F_) /
	170	/* misc flags */
	171	unsigned e_readable : 1; /* file is readable */
	172	unsigned e_writable : 1; /* file is writable */
	173	unsigned e_disabled : 1; /* e_fd has been disabled */
	174	unsigned e_cooked : 1; /* e_data was modified */
	175	unsigned e_free_syms : 1; /* e_symtab is malloc'ed */
	176	unsigned e_unmap_data : 1; /* e_data is mmap'ed */
	177	unsigned e_memory : 1; /* created by elf_memory() */
	178	/* magic number for debugging */
	179	long e_magic;
	180	};
	181
	182	#define ELF_MAGIC 0x012b649e
	183
	184	#define INIT_ELF {\
	185	/* e_size */ 0,\
	186	/* e_dsize */ 0,\
	187	/* e_kind */ ELF_K_NONE,\
	188	/* e_data */ NULL,\
	189	/* e_rawdata */ NULL,\
	190	/* e_idlen */ 0,\
	191	/* e_fd */ -1,\
	192	/* e_count */ 1,\
	193	/* e_parent */ NULL,\
	194	/* e_next */ 0,\
	195	/* e_base */ 0,\
	196	/* e_link */ NULL,\
	197	/* e_arhdr */ NULL,\
	198	/* e_off */ 0,\
	199	/* e_members */ NULL,\
	200	/* e_symtab */ NULL,\
	201	/* e_symlen */ 0,\
	202	/* e_strtab */ NULL,\
	203	/* e_strlen */ 0,\
	204	/* e_class */ ELFCLASSNONE,\
	205	/* e_encoding */ ELFDATANONE,\
	206	/* e_version */ EV_NONE,\
	207	/* e_ehdr */ NULL,\
	208	/* e_phdr */ NULL,\
	209	/* e_phnum */ 0,\
	210	/* e_scn_1 */ NULL,\
	211	/* e_scn_n */ NULL,\
	212	/* e_elf_flags */ 0,\
	213	/* e_ehdr_flags */ 0,\
	214	/* e_phdr_flags */ 0,\
	215	/* e_readable */ 0,\
	216	/* e_writable */ 0,\
	217	/* e_disabled */ 0,\
	218	/* e_cooked */ 0,\
	219	/* e_free_syms */ 0,\
	220	/* e_unmap_data */ 0,\
	221	/* e_memory */ 0,\
	222	/* e_magic */ ELF_MAGIC\
	223	}
	224
	225	/*
	226	* Section descriptor
	227	*/
	228	struct Elf_Scn {
	229	Elf_Scn* s_link; /* pointer to next Elf_Scn */
	230	Elf* s_elf; /* pointer to elf descriptor */
	231	size_t s_index; /* number of this section */
	232	unsigned s_scn_flags; /* section flags (ELF_F_) /
	233	unsigned s_shdr_flags; /* shdr flags (ELF_F_) /
	234	Scn_Data* s_data_1; /* first data buffer */
	235	Scn_Data* s_data_n; /* last data buffer */
	236	Scn_Data* s_rawdata; /* raw data buffer */
	237	/* data copied from shdr */
	238	unsigned s_type; /* section type */
	239	size_t s_offset; /* section offset */
	240	size_t s_size; /* section size */
	241	/* misc flags */
	242	unsigned s_freeme : 1; /* this Elf_Scn was malloc'ed */
	243	/* section header */
	244	union {
	245	#if __LIBELF64
	246	Elf64_Shdr u_shdr64;
	247	#endif /* __LIBELF64 */
	248	Elf32_Shdr u_shdr32;
	249	} s_uhdr;
	250	/* magic number for debugging */
	251	long s_magic;
	252	};
	253	#define s_shdr32 s_uhdr.u_shdr32
	254	#define s_shdr64 s_uhdr.u_shdr64
	255
	256	#define SCN_MAGIC 0x012c747d
	257
	258	#define INIT_SCN {\
	259	/* s_link */ NULL,\
	260	/* s_elf */ NULL,\
	261	/* s_index */ 0,\
	262	/* s_scn_flags */ 0,\
	263	/* s_shdr_flags */ 0,\
	264	/* s_data_1 */ NULL,\
	265	/* s_data_n */ NULL,\
	266	/* s_rawdata */ NULL,\
	267	/* s_type */ SHT_NULL,\
	268	/* s_offset */ 0,\
	269	/* s_size */ 0,\
	270	/* s_freeme */ 0,\
	271	/* s_uhdr */ {{0,}},\
	272	/* s_magic */ SCN_MAGIC\
	273	}
	274
	275	/*
	276	* Data descriptor
	277	*/
	278	struct Scn_Data {
	279	Elf_Data sd_data; /* must be first! */
	280	Scn_Data* sd_link; /* pointer to next Scn_Data */
	281	Elf_Scn* sd_scn; /* pointer to section */
	282	char* sd_memdata; /* memory image of section */
	283	unsigned sd_data_flags; /* data flags (ELF_F_) /
	284	/* misc flags */
	285	unsigned sd_freeme : 1; /* this Scn_Data was malloc'ed */
	286	unsigned sd_free_data : 1; /* sd_memdata is malloc'ed */
	287	/* magic number for debugging */
	288	long sd_magic;
	289	};
	290
	291	#define DATA_MAGIC 0x01072639
	292
	293	#define INIT_DATA {\
	294	{\
	295	/* d_buf */ NULL,\
	296	/* d_type */ ELF_T_BYTE,\
	297	/* d_size */ 0,\
	298	/* d_off */ 0,\
	299	/* d_align */ 0,\
	300	/* d_version */ EV_NONE\
	301	},\
	302	/* sd_link */ NULL,\
	303	/* sd_scn */ NULL,\
	304	/* sd_memdata */ NULL,\
	305	/* sd_data_flags */ 0,\
	306	/* sd_freeme */ 0,\
	307	/* sd_free_data */ 0,\
	308	/* sd_magic */ DATA_MAGIC\
	309	}
	310
	311	/*
	312	* Private status variables
	313	*/
	314	extern unsigned _elf_version;
	315	extern int _elf_errno;
	316	extern int _elf_fill;
	317	extern int _elf_sanity_checks;
	318	#define SANITY_CHECK_STRPTR (1u << 0)
	319
	320	/*
	321	* Private functions
	322	*/
	323	extern void _elf_read __P((Elf, void*, size_t, size_t));
	324	extern void _elf_mmap __P((Elf));
	325	extern int _elf_cook __P((Elf*));
	326	extern char _elf_getehdr __P((Elf, unsigned));
	327	extern char _elf_getphdr __P((Elf, unsigned));
	328	extern Elf_Data _elf_xlatetom __P((const Elf, Elf_Data, const Elf_Data));
	329	extern Elf_Type _elf_scn_type __P((unsigned));
	330	extern size_t _elf32_xltsize __P((const Elf_Data *__src, unsigned __dv, unsigned __encode, int __tof));
	331	extern size_t _elf64_xltsize __P((const Elf_Data *__src, unsigned __dv, unsigned __encode, int __tof));
	332	extern int _elf_update_shnum(Elf *__elf, size_t __shnum);
	333	extern Elf_Scn _elf_first_scn(Elf __elf);
	334
	335	/*
	336	* Special translators
	337	*/
	338	extern size_t _elf_verdef_32L11_tof __P((unsigned char dst, const unsigned char src, size_t n));
	339	extern size_t _elf_verdef_32L11_tom __P((unsigned char dst, const unsigned char src, size_t n));
	340	extern size_t _elf_verdef_32M11_tof __P((unsigned char dst, const unsigned char src, size_t n));
	341	extern size_t _elf_verdef_32M11_tom __P((unsigned char dst, const unsigned char src, size_t n));
	342	extern size_t _elf_verdef_64L11_tof __P((unsigned char dst, const unsigned char src, size_t n));
	343	extern size_t _elf_verdef_64L11_tom __P((unsigned char dst, const unsigned char src, size_t n));
	344	extern size_t _elf_verdef_64M11_tof __P((unsigned char dst, const unsigned char src, size_t n));
	345	extern size_t _elf_verdef_64M11_tom __P((unsigned char dst, const unsigned char src, size_t n));
	346	extern size_t _elf_verneed_32L11_tof __P((unsigned char dst, const unsigned char src, size_t n));
	347	extern size_t _elf_verneed_32L11_tom __P((unsigned char dst, const unsigned char src, size_t n));
	348	extern size_t _elf_verneed_32M11_tof __P((unsigned char dst, const unsigned char src, size_t n));
	349	extern size_t _elf_verneed_32M11_tom __P((unsigned char dst, const unsigned char src, size_t n));
	350	extern size_t _elf_verneed_64L11_tof __P((unsigned char dst, const unsigned char src, size_t n));
	351	extern size_t _elf_verneed_64L11_tom __P((unsigned char dst, const unsigned char src, size_t n));
	352	extern size_t _elf_verneed_64M11_tof __P((unsigned char dst, const unsigned char src, size_t n));
	353	extern size_t _elf_verneed_64M11_tom __P((unsigned char dst, const unsigned char src, size_t n));
	354
	355	/*
	356	* Private data
	357	*/
	358	extern const Elf_Scn _elf_scn_init;
	359	extern const Scn_Data _elf_data_init;
	360	extern const size_t _elf_fmsize[2][EV_CURRENT - EV_NONE][ELF_T_NUM][2];
	361
	362	/*
	363	* Access macros for _elf_fmsize[]
	364	*/
	365	#define _fmsize(c,v,t,w) \
	366	(_elf_fmsize[(c)-ELFCLASS32][(v)-EV_NONE-1][(t)-ELF_T_BYTE][(w)])
	367	#define _fsize(c,v,t) _fmsize((c),(v),(t),1)
	368	#define _msize(c,v,t) _fmsize((c),(v),(t),0)
	369
	370	/*
	371	* Various checks
	372	*/
	373	#define valid_class(c) ((c) >= ELFCLASS32 && (c) <= ELFCLASS64)
	374	#define valid_encoding(e) ((e) >= ELFDATA2LSB && (e) <= ELFDATA2MSB)
	375	#define valid_version(v) ((v) > EV_NONE && (v) <= EV_CURRENT)
	376	#define valid_type(t) ((unsigned)(t) < ELF_T_NUM)
	377
	378	/*
	379	* Error codes
	380	*/
	381	enum {
	382	#define __err__(a,b) a,
	383	#include <errors.h> /* include constants from errors.h */
	384	#undef __err__
	385	ERROR_NUM
	386	};
	387
	388	#define seterr(err) (_elf_errno = (err))
	389
	390	/*
	391	* Sizes of data types (external representation)
	392	* These definitions should be in <elf.h>, but...
	393	*/
	394	#ifndef ELF32_FSZ_ADDR
	395	# define ELF32_FSZ_ADDR 4
	396	# define ELF32_FSZ_HALF 2
	397	# define ELF32_FSZ_OFF 4
	398	# define ELF32_FSZ_SWORD 4
	399	# define ELF32_FSZ_WORD 4
	400	#endif /* ELF32_FSZ_ADDR */
	401	#ifndef ELF64_FSZ_ADDR
	402	# define ELF64_FSZ_ADDR 8
	403	# define ELF64_FSZ_HALF 2
	404	# define ELF64_FSZ_OFF 8
	405	# define ELF64_FSZ_SWORD 4
	406	# define ELF64_FSZ_SXWORD 8
	407	# define ELF64_FSZ_WORD 4
	408	# define ELF64_FSZ_XWORD 8
	409	#endif /* ELF64_FSZ_ADDR */
	410
	411	/*
	412	* More missing pieces, in no particular order
	413	*/
	414	#ifndef SHT_SYMTAB_SHNDX
	415	#define SHT_SYMTAB_SHNDX 18
	416	#endif /* SHT_SYMTAB_SHNDX */
	417
	418	#ifndef SHN_XINDEX
	419	#define SHN_XINDEX 0xffff
	420	#endif /* SHN_XINDEX */
	421
	422	#ifndef PN_XNUM
	423	#define PN_XNUM 0xffff
	424	#endif /* PN_XNUM */
	425
	426	/*
	427	* Debugging
	428	*/
	429	#if ENABLE_DEBUG
	430	extern void __elf_assert __P((const char, unsigned, const char));
	431	# if (__STDC__ + 0)
	432	# define elf_assert(x) do{if(!(x))__elf_assert(__FILE__,__LINE__,#x);}while(0)
	433	# else /* __STDC__ */
	434	# define elf_assert(x) do{if(!(x))__elf_assert(__FILE__,__LINE__,"x");}while(0)
	435	# endif /* __STDC__ */
	436	#else /* ENABLE_DEBUG */
	437	# define elf_assert(x) do{}while(0)
	438	#endif /* ENABLE_DEBUG */
	439
	440	/*
	441	* Return values for certain functions
	442	*/
	443	#define LIBELF_SUCCESS 1
	444	#define LIBELF_FAILURE 0
	445
	446	#endif /* _PRIVATE_H */

src/common/genericBinaryFiles/elf/libelfWin32/include/libelf/sys_elf.h created 644 +131 0

@@ -0,0 +1,131
	1	/* lib/sys_elf.h. Generated automatically by configure. */
	2	/*
	3	sys_elf.h.in - configure template for private "switch" file.
	4	Copyright (C) 1998 - 2001 Michael Riepe
	5
	6	This library is free software; you can redistribute it and/or
	7	modify it under the terms of the GNU Library General Public
	8	License as published by the Free Software Foundation; either
	9	version 2 of the License, or (at your option) any later version.
	10
	11	This library is distributed in the hope that it will be useful,
	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	14	Library General Public License for more details.
	15
	16	You should have received a copy of the GNU Library General Public
	17	License along with this library; if not, write to the Free Software
	18	Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
	19	*/
	20
	21	/* @(#) $Id: sys_elf.h.in,v 1.13 2008/05/23 08:57:07 michael Exp $ */
	22
	23	/*
	24	* DO NOT USE THIS IN APPLICATIONS - #include <libelf.h> INSTEAD!
	25	*/
	26
	27	/* Define to `<elf.h>' or `<sys/elf.h>' if one of them is present */
	28	/* #undef __LIBELF_HEADER_ELF_H */
	29
	30	/* Define if Elf32_Dyn is declared in <link.h> */
	31	/* #undef __LIBELF_NEED_LINK_H */
	32
	33	/* Define if Elf32_Dyn is declared in <sys/link.h> */
	34	/* #undef __LIBELF_NEED_SYS_LINK_H */
	35
	36	/* Define if you want 64-bit support (and your system supports it) */
	37	#define __LIBELF64 1
	38
	39	/* Define if you want 64-bit support, and are running IRIX */
	40	/* #undef __LIBELF64_IRIX */
	41
	42	/* Define if you want 64-bit support, and are running Linux */
	43	/* #undef __LIBELF64_LINUX */
	44
	45	/* Define if you want symbol versioning (and your system supports it) */
	46	#define __LIBELF_SYMBOL_VERSIONS 1
	47
	48	/* Define to a 64-bit signed integer type if one exists */
	49	#define __libelf_i64_t __int64
	50
	51	/* Define to a 64-bit unsigned integer type if one exists */
	52	#define __libelf_u64_t unsigned __int64
	53
	54	/* Define to a 32-bit signed integer type if one exists */
	55	#define __libelf_i32_t int
	56
	57	/* Define to a 32-bit unsigned integer type if one exists */
	58	#define __libelf_u32_t unsigned int
	59
	60	/* Define to a 16-bit signed integer type if one exists */
	61	#define __libelf_i16_t short
	62
	63	/* Define to a 16-bit unsigned integer type if one exists */
	64	#define __libelf_u16_t unsigned short
	65
	66	/*
	67	* Ok, now get the correct instance of elf.h...
	68	*/
	69	#ifdef __LIBELF_HEADER_ELF_H
	70	# include __LIBELF_HEADER_ELF_H
	71	#else /* __LIBELF_HEADER_ELF_H */
	72	# if __LIBELF_INTERNAL__
	73	# include <elf_repl.h>
	74	# else /* __LIBELF_INTERNAL__ */
	75	# include <libelf/elf_repl.h>
	76	# endif /* __LIBELF_INTERNAL__ */
	77	#endif /* __LIBELF_HEADER_ELF_H */
	78
	79	/*
	80	* On some systems, <elf.h> is severely broken. Try to fix it.
	81	*/
	82	#ifdef __LIBELF_HEADER_ELF_H
	83
	84	# ifndef ELF32_FSZ_ADDR
	85	# define ELF32_FSZ_ADDR 4
	86	# define ELF32_FSZ_HALF 2
	87	# define ELF32_FSZ_OFF 4
	88	# define ELF32_FSZ_SWORD 4
	89	# define ELF32_FSZ_WORD 4
	90	# endif /* ELF32_FSZ_ADDR */
	91
	92	# ifndef STN_UNDEF
	93	# define STN_UNDEF 0
	94	# endif /* STN_UNDEF */
	95
	96	# if __LIBELF64
	97
	98	# ifndef ELF64_FSZ_ADDR
	99	# define ELF64_FSZ_ADDR 8
	100	# define ELF64_FSZ_HALF 2
	101	# define ELF64_FSZ_OFF 8
	102	# define ELF64_FSZ_SWORD 4
	103	# define ELF64_FSZ_WORD 4
	104	# define ELF64_FSZ_SXWORD 8
	105	# define ELF64_FSZ_XWORD 8
	106	# endif /* ELF64_FSZ_ADDR */
	107
	108	# ifndef ELF64_ST_BIND
	109	# define ELF64_ST_BIND(i) ((i)>>4)
	110	# define ELF64_ST_TYPE(i) ((i)&0xf)
	111	# define ELF64_ST_INFO(b,t) (((b)<<4)+((t)&0xf))
	112	# endif /* ELF64_ST_BIND */
	113
	114	# ifndef ELF64_R_SYM
	115	# define ELF64_R_SYM(i) ((Elf64_Xword)(i)>>32)
	116	# define ELF64_R_TYPE(i) ((i)&0xffffffffL)
	117	# define ELF64_R_INFO(s,t) (((Elf64_Xword)(s)<<32)+((t)&0xffffffffL))
	118	# endif /* ELF64_R_SYM */
	119
	120	# if __LIBELF64_LINUX
	121	typedef __libelf_u64_t Elf64_Addr;
	122	typedef __libelf_u16_t Elf64_Half;
	123	typedef __libelf_u64_t Elf64_Off;
	124	typedef __libelf_i32_t Elf64_Sword;
	125	typedef __libelf_u32_t Elf64_Word;
	126	typedef __libelf_i64_t Elf64_Sxword;
	127	typedef __libelf_u64_t Elf64_Xword;
	128	# endif /* __LIBELF64_LINUX */
	129
	130	# endif /* __LIBELF64 */
	131	#endif /* __LIBELF_HEADER_ELF_H */

src/common/genericBinaryFiles/elf/libelfWin32/include/libelf/verdef.h created 644 +241 0

@@ -0,0 +1,241
	1	/*
	2	* verdef.h - copy versioning information.
	3	* Copyright (C) 2001 - 2006 Michael Riepe
	4	*
	5	* This library is free software; you can redistribute it and/or
	6	* modify it under the terms of the GNU Library General Public
	7	* License as published by the Free Software Foundation; either
	8	* version 2 of the License, or (at your option) any later version.
	9	*
	10	* This library is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	13	* Library General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU Library General Public
	16	* License along with this library; if not, write to the Free Software
	17	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
	18	*/
	19
	20	#ifndef lint
	21	static const char verdef_h_rcsid[] = "@(#) $Id: verdef.h,v 1.13 2008/05/23 08:15:35 michael Exp $";
	22	#endif /* lint */
	23
	24	#if VER_DEF_CURRENT != 1
	25	#error libelf currently does not support VER_DEF_CURRENT != 1
	26	#endif /* VER_DEF_CURRENT != 1 */
	27
	28	#if TOFILE
	29
	30	static void
	31	__store_verdaux(verdaux_ftype dst, const verdaux_mtype src, unsigned enc) {
	32	if (enc == ELFDATA2LSB) {
	33	__store_u32L(dst->vda_name, src->vda_name);
	34	__store_u32L(dst->vda_next, src->vda_next);
	35	}
	36	else {
	37	__store_u32M(dst->vda_name, src->vda_name);
	38	__store_u32M(dst->vda_next, src->vda_next);
	39	}
	40	}
	41
	42	static void
	43	__store_verdef(verdef_ftype dst, const verdef_mtype src, unsigned enc) {
	44	if (enc == ELFDATA2LSB) {
	45	__store_u16L(dst->vd_version, src->vd_version);
	46	__store_u16L(dst->vd_flags, src->vd_flags);
	47	__store_u16L(dst->vd_ndx, src->vd_ndx);
	48	__store_u16L(dst->vd_cnt, src->vd_cnt);
	49	__store_u32L(dst->vd_hash, src->vd_hash);
	50	__store_u32L(dst->vd_aux, src->vd_aux);
	51	__store_u32L(dst->vd_next, src->vd_next);
	52	}
	53	else {
	54	__store_u16M(dst->vd_version, src->vd_version);
	55	__store_u16M(dst->vd_flags, src->vd_flags);
	56	__store_u16M(dst->vd_ndx, src->vd_ndx);
	57	__store_u16M(dst->vd_cnt, src->vd_cnt);
	58	__store_u32M(dst->vd_hash, src->vd_hash);
	59	__store_u32M(dst->vd_aux, src->vd_aux);
	60	__store_u32M(dst->vd_next, src->vd_next);
	61	}
	62	}
	63
	64	typedef verdaux_mtype verdaux_stype;
	65	typedef verdaux_ftype verdaux_dtype;
	66	typedef verdef_mtype verdef_stype;
	67	typedef verdef_ftype verdef_dtype;
	68	typedef align_mtype verdef_atype;
	69
	70	#define copy_verdaux_srctotmp(d, s, e) ((d) = (s))
	71	#define copy_verdaux_tmptodst(d, s, e) __store_verdaux((d), (s), (e))
	72	#define copy_verdef_srctotmp(d, s, e) ((d) = (s))
	73	#define copy_verdef_tmptodst(d, s, e) __store_verdef((d), (s), (e))
	74
	75	#define translator_suffix _tof
	76
	77	#else /* TOFILE */
	78
	79	static void
	80	__load_verdaux(verdaux_mtype dst, const verdaux_ftype src, unsigned enc) {
	81	if (enc == ELFDATA2LSB) {
	82	dst->vda_name = __load_u32L(src->vda_name);
	83	dst->vda_next = __load_u32L(src->vda_next);
	84	}
	85	else {
	86	dst->vda_name = __load_u32M(src->vda_name);
	87	dst->vda_next = __load_u32M(src->vda_next);
	88	}
	89	}
	90
	91	static void
	92	__load_verdef(verdef_mtype dst, const verdef_ftype src, unsigned enc) {
	93	if (enc == ELFDATA2LSB) {
	94	dst->vd_version = __load_u16L(src->vd_version);
	95	dst->vd_flags = __load_u16L(src->vd_flags);
	96	dst->vd_ndx = __load_u16L(src->vd_ndx);
	97	dst->vd_cnt = __load_u16L(src->vd_cnt);
	98	dst->vd_hash = __load_u32L(src->vd_hash);
	99	dst->vd_aux = __load_u32L(src->vd_aux);
	100	dst->vd_next = __load_u32L(src->vd_next);
	101	}
	102	else {
	103	dst->vd_version = __load_u16M(src->vd_version);
	104	dst->vd_flags = __load_u16M(src->vd_flags);
	105	dst->vd_ndx = __load_u16M(src->vd_ndx);
	106	dst->vd_cnt = __load_u16M(src->vd_cnt);
	107	dst->vd_hash = __load_u32M(src->vd_hash);
	108	dst->vd_aux = __load_u32M(src->vd_aux);
	109	dst->vd_next = __load_u32M(src->vd_next);
	110	}
	111	}
	112
	113	typedef verdaux_ftype verdaux_stype;
	114	typedef verdaux_mtype verdaux_dtype;
	115	typedef verdef_ftype verdef_stype;
	116	typedef verdef_mtype verdef_dtype;
	117	typedef align_ftype verdef_atype;
	118
	119	#define copy_verdaux_srctotmp(d, s, e) __load_verdaux((d), (s), (e))
	120	#define copy_verdaux_tmptodst(d, s, e) ((d) = (s))
	121	#define copy_verdef_srctotmp(d, s, e) __load_verdef((d), (s), (e))
	122	#define copy_verdef_tmptodst(d, s, e) ((d) = (s))
	123
	124	#define translator_suffix _tom
	125
	126	#endif /* TOFILE */
	127
	128	#define cat3(a,b,c) a##b##c
	129	#define xlt3(p,e,s) cat3(p,e,s)
	130	#define xltprefix(x) xlt3(x,_,class_suffix)
	131	#define translator(x,e) xlt3(xltprefix(_elf_##x),e,translator_suffix)
	132
	133	static size_t
	134	xlt_verdef(unsigned char dst, const unsigned char src, size_t n, unsigned enc) {
	135	size_t off;
	136
	137	if (sizeof(verdef_stype) != sizeof(verdef_dtype)
	138	\|\| sizeof(verdaux_stype) != sizeof(verdaux_dtype)) {
	139	/* never happens for ELF v1 and Verneed v1 */
	140	seterr(ERROR_UNIMPLEMENTED);
	141	return (size_t)-1;
	142	}
	143	/* size translation shortcut */
	144	if (dst == NULL) {
	145	return n;
	146	}
	147	if (src == NULL) {
	148	seterr(ERROR_NULLBUF);
	149	return (size_t)-1;
	150	}
	151	off = 0;
	152	while (off + sizeof(verdef_stype) <= n) {
	153	const verdef_stype *svd;
	154	verdef_dtype *dvd;
	155	verdef_mtype vd;
	156	size_t acount;
	157	size_t aoff;
	158
	159	/*
	160	* check for proper alignment
	161	*/
	162	if (off % sizeof(verdef_atype)) {
	163	seterr(ERROR_VERDEF_FORMAT);
	164	return (size_t)-1;
	165	}
	166	/*
	167	* copy and check src
	168	*/
	169	svd = (verdef_stype*)(src + off);
	170	dvd = (verdef_dtype*)(dst + off);
	171	copy_verdef_srctotmp(&vd, svd, enc);
	172	if (vd.vd_version < 1
	173	\|\| vd.vd_version > VER_DEF_CURRENT) {
	174	seterr(ERROR_VERDEF_VERSION);
	175	return (size_t)-1;
	176	}
	177	if (vd.vd_cnt < 1
	178	\|\| vd.vd_aux == 0) {
	179	seterr(ERROR_VERDEF_FORMAT);
	180	return (size_t)-1;
	181	}
	182	copy_verdef_tmptodst(dvd, &vd, enc);
	183	/*
	184	* copy aux array
	185	*/
	186	aoff = off + vd.vd_aux;
	187	for (acount = 0; acount < vd.vd_cnt; acount++) {
	188	const verdaux_stype *svda;
	189	verdaux_dtype *dvda;
	190	verdaux_mtype vda;
	191
	192	/*
	193	* are we still inside the buffer limits?
	194	*/
	195	if (aoff + sizeof(verdaux_stype) > n) {
	196	break;
	197	}
	198	/*
	199	* check for proper alignment
	200	*/
	201	if (aoff % sizeof(verdef_atype)) {
	202	seterr(ERROR_VERDEF_FORMAT);
	203	return (size_t)-1;
	204	}
	205	/*
	206	* copy and check src
	207	*/
	208	svda = (verdaux_stype*)(src + aoff);
	209	dvda = (verdaux_dtype*)(dst + aoff);
	210	copy_verdaux_srctotmp(&vda, svda, enc);
	211	copy_verdaux_tmptodst(dvda, &vda, enc);
	212	/*
	213	* advance to next verdaux
	214	*/
	215	if (vda.vda_next == 0) {
	216	/* end of list */
	217	break;
	218	}
	219	aoff += vda.vda_next;
	220	}
	221	/*
	222	* advance to next verdef
	223	*/
	224	if (vd.vd_next == 0) {
	225	/* end of list */
	226	break;
	227	}
	228	off += vd.vd_next;
	229	}
	230	return n;
	231	}
	232
	233	size_t
	234	translator(verdef,L11)(unsigned char dst, const unsigned char src, size_t n) {
	235	return xlt_verdef(dst, src, n, ELFDATA2LSB);
	236	}
	237
	238	size_t
	239	translator(verdef,M11)(unsigned char dst, const unsigned char src, size_t n) {
	240	return xlt_verdef(dst, src, n, ELFDATA2MSB);
	241	}

src/common/genericBinaryFiles/elf/libelfWin32/include/libelf/verneed.h created 644 +245 0

@@ -0,0 +1,245
	1	/*
	2	* verneed.h - copy versioning information.
	3	* Copyright (C) 2001 - 2006 Michael Riepe
	4	*
	5	* This library is free software; you can redistribute it and/or
	6	* modify it under the terms of the GNU Library General Public
	7	* License as published by the Free Software Foundation; either
	8	* version 2 of the License, or (at your option) any later version.
	9	*
	10	* This library is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	13	* Library General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU Library General Public
	16	* License along with this library; if not, write to the Free Software
	17	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
	18	*/
	19
	20	#ifndef lint
	21	static const char verneed_h_rcsid[] = "@(#) $Id: verneed.h,v 1.13 2008/05/23 08:15:35 michael Exp $";
	22	#endif /* lint */
	23
	24	#if VER_NEED_CURRENT != 1
	25	#error libelf currently does not support VER_NEED_CURRENT != 1
	26	#endif /* VER_NEED_CURRENT != 1 */
	27
	28	#if TOFILE
	29
	30	static void
	31	__store_vernaux(vernaux_ftype dst, const vernaux_mtype src, unsigned enc) {
	32	if (enc == ELFDATA2LSB) {
	33	__store_u32L(dst->vna_hash, src->vna_hash);
	34	__store_u16L(dst->vna_flags, src->vna_flags);
	35	__store_u16L(dst->vna_other, src->vna_other);
	36	__store_u32L(dst->vna_name, src->vna_name);
	37	__store_u32L(dst->vna_next, src->vna_next);
	38	}
	39	else {
	40	__store_u32M(dst->vna_hash, src->vna_hash);
	41	__store_u16M(dst->vna_flags, src->vna_flags);
	42	__store_u16M(dst->vna_other, src->vna_other);
	43	__store_u32M(dst->vna_name, src->vna_name);
	44	__store_u32M(dst->vna_next, src->vna_next);
	45	}
	46	}
	47
	48	static void
	49	__store_verneed(verneed_ftype dst, const verneed_mtype src, unsigned enc) {
	50	if (enc == ELFDATA2LSB) {
	51	__store_u16L(dst->vn_version, src->vn_version);
	52	__store_u16L(dst->vn_cnt, src->vn_cnt);
	53	__store_u32L(dst->vn_file, src->vn_file);
	54	__store_u32L(dst->vn_aux, src->vn_aux);
	55	__store_u32L(dst->vn_next, src->vn_next);
	56	}
	57	else {
	58	__store_u16M(dst->vn_version, src->vn_version);
	59	__store_u16M(dst->vn_cnt, src->vn_cnt);
	60	__store_u32M(dst->vn_file, src->vn_file);
	61	__store_u32M(dst->vn_aux, src->vn_aux);
	62	__store_u32M(dst->vn_next, src->vn_next);
	63	}
	64	}
	65
	66	typedef vernaux_mtype vernaux_stype;
	67	typedef vernaux_ftype vernaux_dtype;
	68	typedef verneed_mtype verneed_stype;
	69	typedef verneed_ftype verneed_dtype;
	70	typedef align_mtype verneed_atype;
	71
	72	#define copy_vernaux_srctotmp(d, s, e) ((d) = (s))
	73	#define copy_vernaux_tmptodst(d, s, e) __store_vernaux((d), (s), (e))
	74	#define copy_verneed_srctotmp(d, s, e) ((d) = (s))
	75	#define copy_verneed_tmptodst(d, s, e) __store_verneed((d), (s), (e))
	76
	77	#define translator_suffix _tof
	78
	79	#else /* TOFILE */
	80
	81	static void
	82	__load_vernaux(vernaux_mtype dst, const vernaux_ftype src, unsigned enc) {
	83	if (enc == ELFDATA2LSB) {
	84	dst->vna_hash = __load_u32L(src->vna_hash);
	85	dst->vna_flags = __load_u16L(src->vna_flags);
	86	dst->vna_other = __load_u16L(src->vna_other);
	87	dst->vna_name = __load_u32L(src->vna_name);
	88	dst->vna_next = __load_u32L(src->vna_next);
	89	}
	90	else {
	91	dst->vna_hash = __load_u32M(src->vna_hash);
	92	dst->vna_flags = __load_u16M(src->vna_flags);
	93	dst->vna_other = __load_u16M(src->vna_other);
	94	dst->vna_name = __load_u32M(src->vna_name);
	95	dst->vna_next = __load_u32M(src->vna_next);
	96	}
	97	}
	98
	99	static void
	100	__load_verneed(verneed_mtype dst, const verneed_ftype src, unsigned enc) {
	101	if (enc == ELFDATA2LSB) {
	102	dst->vn_version = __load_u16L(src->vn_version);
	103	dst->vn_cnt = __load_u16L(src->vn_cnt);
	104	dst->vn_file = __load_u32L(src->vn_file);
	105	dst->vn_aux = __load_u32L(src->vn_aux);
	106	dst->vn_next = __load_u32L(src->vn_next);
	107	}
	108	else {
	109	dst->vn_version = __load_u16M(src->vn_version);
	110	dst->vn_cnt = __load_u16M(src->vn_cnt);
	111	dst->vn_file = __load_u32M(src->vn_file);
	112	dst->vn_aux = __load_u32M(src->vn_aux);
	113	dst->vn_next = __load_u32M(src->vn_next);
	114	}
	115	}
	116
	117	typedef vernaux_ftype vernaux_stype;
	118	typedef vernaux_mtype vernaux_dtype;
	119	typedef verneed_ftype verneed_stype;
	120	typedef verneed_mtype verneed_dtype;
	121	typedef align_ftype verneed_atype;
	122
	123	#define copy_vernaux_srctotmp(d, s, e) __load_vernaux((d), (s), (e))
	124	#define copy_vernaux_tmptodst(d, s, e) ((d) = (s))
	125	#define copy_verneed_srctotmp(d, s, e) __load_verneed((d), (s), (e))
	126	#define copy_verneed_tmptodst(d, s, e) ((d) = (s))
	127
	128	#define translator_suffix _tom
	129
	130	#endif /* TOFILE */
	131
	132	#define cat3(a,b,c) a##b##c
	133	#define xlt3(p,e,s) cat3(p,e,s)
	134	#define xltprefix(x) xlt3(x,_,class_suffix)
	135	#define translator(x,e) xlt3(xltprefix(_elf_##x),e,translator_suffix)
	136
	137	static size_t
	138	xlt_verneed(unsigned char dst, const unsigned char src, size_t n, unsigned enc) {
	139	size_t off;
	140
	141	if (sizeof(verneed_stype) != sizeof(verneed_dtype)
	142	\|\| sizeof(vernaux_stype) != sizeof(vernaux_dtype)) {
	143	/* never happens for ELF v1 and Verneed v1 */
	144	seterr(ERROR_UNIMPLEMENTED);
	145	return (size_t)-1;
	146	}
	147	/* size translation shortcut */
	148	if (dst == NULL) {
	149	return n;
	150	}
	151	if (src == NULL) {
	152	seterr(ERROR_NULLBUF);
	153	return (size_t)-1;
	154	}
	155	off = 0;
	156	while (off + sizeof(verneed_stype) <= n) {
	157	const verneed_stype *svn;
	158	verneed_dtype *dvn;
	159	verneed_mtype vn;
	160	size_t acount;
	161	size_t aoff;
	162
	163	/*
	164	* check for proper alignment
	165	*/
	166	if (off % sizeof(verneed_atype)) {
	167	seterr(ERROR_VERNEED_FORMAT);
	168	return (size_t)-1;
	169	}
	170	/*
	171	* copy and check src
	172	*/
	173	svn = (verneed_stype*)(src + off);
	174	dvn = (verneed_dtype*)(dst + off);
	175	copy_verneed_srctotmp(&vn, svn, enc);
	176	if (vn.vn_version < 1
	177	\|\| vn.vn_version > VER_NEED_CURRENT) {
	178	seterr(ERROR_VERNEED_VERSION);
	179	return (size_t)-1;
	180	}
	181	if (vn.vn_cnt < 1
	182	\|\| vn.vn_aux == 0) {
	183	seterr(ERROR_VERNEED_FORMAT);
	184	return (size_t)-1;
	185	}
	186	copy_verneed_tmptodst(dvn, &vn, enc);
	187	/*
	188	* copy aux array
	189	*/
	190	aoff = off + vn.vn_aux;
	191	for (acount = 0; acount < vn.vn_cnt; acount++) {
	192	const vernaux_stype *svna;
	193	vernaux_dtype *dvna;
	194	vernaux_mtype vna;
	195
	196	/*
	197	* are we still inside the buffer limits?
	198	*/
	199	if (aoff + sizeof(vernaux_stype) > n) {
	200	break;
	201	}
	202	/*
	203	* check for proper alignment
	204	*/
	205	if (aoff % sizeof(verneed_atype)) {
	206	seterr(ERROR_VERNEED_FORMAT);
	207	return (size_t)-1;
	208	}
	209	/*
	210	* copy and check src
	211	*/
	212	svna = (vernaux_stype*)(src + aoff);
	213	dvna = (vernaux_dtype*)(dst + aoff);
	214	copy_vernaux_srctotmp(&vna, svna, enc);
	215	copy_vernaux_tmptodst(dvna, &vna, enc);
	216	/*
	217	* advance to next vernaux
	218	*/
	219	if (vna.vna_next == 0) {
	220	/* end of list */
	221	break;
	222	}
	223	aoff += vna.vna_next;
	224	}
	225	/*
	226	* advance to next verneed
	227	*/
	228	if (vn.vn_next == 0) {
	229	/* end of list */
	230	break;
	231	}
	232	off += vn.vn_next;
	233	}
	234	return n;
	235	}
	236
	237	size_t
	238	translator(verneed,L11)(unsigned char dst, const unsigned char src, size_t n) {
	239	return xlt_verneed(dst, src, n, ELFDATA2LSB);
	240	}
	241
	242	size_t
	243	translator(verneed,M11)(unsigned char dst, const unsigned char src, size_t n) {
	244	return xlt_verneed(dst, src, n, ELFDATA2MSB);
	245	}

src/common/genericBinaryFiles/srec/srecfile.cpp created 644 +403 0

@@ -0,0 +1,403
	1	/*------------------------------------------------------------------------------
	2	-- This file is a part of the SocExplorer Software
	3	-- Copyright (C) 2014, Plasma Physics Laboratory - CNRS
	4	--
	5	-- This program is free software; you can redistribute it and/or modify
	6	-- it under the terms of the GNU General Public License as published by
	7	-- the Free Software Foundation; either version 2 of the License, or
	8	-- (at your option) any later version.
	9	--
	10	-- This program is distributed in the hope that it will be useful,
	11	-- but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	-- GNU General Public License for more details.
	14	--
	15	-- You should have received a copy of the GNU General Public License
	16	-- along with this program; if not, write to the Free Software
	17	-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	18	-------------------------------------------------------------------------------*/
	19	/*-- Author : Alexis Jeandet
	20	-- Mail : alexis.jeandet@member.fsf.org
	21	----------------------------------------------------------------------------*/
	22	#include "srecfile.h"
	23	#include <QTextStream>
	24	#include "binaryfile.h"
	25
	26	srecFile::srecFile()
	27	{
	28	}
	29
	30	srecFile::srecFile(const QString &File)
	31	{
	32	openFile(File);
	33	}
	34
	35	srecFile::srecFile(const QStringList &Files)
	36	{
	37	openFiles(Files);
	38	}
	39
	40	srecFile::~srecFile()
	41	{
	42
	43	}
	44
	45	bool srecFile::openFile(const QString &File)
	46	{
	47	return openFiles(QStringList()<<File);
	48	}
	49
	50	bool srecFile::openFiles(const QStringList &Files)
	51	{
	52	for(int i=0;i<Files.count();i++)
	53	{
	54	this->p_isSrec=true;
	55	this->p_isSrec &= isSREC(Files.at(i));
	56	this->p_files.append(new QFile(Files.at(i)));
	57	this->p_files.at(i)->open(QIODevice::ReadOnly);
	58	parseFile(this->p_files.at(i));
	59	}
	60	return true;
	61	}
	62
	63	bool srecFile::isopened()
	64	{
	65	bool opened = true;
	66	for(int i=0;i<this->p_files.count();i++)
	67	{
	68	opened &= p_files.at(i)->isOpen();
	69	}
	70	return opened;
	71	}
	72
	73	int srecFile::closeFile()
	74	{
	75	for(int i=0;i<p_files.count();i++)
	76	{
	77	delete p_files.at(i);
	78	delete p_fragments.at(i);
	79	}
	80	p_fragments.clear();
	81	p_files.clear();
	82	p_fileName.clear();
	83	return 0;
	84	}
	85
	86	QList<codeFragment *> srecFile::getFragments()
	87	{
	88	return p_fragments;
	89	}
	90
	91	bool srecFile::toSrec(QList<codeFragment *> fragments, const QString &File)
	92	{
	93	QString line;
	94	QFile file(File);
	95	file.open(QIODevice::WriteOnly);
	96	if(file.isOpen())
	97	{
	98	QTextStream stream( &file );
	99	//First build header
	100	stream << buildRecord(0,0,File.toStdString().c_str(),File.count());
	101	for(int i=0;i<fragments.count();i++)
	102	{
	103	codeFragment *fragment = fragments.at(i);
	104	for(int j=0;j<((int)(fragment->size));j+=16)
	105	{
	106	stream << buildRecord(3,fragment->address+j,fragment->data+j,16);
	107	}
	108	int rem = fragment->size % 16;
	109	if(rem)
	110	{
	111	stream << buildRecord(3,fragment->address+fragment->size-rem,fragment->data+fragment->size-rem,rem);
	112	}
	113	stream << buildRecord(7,fragment->address,NULL,0);
	114	}
	115	file.close();
	116	return true;
	117	}
	118
	119	return false;
	120	}
	121
	122	bool srecFile::toSrec(const QString &File)
	123	{
	124	return toSrec(p_fragments,File);
	125	}
	126
	127	bool srecFile::toBinary(const QString &File)
	128	{
	129	return binaryFile::toBinary(p_fragments,File);
	130	}
	131
	132	int srecFile::lineCount()
	133	{
	134	return p_lineCount;
	135	}
	136
	137	int srecFile::getFragmentsCount()
	138	{
	139	return p_fragments.count();
	140	}
	141
	142	int srecFile::getFragmentAddress(int index)
	143	{
	144	if((index < p_fragments.count()) && (index>=0))
	145	{
	146	return p_fragments.at(index)->address;
	147	}
	148	return 0;
	149	}
	150
	151	int srecFile::getFragmentSize(int index)
	152	{
	153	if((index < p_fragments.count()) && (index>=0))
	154	{
	155	return p_fragments.at(index)->size;
	156	}
	157	return 0;
	158	}
	159
	160	codeFragment *srecFile::getFragment(int index)
	161	{
	162	if((index < p_fragments.count()) && (index>=0))
	163	{
	164	return p_fragments.at(index);
	165	}
	166	return NULL;
	167	}
	168
	169	QString srecFile::getFragmentHeader(int index)
	170	{
	171	if((index < p_fragments.count()) && (index>=0))
	172	{
	173	return p_fragments.at(index)->header;
	174	}
	175	return "";
	176	}
	177
	178	bool srecFile::getFragmentData(int index, char **buffer)
	179	{
	180
	181	if((index < p_fragments.count()) && (index>=0))
	182	{
	183	buffer = (char )this->p_fragments.at(index)->data;
	184	return true;
	185	}
	186	return false;
	187	}
	188
	189	bool srecFile::isSREC()
	190	{
	191	return p_isSrec & isopened();
	192	}
	193
	194	bool srecFile::isSREC(const QString &File)
	195	{
	196	QFile file(File);
	197	file.open(QIODevice::ReadOnly);
	198	if(file.isOpen())
	199	{
	200	file.seek(0);
	201	QString line=file.readLine();
	202	file.close();
	203	return ((line.at(0)=='S')&&(line.at(1)=='0'));
	204	}
	205	return false;
	206	}
	207
	208	void srecFile::parseFile(QFile *file)
	209	{
	210	if(file->isOpen())
	211	{
	212	this->p_lineCount = 0;
	213	file->seek(0);
	214	codeFragment* fragment=NULL;
	215	char* data;
	216	quint64 size=0;
	217	quint64 address=-1;
	218	QString header;
	219	while (!file->atEnd())
	220	{
	221	QString line = file->readLine();
	222	p_lineCount++;
	223	int rectype = parseLine(line,&address,&data,&size);
	224	if(rectype==0)
	225	{
	226	header.clear();
	227	header.append(data);
	228	fragment = new codeFragment(data,size,address);
	229	fragment->header = header;
	230	p_fragments.append(fragment);
	231	}
	232	else
	233	{
	234	if((rectype>=1) && (rectype<=3))
	235	{
	236	bool merged = false;
	237	//Could I merge it with an other fragment?
	238	// TODO should make merging optionnal
	239	for(int i=0;i<p_fragments.count();i++)
	240	{
	241	codeFragment* frag = p_fragments.at(i);
	242	if(((frag->address+frag->size)==address) && (merged==false) && (size!=0))
	243	{
	244	char* mergedData=(char*)malloc(size+frag->size);
	245	memcpy(mergedData,frag->data,frag->size);
	246	memcpy(mergedData+frag->size,data,size);
	247	free(frag->data);
	248	free(data);
	249	frag->data = mergedData;
	250	frag->size = frag->size+size;
	251	merged = true;
	252	}
	253	}
	254	if(!merged)
	255	{
	256	fragment = new codeFragment(data,size,address);
	257	fragment->header = header;
	258	p_fragments.append(fragment);
	259	}
	260	}
	261	else
	262	{
	263
	264	}
	265	}
	266	}
	267	}
	268	}
	269
	270	int srecFile::parseLine(const QString &record, quint64 address, char data, quint64 size)
	271	{
	272	#define newData (*data)
	273	#define newAddress (*address)
	274	#define newSize (*size)
	275	int recType = -1;
	276	if((record.count()>4) && checkSum(record))
	277	{
	278	if(record.at(0)=='S')
	279	{
	280	recType = record.at(1).toLatin1() & 0x0F;
	281	//Header type
	282	if(recType==0)
	283	{
	284	newAddress = record.mid(4,4).toInt(0,16);
	285	newSize = record.mid(2,2).toInt(0,16) - 3;
	286	if(newSize>0)
	287	{
	288	newData=(char*)malloc(newSize+1);
	289	for(int i=0;i<(int)newSize;i++)
	290	{
	291	newData[i] = ((char)record.mid((2*i)+8,2).toInt(0,16));
	292	}
	293	newData[newSize] = '\0'; // force string end for header
	294	}
	295	}
	296	//2 address byte record type
	297	if((recType==1) \|\| (recType==5) \|\| (recType==9))
	298	{
	299	newAddress = record.mid(4,4).toInt(0,16);
	300	newSize = record.mid(2,2).toInt(0,16) - 3;
	301	if(newSize>0)
	302	{
	303	newData=(char*)malloc(newSize);
	304	for(int i=0;i<(int)newSize;i++)
	305	{
	306	newData[i] = ((char)record.mid((2*i)+8,2).toInt(0,16));
	307	}
	308	}
	309	}
	310	//3 address byte record type
	311	if((recType==2) \|\| (recType==6) \|\| (recType==8))
	312	{
	313	newAddress = record.mid(4,6).toInt(0,16);
	314	newSize = record.mid(2,2).toInt(0,16) - 4;
	315	if(newSize>0)
	316	{
	317	newData=(char*)malloc(newSize);
	318	for(int i=0;i<(int)newSize;i++)
	319	{
	320	newData[i] = ((char)record.mid((2*i)+10,2).toInt(0,16));
	321	}
	322	}
	323	}
	324	//4 address byte record type
	325	if((recType==3) \|\| (recType==7))
	326	{
	327	newAddress = record.mid(4,8).toInt(0,16);
	328	newSize = record.mid(2,2).toInt(0,16) - 5;
	329	if(newSize>0)
	330	{
	331	newData=(char*)malloc(newSize);
	332	for(int i=0;i<(int)newSize;i++)
	333	{
	334	newData[i] = ((char)record.mid((2*i)+12,2).toInt(0,16));
	335	}
	336	}
	337	}
	338	}
	339	}
	340	return recType;
	341	}
	342
	343	char srecFile::lineCheckSum(const QString &line)
	344	{
	345	char sum=0;
	346	QString localLine = line;
	347	bool ok;
	348	if(localLine.at(0)=='S') // then should skip the first two digits
	349	{
	350	localLine.remove(0,2);
	351	}
	352	for(int i=0;i<localLine.count();i+=2)
	353	{
	354	sum+=(char)(localLine.mid(i,2).toInt(&ok,16));
	355	}
	356	return ~sum;
	357	}
	358
	359	bool srecFile::checkSum(const QString &line)
	360	{
	361	QString scp=line;
	362	scp.remove('\n');
	363	scp.remove('\r');
	364	char ck2 = (char)scp.mid(scp.count()-2,2).toInt(0,16);
	365	char ck=lineCheckSum(scp.remove(scp.count()-2,2));
	366	return (ck2==ck);
	367	}
	368
	369	QString srecFile::buildRecord(int recType, int address,const char *data, int size)
	370	{
	371	QString record;
	372	if((recType>=0) && (recType<=9))
	373	{
	374	record.append("S");
	375	record.append(QString::number(recType));
	376	//2 address byte record type
	377	if((recType==0) \|\| (recType==1) \|\| (recType==5) \|\| (recType==9))
	378	{
	379	record.append(QString("%1").arg(3+size,2,16).replace(' ','0'));
	380	record.append(QString("%1").arg(address,4,16).replace(' ','0'));
	381	}
	382	//3 address byte record type
	383	if((recType==2) \|\| (recType==6) \|\| (recType==8))
	384	{
	385	record.append(QString("%1").arg(4+size,2,16).replace(' ','0'));
	386	record.append(QString("%1").arg(address,6,16).replace(' ','0'));
	387	}
	388	//4 address byte record type
	389	if((recType==3) \|\| (recType==7))
	390	{
	391	record.append(QString("%1").arg(5+size,2,16).replace(' ','0'));
	392	record.append(QString("%1").arg(address,8,16).replace(' ','0'));
	393	}
	394	for(int i=0; i<size;i++)
	395	{
	396	record.append(QString("%1").arg((uchar)data[i],2,16).replace(' ','0'));
	397	}
	398	record.append(QString("%1").arg((uchar)srecFile::lineCheckSum(record),2,16).replace(' ','0'));
	399	record.append('\n');
	400	}
	401	return record.toUpper();
	402	}
	403

src/common/genericBinaryFiles/srec/srecfile.h created 644 +73 0

@@ -0,0 +1,73
	1	/*------------------------------------------------------------------------------
	2	-- This file is a part of the SocExplorer Software
	3	-- Copyright (C) 2014, Plasma Physics Laboratory - CNRS
	4	--
	5	-- This program is free software; you can redistribute it and/or modify
	6	-- it under the terms of the GNU General Public License as published by
	7	-- the Free Software Foundation; either version 2 of the License, or
	8	-- (at your option) any later version.
	9	--
	10	-- This program is distributed in the hope that it will be useful,
	11	-- but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	-- GNU General Public License for more details.
	14	--
	15	-- You should have received a copy of the GNU General Public License
	16	-- along with this program; if not, write to the Free Software
	17	-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	18	-------------------------------------------------------------------------------*/
	19	/*-- Author : Alexis Jeandet
	20	-- Mail : alexis.jeandet@member.fsf.org
	21	----------------------------------------------------------------------------*/
	22	#ifndef SRECFILE_H
	23	#define SRECFILE_H
	24
	25	#include <QObject>
	26	#include <abstractbinfile.h>
	27	#include <QFile>
	28	#include <QStringList>
	29
	30	class srecFile : public abstractBinFile
	31	{
	32	Q_OBJECT
	33	public:
	34	explicit srecFile();
	35	srecFile(const QString& File);
	36	srecFile(const QStringList& Files);
	37	~srecFile();
	38	bool openFile(const QString& File);
	39	bool openFiles(const QStringList& Files);
	40	bool isopened();
	41	int closeFile();
	42	QList<codeFragment*> getFragments();
	43	static bool toSrec(QList<codeFragment*> fragments,const QString& File);
	44	bool toSrec(const QString &File);
	45	bool toBinary(const QString& File);
	46	int lineCount();
	47	int getFragmentsCount();
	48	int getFragmentAddress(int index);
	49	int getFragmentSize(int index);
	50	codeFragment *getFragment(int index);
	51	QString getFragmentHeader(int index);
	52	bool getFragmentData(int index, char **buffer);
	53
	54	bool isSREC();
	55	static bool isSREC(const QString& File);
	56	signals:
	57
	58	public slots:
	59	private:
	60	void parseFile(QFile* file);
	61	static int parseLine(const QString& record, quint64 address, char* data, quint64 *size);
	62	static char lineCheckSum(const QString& line);
	63	static bool checkSum(const QString& line);
	64	static QString buildRecord(int recType,int address,const char* data,int size);
	65	QStringList p_fileNames;
	66	QList<QFile*>p_files;
	67	QList<codeFragment*> p_fragments;
	68	int p_lineCount;
	69	bool p_isSrec;
	70
	71	};
	72
	73	#endif // SRECFILE_H

src/common/genericBinaryFiles/srec/srecfilewidget.cpp created 644 +144 0

@@ -0,0 +1,144
	1	/*------------------------------------------------------------------------------
	2	-- This file is a part of the SocExplorer Software
	3	-- Copyright (C) 2014, Plasma Physics Laboratory - CNRS
	4	--
	5	-- This program is free software; you can redistribute it and/or modify
	6	-- it under the terms of the GNU General Public License as published by
	7	-- the Free Software Foundation; either version 2 of the License, or
	8	-- (at your option) any later version.
	9	--
	10	-- This program is distributed in the hope that it will be useful,
	11	-- but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	-- GNU General Public License for more details.
	14	--
	15	-- You should have received a copy of the GNU General Public License
	16	-- along with this program; if not, write to the Free Software
	17	-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	18	-------------------------------------------------------------------------------*/
	19	/*-- Author : Alexis Jeandet
	20	-- Mail : alexis.jeandet@member.fsf.org
	21	----------------------------------------------------------------------------*/
	22	#include "srecfilewidget.h"
	23	#include "ui_srecfilewidget.h"
	24	#include <QTableWidgetItem>
	25	#include <qtablewidgetintitem.h>
	26	#include <QtWidgets/QFileDialog>
	27	#include "binaryfile.h"
	28
	29	srecFileWidget::srecFileWidget(QWidget *parent) :
	30	abstractBinFileWidget(parent),
	31	ui(new Ui::srecFileWidget)
	32	{
	33	ui->setupUi(this);
	34	connect(this->ui->fragmentsList,SIGNAL(cellActivated(int,int)),this,SLOT(recordCellActivated(int,int)));
	35	this->setWindowTitle("SocExplorer SREC viewer");
	36	exportToSREC_action = new QAction(tr("Export to SREC"),this);
	37	exportToBIN_action = new QAction(tr("Export to Binary"),this);
	38	this->ui->fragmentsList->addAction(exportToBIN_action);
	39	this->ui->fragmentsList->addAction(exportToSREC_action);
	40	connect(this->exportToBIN_action,SIGNAL(triggered()),this,SLOT(exportToBIN()));
	41	connect(this->exportToSREC_action,SIGNAL(triggered()),this,SLOT(exportToSREC()));
	42	}
	43
	44	srecFileWidget::~srecFileWidget()
	45	{
	46	delete ui;
	47	}
	48
	49	void srecFileWidget::setFile(abstractBinFile *file)
	50	{
	51	this->p_srec = (srecFile*)file;
	52	if(p_srec->isopened() && p_srec->isSREC())
	53	{
	54	reloadFile();
	55	}
	56	}
	57
	58	void srecFileWidget::reloadFile()
	59	{
	60	this->ui->fragmentsList->clear();
	61	this->ui->fragmentsList->setRowCount(p_srec->getFragmentsCount());
	62	this->ui->fragmentsList->setHorizontalHeaderLabels(QStringList()<<"Index"<<"Address"<<"Size"<<"Header");
	63	for(int i=0;i<p_srec->getFragmentsCount();i++)
	64	{
	65	QTableWidgetItem newItem = (QTableWidgetItem)new QTableWidgetIntItem(QString("%1").arg(i),DecimalItem);
	66	newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
	67	this->ui->fragmentsList->setItem(i, 0, newItem);
	68
	69	newItem = (QTableWidgetItem*)new QTableWidgetIntItem(QString("0x%1").arg(p_srec->getFragmentAddress(i),8,16).replace(" ","0"),HexaDecimalItem);
	70	newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
	71	this->ui->fragmentsList->setItem(i, 1, newItem);
	72
	73	newItem = (QTableWidgetItem*)new QTableWidgetIntItem(QString("%1").arg(p_srec->getFragmentSize(i)),DecimalItem);
	74	newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
	75	this->ui->fragmentsList->setItem(i, 2, newItem);
	76
	77	newItem = new QTableWidgetItem(p_srec->getFragmentHeader(i));
	78	newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
	79	this->ui->fragmentsList->setItem(i, 3, newItem);
	80
	81	}
	82	this->ui->fragmentsList->resizeColumnsToContents();
	83	}
	84
	85	void srecFileWidget::recordCellActivated(int row, int column)
	86	{
	87	Q_UNUSED(column)
	88	char* buff=NULL;
	89	int index = this->ui->fragmentsList->item(row,0)->text().toInt();
	90	if(index!=-1)
	91	{
	92	this->p_srec->getFragmentData(index,&buff);
	93	this->ui->fragmentHexView->setData(QByteArray(buff,this->p_srec->getFragmentSize(index)));
	94	this->ui->fragmentHexView->setAddressOffset(this->p_srec->getFragmentAddress(index));
	95	}
	96
	97	}
	98
	99	void srecFileWidget::exportToSREC()
	100	{
	101	QList<codeFragment *> SelectedFragmentsList=getSelectedFragments();
	102	if(SelectedFragmentsList.count()>0)
	103	{
	104	QString fileName = QFileDialog::getSaveFileName(this, tr("Save File"),
	105	NULL,
	106	tr("SREC Files (*.srec)"));
	107	if(!fileName.isEmpty())
	108	{
	109	srecFile::toSrec(SelectedFragmentsList,fileName);
	110	}
	111	}
	112	}
	113
	114	void srecFileWidget::exportToBIN()
	115	{
	116	QList<codeFragment *> SelectedFragmentsList=getSelectedFragments();
	117	if(SelectedFragmentsList.count()>0)
	118	{
	119	QString fileName = QFileDialog::getSaveFileName(this, tr("Save File"),
	120	NULL,
	121	tr("Binary Files (*.bin)"));
	122	if(!fileName.isEmpty())
	123	{
	124	binaryFile::toBinary(SelectedFragmentsList,fileName);
	125	}
	126	}
	127	}
	128
	129	QList<codeFragment *> srecFileWidget::getSelectedFragments()
	130	{
	131	QList<codeFragment *> SelectedFragmentsList;
	132	QList<QTableWidgetItem*> items = this->ui->fragmentsList->selectedItems();
	133	for(int i=0;i<items.count();i++)
	134	{
	135	codeFragment * fragment = p_srec->getFragment(items.at(i)->row());
	136	if(!SelectedFragmentsList.contains(fragment))
	137	{
	138	SelectedFragmentsList.append(fragment);
	139	}
	140	}
	141	return SelectedFragmentsList;
	142	}
	143
	144

src/common/genericBinaryFiles/srec/srecfilewidget.h created 644 +58 0

@@ -0,0 +1,58
	1	/*------------------------------------------------------------------------------
	2	-- This file is a part of the SocExplorer Software
	3	-- Copyright (C) 2014, Plasma Physics Laboratory - CNRS
	4	--
	5	-- This program is free software; you can redistribute it and/or modify
	6	-- it under the terms of the GNU General Public License as published by
	7	-- the Free Software Foundation; either version 2 of the License, or
	8	-- (at your option) any later version.
	9	--
	10	-- This program is distributed in the hope that it will be useful,
	11	-- but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	-- GNU General Public License for more details.
	14	--
	15	-- You should have received a copy of the GNU General Public License
	16	-- along with this program; if not, write to the Free Software
	17	-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	18	-------------------------------------------------------------------------------*/
	19	/*-- Author : Alexis Jeandet
	20	-- Mail : alexis.jeandet@member.fsf.org
	21	----------------------------------------------------------------------------*/
	22	#ifndef SRECFILEWIDGET_H
	23	#define SRECFILEWIDGET_H
	24
	25	#include <QWidget>
	26	#include "srecfile.h"
	27	#include <QAction>
	28
	29	namespace Ui {
	30	class srecFileWidget;
	31	}
	32
	33	class srecFileWidget : public abstractBinFileWidget
	34	{
	35	Q_OBJECT
	36
	37	public:
	38	explicit srecFileWidget(QWidget *parent = 0);
	39	~srecFileWidget();
	40
	41	public slots:
	42	void setFile(abstractBinFile* file);
	43	void reloadFile();
	44
	45	private slots:
	46	void recordCellActivated(int row, int column);
	47	void exportToSREC();
	48	void exportToBIN();
	49
	50	private:
	51	QList<codeFragment *> getSelectedFragments();
	52	Ui::srecFileWidget *ui;
	53	srecFile* p_srec;
	54	QAction* exportToSREC_action;
	55	QAction* exportToBIN_action;
	56	};
	57
	58	#endif // SRECFILEWIDGET_H

src/common/genericBinaryFiles/srec/srecfilewidget.ui created 644 +87 0

@@ -0,0 +1,87
	1	<?xml version="1.0" encoding="UTF-8"?>
	2	<ui version="4.0">
	3	<class>srecFileWidget</class>
	4	<widget class="QWidget" name="srecFileWidget">
	5	<property name="geometry">
	6	<rect>
	7	<x>0</x>
	8	<y>0</y>
	9	<width>740</width>
	10	<height>516</height>
	11	</rect>
	12	</property>
	13	<property name="windowTitle">
	14	<string>Form</string>
	15	</property>
	16	<layout class="QGridLayout" name="gridLayout">
	17	<item row="0" column="0">
	18	<widget class="QSplitter" name="splitter">
	19	<property name="orientation">
	20	<enum>Qt::Horizontal</enum>
	21	</property>
	22	<widget class="QGroupBox" name="groupBox">
	23	<property name="title">
	24	<string>Hexadecimal Viewer</string>
	25	</property>
	26	<layout class="QVBoxLayout" name="verticalLayout">
	27	<item>
	28	<widget class="QHexEdit" name="fragmentHexView" native="true">
	29	<property name="minimumSize">
	30	<size>
	31	<width>256</width>
	32	<height>0</height>
	33	</size>
	34	</property>
	35	</widget>
	36	</item>
	37	</layout>
	38	</widget>
	39	<widget class="QGroupBox" name="groupBox_2">
	40	<property name="title">
	41	<string>SREC records list</string>
	42	</property>
	43	<layout class="QVBoxLayout" name="verticalLayout_2">
	44	<item>
	45	<widget class="QTableWidget" name="fragmentsList">
	46	<property name="contextMenuPolicy">
	47	<enum>Qt::ActionsContextMenu</enum>
	48	</property>
	49	<column>
	50	<property name="text">
	51	<string>Index</string>
	52	</property>
	53	</column>
	54	<column>
	55	<property name="text">
	56	<string>Address</string>
	57	</property>
	58	</column>
	59	<column>
	60	<property name="text">
	61	<string>Size</string>
	62	</property>
	63	</column>
	64	<column>
	65	<property name="text">
	66	<string>Header</string>
	67	</property>
	68	</column>
	69	</widget>
	70	</item>
	71	</layout>
	72	</widget>
	73	</widget>
	74	</item>
	75	</layout>
	76	</widget>
	77	<customwidgets>
	78	<customwidget>
	79	<class>QHexEdit</class>
	80	<extends>QWidget</extends>
	81	<header location="global">qhexedit.h</header>
	82	<container>1</container>
	83	</customwidget>
	84	</customwidgets>
	85	<resources/>
	86	<connections/>
	87	</ui>

src/common/common.pro +46 -46

             win32:CONFIG += dll
             win32:CONFIG -= static
-            win32:INCLUDEPATH += $${PWD}/elf/libelfWin32/include
+            win32:INCLUDEPATH += $${PWD}/genericBinaryFiles/elf/libelfWin32/include
-            win32:INCLUDEPATH += $${PWD}/elf/libelfWin32/include/libelf
+            win32:INCLUDEPATH += $${PWD}/genericBinaryFiles/elf/libelfWin32/include/libelf
             win32:DEFINES+=_ELF_WINDOWS_
             DEFINES+=RS232_debug
-            win32:LIBS += $${PWD}/elf/libelfWin32/bin/libelf.a
+            win32:LIBS += $${PWD}/genericBinaryFiles/elf/libelfWin32/bin/libelf.a
             unix:LIBS += -lelf
             QMAKE_LFLAGS_RELEASE += --enable-auto-import
                 QCustomPlot/qcustomplot.h \
                 SocExplorerPlot.h \
                 tcp_terminal_client.h \
-                elf/elfinfowdgt.h \
+                genericBinaryFiles/elf/elfinfowdgt.h \
-                elf/elfparser.h \
+                genericBinaryFiles/elf/elfparser.h \
-                elf/elffile.h \
+                genericBinaryFiles/elf/elffile.h \
-                elf/elffilewidget.h \
+                genericBinaryFiles/elf/elffilewidget.h \
                 qipdialogbox.h \
                 lppserial/src/RS232.h \
                 qtablewidgetintitem.h \
-                srec/srecfile.h \
+                genericBinaryFiles/srec/srecfile.h \
-                srec/srecfilewidget.h \
+                genericBinaryFiles/srec/srecfilewidget.h \
-                BinFile/binaryfile.h \
+                genericBinaryFiles/BinFile/binaryfile.h \
-                BinFile/binaryfilewidget.h \
+                genericBinaryFiles/BinFile/binaryfilewidget.h \
-                abstractbinfile.h
+                genericBinaryFiles/abstractbinfile.h
             win32{
-                elfheader.path = $$[QT_INSTALL_HEADERS]/SocExplorer/common/libelf
+                elfheader.path = $$[QT_INSTALL_HEADERS]/SocExplorer/common/genericBinaryFiles/libelf
                 elfheader.files += \
-                    elf/libelfWin32/include/libelf/byteswap.h  \
+                    genericBinaryFiles/elf/libelfWin32/include/libelf/byteswap.h  \
-                    elf/libelfWin32/include/libelf/errors.h     \
+                    genericBinaryFiles/elf/libelfWin32/include/libelf/errors.h     \
-                    elf/libelfWin32/include/libelf/gelf.h    \
+                    genericBinaryFiles/elf/libelfWin32/include/libelf/gelf.h    \
-                    elf/libelfWin32/include/libelf/nlist.h    \
+                    genericBinaryFiles/elf/libelfWin32/include/libelf/nlist.h    \
-                    elf/libelfWin32/include/libelf/sys_elf.h  \
+                    genericBinaryFiles/elf/libelfWin32/include/libelf/sys_elf.h  \
-                    elf/libelfWin32/include/libelf/verneed.h \
+                    genericBinaryFiles/elf/libelfWin32/include/libelf/verneed.h \
-                    elf/libelfWin32/include/libelf/elf_repl.h \
+                    genericBinaryFiles/elf/libelfWin32/include/libelf/elf_repl.h \
-                    elf/libelfWin32/include/libelf/ext_types.h \
+                    genericBinaryFiles/elf/libelfWin32/include/libelf/ext_types.h \
-                    elf/libelfWin32/include/libelf/libelf.h  \
+                    genericBinaryFiles/elf/libelfWin32/include/libelf/libelf.h  \
-                    elf/libelfWin32/include/libelf/private.h  \
+                    genericBinaryFiles/elf/libelfWin32/include/libelf/private.h  \
-                    elf/libelfWin32/include/libelf/verdef.h
+                    genericBinaryFiles/elf/libelfWin32/include/libelf/verdef.h
                 INSTALLS += elfheader
             }
             INSTALLS += target header
-            INCLUDEPATH += QCustomPlot qhexedit srec BinFile
+            INCLUDEPATH += QCustomPlot qhexedit   genericBinaryFiles genericBinaryFiles/srec  genericBinaryFiles/BinFile
             HEADERS += \
                 memsizewdgt.h \
                 qhexedit/commands.h \
                 QCustomPlot/qcustomplot.h \
                 tcp_terminal_client.h \
-                elf/elfinfowdgt.h \
+                genericBinaryFiles/elf/elfinfowdgt.h \
-                elf/elfparser.h \
+                genericBinaryFiles/elf/elfparser.h \
-                elf/elffile.h \
+                genericBinaryFiles/elf/elffile.h \
                 qipdialogbox.h \
                 PySocExplorer.h \
                 SocExplorerPlot.h \
-                elf/elffilewidget.h \
+                genericBinaryFiles/elf/elffilewidget.h \
                 qtablewidgetintitem.h \
-                srec/srecfile.h \
+                genericBinaryFiles/srec/srecfile.h \
-                srec/srecfilewidget.h \
+                genericBinaryFiles/srec/srecfilewidget.h \
-                abstractbinfile.h \
+                genericBinaryFiles/abstractbinfile.h \
-                BinFile/binaryfile.h \
+                genericBinaryFiles/BinFile/binaryfile.h \
-                BinFile/binaryfilewidget.h
+                genericBinaryFiles/BinFile/binaryfilewidget.h
             SOURCES += \
                 qhexedit/commands.cpp \
                 QCustomPlot/qcustomplot.cpp \
                 tcp_terminal_client.cpp \
-                elf/elfinfowdgt.cpp \
+                genericBinaryFiles/elf/elfinfowdgt.cpp \
-                elf/elfparser.cpp \
+                genericBinaryFiles/elf/elfparser.cpp \
-                elf/elffile.cpp \
+                genericBinaryFiles/elf/elffile.cpp \
                 qipdialogbox.cpp \
                 SocExplorerPlot.cpp \
-                elf/elffilewidget.cpp \
+                genericBinaryFiles/elf/elffilewidget.cpp \
                 qtablewidgetintitem.cpp \
-                srec/srecfile.cpp \
+                genericBinaryFiles/srec/srecfile.cpp \
-                srec/srecfilewidget.cpp \
+                genericBinaryFiles/srec/srecfilewidget.cpp \
-                abstractbinfile.cpp \
+                genericBinaryFiles/abstractbinfile.cpp \
-                BinFile/binaryfile.cpp \
+                genericBinaryFiles/BinFile/binaryfile.cpp \
-                BinFile/binaryfilewidget.cpp
+                genericBinaryFiles/BinFile/binaryfilewidget.cpp
             FORMS += \
-                elf/elffilewidget.ui \
+                genericBinaryFiles/elf/elffilewidget.ui \
-                srec/srecfilewidget.ui \
+                genericBinaryFiles/srec/srecfilewidget.ui \
-                BinFile/binaryfilewidget.ui
+                genericBinaryFiles/BinFile/binaryfilewidget.ui
             OTHER_FILES += \
                 ./pythongenerator.sh \

src/common/pythongenerator.sh +1 -1

             #export QTDIR=/usr/include
             #export QTDIR=/usr/include/qt5
-            pythonqt_generator  --include-paths=./elf:./srec:./BinFile:/usr/include/qt5:/usr/include/qt5/QtCore:/usr/include/qt5/QtWidgets  --output-directory=pythonQtOut PySocExplorer.h pythonQtgeneratorCfg.txt
+            pythonqt_generator  --include-paths=./genericBinaryFiles/elf:./genericBinaryFiles/srec:./genericBinaryFiles/BinFile:/usr/include/qt5:/usr/include/qt5/QtCore:/usr/include/qt5/QtWidgets  --output-directory=pythonQtOut PySocExplorer.h pythonQtgeneratorCfg.txt

src/src.pro +6 -5

                         $${PWD}/common \
                         $${PWD}/common/qhexedit \
                         $${PWD}/common/QCustomPlot \
-                        $${PWD}/common/elf \
+                        $${PWD}/common/genericBinaryFiles \
-                        $${PWD}/common/srec \
+                        $${PWD}/common/genericBinaryFiles/elf \
-                        $${PWD}/common/BinFile \
+                        $${PWD}/common/genericBinaryFiles/srec \
+                        $${PWD}/common/genericBinaryFiles/BinFile \
                         SocExplorerEngine/engine \
                         SocExplorerEngine/pluginloader \
                         SocExplorerEngine/pluginsInterface \
                         SocExplorerEngine/PeripheralWidget/src
             win32:INCLUDEPATH+= \
-                        $${PWD}/common/elf/libelfWin32/include \
+                        $${PWD}/common/genericBinaryFiles/elf/libelfWin32/include \
-                        $${PWD}/common/elf/libelfWin32/include/libelf \
+                        $${PWD}/common/genericBinaryFiles/elf/libelfWin32/include/libelf \
             RC_FILE = ../win32cfg/socexplorer.rc

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages