HG_REPOSITORIES/LPP/INSTRUMENTATION/genericBinaryFiles Commit - r0:76019e856a27

init

Jeandet Alexis -

r0:76019e856a27 default

parent child

Context file:

r0:76019e856a27

Expand all files

.hgignore created 644 +2 0

			@@ -0,0 +1,2
		1	syntax: glob
		2	*~

BinFile/binaryfile.cpp created 644 +175 0

			@@ -0,0 +1,175
		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 "binaryfile.h"
		23	#include "srecfile.h"
		24
		25	binaryFile::binaryFile()
		26	{
		27	}
		28
		29	binaryFile::binaryFile(const QString &File)
		30	{
		31	openFile(File);
		32	}
		33
		34	binaryFile::binaryFile(const QStringList &Files)
		35	{
		36	openFiles(Files);
		37	}
		38
		39	binaryFile::~binaryFile()
		40	{
		41
		42	}
		43
		44	bool binaryFile::openFile(const QString &File)
		45	{
		46	return openFiles(QStringList()<<File);
		47	}
		48
		49	bool binaryFile::openFiles(const QStringList &Files)
		50	{
		51	for(int i=0;i<Files.count();i++)
		52	{
		53	this->p_files.append(new QFile(Files.at(i)));
		54	this->p_files.at(i)->open(QIODevice::ReadOnly);
		55	loadFile(this->p_files.at(i));
		56	}
		57	return true;
		58	}
		59
		60	bool binaryFile::isopened()
		61	{
		62	bool opened = true;
		63	for(int i=0;i<this->p_files.count();i++)
		64	{
		65	opened &= p_files.at(i)->isOpen();
		66	}
		67	return opened;
		68	}
		69
		70	int binaryFile::closeFile()
		71	{
		72	for(int i=0;i<p_files.count();i++)
		73	{
		74	delete p_files.at(i);
		75	for(int j=0;j<p_fragments.count();j++)
		76	{
		77	if(p_fragments.at(j)->header == p_files.at(i)->fileName())
		78	{
		79	codeFragment* fragment = p_fragments.at(j);
		80	p_fragments.removeAt(j);
		81	delete fragment;
		82	}
		83	}
		84	}
		85	p_files.clear();
		86	p_fileName.clear();
		87	return 0;
		88	}
		89
		90	QList<codeFragment *> binaryFile::getFragments()
		91	{
		92	return p_fragments;
		93	}
		94
		95	int binaryFile::getFragmentsCount()
		96	{
		97	return p_fragments.count();
		98	}
		99
		100	int binaryFile::getFragmentAddress(int index)
		101	{
		102	if((index>=0)&&(index<p_fragments.count()))
		103	return p_fragments.at(index)->address;
		104	return 0;
		105	}
		106
		107	int binaryFile::getFragmentSize(int index)
		108	{
		109	if((index>=0)&&(index<p_fragments.count()))
		110	return p_fragments.at(index)->size;
		111	return 0;
		112	}
		113
		114	QString binaryFile::getFragmentHeader(int index)
		115	{
		116	if((index>=0)&&(index<p_fragments.count()))
		117	return p_fragments.at(index)->header;
		118	return "";
		119	}
		120
		121	codeFragment *binaryFile::getFragment(int index)
		122	{
		123	if((index>=0)&&(index<p_fragments.count()))
		124	return p_fragments.at(index);
		125	return NULL;
		126	}
		127
		128	bool binaryFile::getFragmentData(int index, char **buffer)
		129	{
		130	if((index>=0)&&(index<p_fragments.count()))
		131	{
		132	*buffer = p_fragments.at(index)->data;
		133	return true;
		134	}
		135	return false;
		136	}
		137
		138	bool binaryFile::toSrec(const QString &fileName)
		139	{
		140	srecFile::toSrec(p_fragments,fileName);
		141	}
		142
		143	bool binaryFile::toBinary(const QString &fileName)
		144	{
		145	toBinary(p_fragments,fileName);
		146	}
		147
		148	bool binaryFile::toBinary(QList<codeFragment *> fragments, const QString &File)
		149	{
		150	QFile file(File);
		151	file.open(QIODevice::WriteOnly);
		152	if(file.isOpen())
		153	{
		154	for(int i=0;i<fragments.count();i++)
		155	{
		156	file.write(fragments.at(i)->data,fragments.at(i)->size);
		157	}
		158	return true;
		159	}
		160	return false;
		161	}
		162
		163	void binaryFile::loadFile(QFile *file)
		164	{
		165	if (file->isOpen())
		166	{
		167	codeFragment* fragment = new codeFragment();
		168	fragment->header = file->fileName();
		169	fragment->address = 0;
		170	fragment->size = file->size();
		171	fragment->data = (char*)malloc(file->size());
		172	file->read(fragment->data,file->size());
		173	p_fragments.append(fragment);
		174	}
		175	}

BinFile/binaryfile.h created 644 +64 0

			@@ -0,0 +1,64
		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 BINARYFILE_H
		23	#define BINARYFILE_H
		24	#include "abstractbinfile.h"
		25	#include <QObject>
		26	#include <QString>
		27	#include <QList>
		28	#include <QStringList>
		29	#include <QFile>
		30
		31	class binaryFile : public abstractBinFile
		32	{
		33	Q_OBJECT
		34	public:
		35	explicit binaryFile();
		36	binaryFile(const QString& File);
		37	binaryFile(const QStringList& Files);
		38	~binaryFile();
		39	bool openFile(const QString& File);
		40	bool openFiles(const QStringList& Files);
		41	bool isopened();
		42	int closeFile();
		43	QList<codeFragment*> getFragments();
		44	int getFragmentsCount();
		45	int getFragmentAddress(int index);
		46	int getFragmentSize(int index);
		47	QString getFragmentHeader(int index);
		48	codeFragment* getFragment(int index);
		49	bool getFragmentData(int index, char **buffer);
		50	bool toSrec(const QString& fileName);
		51	bool toBinary(const QString& fileName);
		52	static bool toBinary(QList<codeFragment*> fragments,const QString& File);
		53	signals:
		54
		55	public slots:
		56
		57	private:
		58	void loadFile(QFile *file);
		59	QStringList p_fileNames;
		60	QList<QFile*>p_files;
		61	QList<codeFragment*> p_fragments;
		62	};
		63
		64	#endif // BINARYFILE_H

BinFile/binaryfilewidget.cpp created 644 +150 0

			@@ -0,0 +1,150
		1	#include "binaryfilewidget.h"
		2	#include "ui_binaryfilewidget.h"
		3	#include "qtablewidgetintitem.h"
		4	#include <QtWidgets/QTableWidget>
		5	#include <QtWidgets/QFileDialog>
		6	#include "srecfile.h"
		7
		8	binaryFileWidget::binaryFileWidget(QWidget *parent) :
		9	abstractBinFileWidget(parent),
		10	ui(new Ui::binaryFileWidget)
		11	{
		12	ui->setupUi(this);
		13	connect(this->ui->fragmentList,SIGNAL(cellActivated(int,int)),this,SLOT(fragmentCellActivated(int,int)));
		14	connect(this->ui->fragmentList,SIGNAL(cellChanged(int,int)),this,SLOT(fragmentCellChanged(int,int)));
		15	exportToSREC_action = new QAction(tr("Export to SREC"),this);
		16	exportToBIN_action = new QAction(tr("Export to Binary"),this);
		17	this->ui->fragmentList->addAction(exportToBIN_action);
		18	this->ui->fragmentList->addAction(exportToSREC_action);
		19	connect(this->exportToBIN_action,SIGNAL(triggered()),this,SLOT(exportToBIN()));
		20	connect(this->exportToSREC_action,SIGNAL(triggered()),this,SLOT(exportToSREC()));
		21	}
		22
		23	binaryFileWidget::~binaryFileWidget()
		24	{
		25	delete ui;
		26	}
		27
		28	void binaryFileWidget::setFile(abstractBinFile *file)
		29	{
		30	this->p_binfile = (binaryFile*)file;
		31	if(p_binfile->isopened())
		32	{
		33	reloadFile();
		34	}
		35	}
		36
		37	void binaryFileWidget::reloadFile()
		38	{
		39	this->ui->fragmentList->clear();
		40	this->ui->fragmentList->setRowCount(p_binfile->getFragmentsCount());
		41	this->ui->fragmentList->setHorizontalHeaderLabels(QStringList()<<"File"<<"Size"<<"Address");
		42	for(int i=0;i<p_binfile->getFragmentsCount();i++)
		43	{
		44	QTableWidgetItem *newItem = new QTableWidgetItem(p_binfile->getFragmentHeader(i));
		45	newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
		46	this->ui->fragmentList->setItem(i, 0, newItem);
		47
		48	newItem = (QTableWidgetItem*)new QTableWidgetIntItem(QString("%1").arg(p_binfile->getFragmentSize(i)),DecimalItem);
		49	newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
		50	this->ui->fragmentList->setItem(i, 1, newItem);
		51
		52	newItem = (QTableWidgetItem*)new QTableWidgetIntItem(QString("0x%1").arg(p_binfile->getFragmentAddress(i),8,16).replace(" ","0"),HexaDecimalItem);
		53	// newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
		54	this->ui->fragmentList->setItem(i, 2, newItem);
		55
		56	}
		57	this->ui->fragmentList->resizeColumnsToContents();
		58	}
		59
		60	void binaryFileWidget::fragmentCellActivated(int row, int column)
		61	{
		62	Q_UNUSED(column)
		63	char* buff=NULL;
		64	int index = this->ui->fragmentList->item(row,0)->text().toInt();
		65	if(index!=-1)
		66	{
		67	this->p_binfile->getFragmentData(index,&buff);
		68	this->ui->hexViewer->setData(QByteArray(buff,this->p_binfile->getFragmentSize(index)));
		69	this->ui->hexViewer->setAddressOffset(this->p_binfile->getFragmentAddress(index));
		70	}
		71	}
		72
		73	void binaryFileWidget::fragmentCellChanged(int row, int column)
		74	{
		75	if(column==2)
		76	{
		77	QString newAddressStr = this->ui->fragmentList->item(row,column)->text();
		78	int newAddress = 0;
		79	newAddressStr.remove(" ");
		80	if(newAddressStr.at(0)=='0' && newAddressStr.at(1)=='x')
		81	{
		82	newAddress = newAddressStr.remove("0x").toUInt(0,16);
		83	}
		84	else
		85	{
		86	newAddress = newAddressStr.toUInt();
		87	}
		88	this->p_binfile->getFragments().at(row)->address = newAddress;
		89	}
		90	}
		91
		92	void binaryFileWidget::exportToSREC()
		93	{
		94	QList<codeFragment *> SelectedFragmentsList=getSelectedFragments();
		95	if(SelectedFragmentsList.count()>0)
		96	{
		97	QString fileName = QFileDialog::getSaveFileName(this, tr("Save File"),
		98	NULL,
		99	tr("SREC Files (*.srec)"));
		100	if(!fileName.isEmpty())
		101	{
		102	srecFile::toSrec(SelectedFragmentsList,fileName);
		103	}
		104	}
		105	}
		106
		107	void binaryFileWidget::exportToBIN()
		108	{
		109	QList<codeFragment *> SelectedFragmentsList=getSelectedFragments();
		110	if(SelectedFragmentsList.count()>0)
		111	{
		112	QString fileName = QFileDialog::getSaveFileName(this, tr("Save File"),
		113	NULL,
		114	tr("Binary Files (*.bin)"));
		115	if(!fileName.isEmpty())
		116	{
		117	binaryFile::toBinary(SelectedFragmentsList,fileName);
		118	}
		119	}
		120	}
		121
		122	QStringList binaryFileWidget::getSelectedFilesNames()
		123	{
		124	QStringList SelectedFilesList;
		125	QList<QTableWidgetItem*> items = this->ui->fragmentList->selectedItems();
		126	for(int i=0;i<items.count();i++)
		127	{
		128	QString file = p_binfile->getFragmentHeader(items.at(i)->row());
		129	if(!SelectedFilesList.contains(file))
		130	{
		131	SelectedFilesList.append(file);
		132	}
		133	}
		134	return SelectedFilesList;
		135	}
		136
		137	QList<codeFragment *> binaryFileWidget::getSelectedFragments()
		138	{
		139	QList<codeFragment *> SelectedFragmentsList;
		140	QList<QTableWidgetItem*> items = this->ui->fragmentList->selectedItems();
		141	for(int i=0;i<items.count();i++)
		142	{
		143	codeFragment * fragment = p_binfile->getFragment(items.at(i)->row());
		144	if(!SelectedFragmentsList.contains(fragment))
		145	{
		146	SelectedFragmentsList.append(fragment);
		147	}
		148	}
		149	return SelectedFragmentsList;
		150	}

BinFile/binaryfilewidget.h created 644 +60 0

			@@ -0,0 +1,60
		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 BINARYFILEWIDGET_H
		23	#define BINARYFILEWIDGET_H
		24
		25	#include <QWidget>
		26	#include "binaryfile.h"
		27	#include <QAction>
		28
		29	namespace Ui {
		30	class binaryFileWidget;
		31	}
		32
		33	class binaryFileWidget : public abstractBinFileWidget
		34	{
		35	Q_OBJECT
		36
		37	public:
		38	explicit binaryFileWidget(QWidget *parent = 0);
		39	~binaryFileWidget();
		40
		41	public slots:
		42	void setFile(abstractBinFile* file);
		43	void reloadFile();
		44
		45	private slots:
		46	void fragmentCellActivated(int row, int column);
		47	void fragmentCellChanged(int row, int column);
		48	void exportToSREC();
		49	void exportToBIN();
		50
		51	private:
		52	QStringList getSelectedFilesNames();
		53	QList<codeFragment *> getSelectedFragments();
		54	Ui::binaryFileWidget *ui;
		55	binaryFile* p_binfile;
		56	QAction* exportToSREC_action;
		57	QAction* exportToBIN_action;
		58	};
		59
		60	#endif // BINARYFILEWIDGET_H

BinFile/binaryfilewidget.ui created 644 +64 0

			@@ -0,0 +1,64
		1	<?xml version="1.0" encoding="UTF-8"?>
		2	<ui version="4.0">
		3	<class>binaryFileWidget</class>
		4	<widget class="QWidget" name="binaryFileWidget">
		5	<property name="geometry">
		6	<rect>
		7	<x>0</x>
		8	<y>0</y>
		9	<width>637</width>
		10	<height>342</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="QHexEdit" name="hexViewer" native="true">
		23	<property name="minimumSize">
		24	<size>
		25	<width>200</width>
		26	<height>0</height>
		27	</size>
		28	</property>
		29	</widget>
		30	<widget class="QTableWidget" name="fragmentList">
		31	<property name="contextMenuPolicy">
		32	<enum>Qt::ActionsContextMenu</enum>
		33	</property>
		34	<column>
		35	<property name="text">
		36	<string>File</string>
		37	</property>
		38	</column>
		39	<column>
		40	<property name="text">
		41	<string>Size</string>
		42	</property>
		43	</column>
		44	<column>
		45	<property name="text">
		46	<string>Address</string>
		47	</property>
		48	</column>
		49	</widget>
		50	</widget>
		51	</item>
		52	</layout>
		53	</widget>
		54	<customwidgets>
		55	<customwidget>
		56	<class>QHexEdit</class>
		57	<extends>QWidget</extends>
		58	<header location="global">qhexedit.h</header>
		59	<container>1</container>
		60	</customwidget>
		61	</customwidgets>
		62	<resources/>
		63	<connections/>
		64	</ui>

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	}

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

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	}

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

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

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

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>

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

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

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

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

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!

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

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

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>

elf/libelfWin32/VERSION created 644 +1 0

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

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 */

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 */

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"))

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 */

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 */

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 */

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 */

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 */

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 */

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	}

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	}

genericbinaryfilewidget.cpp created 644 +62 0

			@@ -0,0 +1,62
		1	#include "genericbinaryfilewidget.h"
		2	#include "ui_genericbinaryfilewidget.h"
		3	#include <QFileDialog>
		4	#include <QFile>
		5	#include "srec/srecfile.h"
		6
		7	genericBinaryFileWidget::genericBinaryFileWidget(QWidget *parent) :
		8	QWidget(parent),
		9	ui(new Ui::genericBinaryFileWidget)
		10	{
		11	ui->setupUi(this);
		12	}
		13
		14	genericBinaryFileWidget::~genericBinaryFileWidget()
		15	{
		16	delete ui;
		17	}
		18
		19	void genericBinaryFileWidget::openFile()
		20	{
		21	QStringList filesNames = QFileDialog::getOpenFileNames(
		22	this,
		23	"Select one or more files to open",
		24	NULL,
		25	"Binary Files (.bin);;SREC Files (.srec);;Elf Files (*)");
		26
		27	for(int i=0;i<filesNames.count();i++)
		28	{
		29	QFile file(filesNames.at(i));
		30	if(file.open(QIODevice::ReadOnly))
		31	{
		32	char magic[4];
		33	file.read(magic,4);
		34	QString line;
		35	switch((int)magic[0])
		36	{
		37	case 'e':
		38	if((magic[1]=='l') && (magic[2]=='f'))
		39	{
		40	files.append(new FileListElement(filesNames.at(i),false,Type_Elf,NULL));
		41	}
		42	break;
		43	case 'S':
		44	file.seek(0);
		45	line = file.readLine();
		46	if(srecFile::checkSum(line))
		47	{
		48	files.append(new FileListElement(filesNames.at(i),false,Type_SREC,NULL));
		49	}
		50	break;
		51	default:
		52	files.append(new FileListElement(filesNames.at(i),false,Type_Bin,NULL));
		53	break;
		54	}
		55	}
		56	}
		57
		58	}
		59
		60
		61
		62

genericbinaryfilewidget.h created 644 +42 0

			@@ -0,0 +1,42
		1	#ifndef GENERICBINARYFILEWIDGET_H
		2	#define GENERICBINARYFILEWIDGET_H
		3
		4	#include <QWidget>
		5	#include <QString>
		6	#include <QStringList>
		7	#include <abstractbinfile.h>
		8
		9	namespace Ui {
		10	class genericBinaryFileWidget;
		11	}
		12
		13	typedef enum {Type_SREC,Type_Bin,Type_Elf}FileTypeEnum;
		14	class FileListElement
		15	{
		16	public:
		17	FileListElement() {}
		18	FileListElement(QString fileName,bool isOpened,FileTypeEnum FileType,abstractBinFileWidget* viewer)
		19	:fileName(fileName),isOpened(isOpened),FileType(FileType),viewer(viewer){}
		20	QString fileName;
		21	bool isOpened;
		22	FileTypeEnum FileType;
		23	abstractBinFileWidget* viewer;
		24	};
		25
		26	class genericBinaryFileWidget : public QWidget
		27	{
		28	Q_OBJECT
		29
		30	public:
		31	explicit genericBinaryFileWidget(QWidget *parent = 0);
		32	~genericBinaryFileWidget();
		33
		34	public slots:
		35	void openFile();
		36
		37	private:
		38	Ui::genericBinaryFileWidget *ui;
		39	QList<FileListElement*> files;
		40	};
		41
		42	#endif // GENERICBINARYFILEWIDGET_H

genericbinaryfilewidget.ui created 644 +103 0

			@@ -0,0 +1,103
		1	<?xml version="1.0" encoding="UTF-8"?>
		2	<ui version="4.0">
		3	<class>genericBinaryFileWidget</class>
		4	<widget class="QWidget" name="genericBinaryFileWidget">
		5	<property name="geometry">
		6	<rect>
		7	<x>0</x>
		8	<y>0</y>
		9	<width>878</width>
		10	<height>360</height>
		11	</rect>
		12	</property>
		13	<property name="acceptDrops">
		14	<bool>false</bool>
		15	</property>
		16	<property name="windowTitle">
		17	<string>Form</string>
		18	</property>
		19	<layout class="QGridLayout" name="gridLayout_2">
		20	<item row="0" column="0">
		21	<widget class="QSplitter" name="splitter">
		22	<property name="orientation">
		23	<enum>Qt::Horizontal</enum>
		24	</property>
		25	<widget class="QWidget" name="widget" native="true">
		26	<layout class="QGridLayout" name="gridLayout">
		27	<item row="1" column="0">
		28	<widget class="QPushButton" name="openFileQpb">
		29	<property name="text">
		30	<string/>
		31	</property>
		32	<property name="icon">
		33	<iconset resource="../SocExplorerCommon.qrc">
		34	<normaloff>:/images/add.svg</normaloff>:/images/add.svg</iconset>
		35	</property>
		36	<property name="iconSize">
		37	<size>
		38	<width>32</width>
		39	<height>32</height>
		40	</size>
		41	</property>
		42	</widget>
		43	</item>
		44	<item row="1" column="1">
		45	<widget class="QPushButton" name="removeFileQpb">
		46	<property name="text">
		47	<string/>
		48	</property>
		49	<property name="icon">
		50	<iconset resource="../SocExplorerCommon.qrc">
		51	<normaloff>:/images/trash.svg</normaloff>:/images/trash.svg</iconset>
		52	</property>
		53	<property name="iconSize">
		54	<size>
		55	<width>32</width>
		56	<height>32</height>
		57	</size>
		58	</property>
		59	</widget>
		60	</item>
		61	<item row="1" column="2">
		62	<spacer name="horizontalSpacer">
		63	<property name="orientation">
		64	<enum>Qt::Horizontal</enum>
		65	</property>
		66	<property name="sizeHint" stdset="0">
		67	<size>
		68	<width>40</width>
		69	<height>20</height>
		70	</size>
		71	</property>
		72	</spacer>
		73	</item>
		74	<item row="0" column="0" colspan="3">
		75	<widget class="QTableWidget" name="tableWidget">
		76	<column>
		77	<property name="text">
		78	<string>File</string>
		79	</property>
		80	</column>
		81	<column>
		82	<property name="text">
		83	<string>Type</string>
		84	</property>
		85	</column>
		86	</widget>
		87	</item>
		88	</layout>
		89	</widget>
		90	<widget class="QTabWidget" name="fileViewerTab">
		91	<property name="currentIndex">
		92	<number>-1</number>
		93	</property>
		94	</widget>
		95	</widget>
		96	</item>
		97	</layout>
		98	</widget>
		99	<resources>
		100	<include location="../SocExplorerCommon.qrc"/>
		101	</resources>
		102	<connections/>
		103	</ui>

srec/srecfile.cpp created 644 +456 0

			@@ -0,0 +1,456
		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	p_mergingRecords = true;
		29	}
		30
		31	srecFile::srecFile(const QString &File)
		32	{
		33	p_mergingRecords = true;
		34	openFile(File);
		35	}
		36
		37	srecFile::srecFile(const QStringList &Files)
		38	{
		39	p_mergingRecords = true;
		40	openFiles(Files);
		41	}
		42
		43	srecFile::~srecFile()
		44	{
		45
		46	}
		47
		48	bool srecFile::openFile(const QString &File)
		49	{
		50	return openFiles(QStringList()<<File);
		51	}
		52
		53	bool srecFile::openFiles(const QStringList &Files)
		54	{
		55	for(int i=0;i<Files.count();i++)
		56	{
		57	this->p_isSrec=true;
		58	this->p_isSrec &= isSREC(Files.at(i));
		59	this->p_files.append(new QFile(Files.at(i)));
		60	this->p_files.at(i)->open(QIODevice::ReadOnly);
		61	parseFile(this->p_files.at(i));
		62	}
		63	return true;
		64	}
		65
		66	bool srecFile::isopened()
		67	{
		68	bool opened = true;
		69	for(int i=0;i<this->p_files.count();i++)
		70	{
		71	opened &= p_files.at(i)->isOpen();
		72	}
		73	return opened;
		74	}
		75
		76	int srecFile::closeFile()
		77	{
		78	for(int i=0;i<p_files.count();i++)
		79	{
		80	delete p_files.at(i);
		81	delete p_fragments.at(i);
		82	}
		83	p_fragments.clear();
		84	p_files.clear();
		85	p_fileName.clear();
		86	return 0;
		87	}
		88
		89	QList<codeFragment *> srecFile::getFragments()
		90	{
		91	return p_fragments;
		92	}
		93
		94	bool srecFile::toSrec(QList<codeFragment *> fragments, const QString &File)
		95	{
		96	QString line;
		97	QFile file(File);
		98	file.open(QIODevice::WriteOnly);
		99	if(file.isOpen())
		100	{
		101	QTextStream stream( &file );
		102	//First build header
		103	stream << buildRecord(0,0,File.toStdString().c_str(),File.count());
		104	for(int i=0;i<fragments.count();i++)
		105	{
		106	codeFragment *fragment = fragments.at(i);
		107	for(int j=0;j<((int)(fragment->size)/16);j++)
		108	{
		109	stream << buildRecord(3,fragment->address+(j16),fragment->data+(j16),16);
		110	}
		111	int rem = fragment->size % 16;
		112	if(rem)
		113	{
		114	stream << buildRecord(3,fragment->address+fragment->size-rem,fragment->data+fragment->size-rem,rem);
		115	}
		116	stream << buildRecord(7,fragment->address,NULL,0);
		117	}
		118	file.close();
		119	return true;
		120	}
		121
		122	return false;
		123	}
		124
		125	bool srecFile::toSrec(const QString &File)
		126	{
		127	return toSrec(p_fragments,File);
		128	}
		129
		130	bool srecFile::toBinary(const QString &File)
		131	{
		132	return binaryFile::toBinary(p_fragments,File);
		133	}
		134
		135	int srecFile::lineCount()
		136	{
		137	return p_lineCount;
		138	}
		139
		140	int srecFile::getFragmentsCount()
		141	{
		142	return p_fragments.count();
		143	}
		144
		145	int srecFile::getFragmentAddress(int index)
		146	{
		147	if((index < p_fragments.count()) && (index>=0))
		148	{
		149	return p_fragments.at(index)->address;
		150	}
		151	return 0;
		152	}
		153
		154	int srecFile::getFragmentSize(int index)
		155	{
		156	if((index < p_fragments.count()) && (index>=0))
		157	{
		158	return p_fragments.at(index)->size;
		159	}
		160	return 0;
		161	}
		162
		163	codeFragment *srecFile::getFragment(int index)
		164	{
		165	if((index < p_fragments.count()) && (index>=0))
		166	{
		167	return p_fragments.at(index);
		168	}
		169	return NULL;
		170	}
		171
		172	QString srecFile::getFragmentHeader(int index)
		173	{
		174	if((index < p_fragments.count()) && (index>=0))
		175	{
		176	return p_fragments.at(index)->header;
		177	}
		178	return "";
		179	}
		180
		181	bool srecFile::getFragmentData(int index, char **buffer)
		182	{
		183
		184	if((index < p_fragments.count()) && (index>=0))
		185	{
		186	buffer = (char )this->p_fragments.at(index)->data;
		187	return true;
		188	}
		189	return false;
		190	}
		191
		192	bool srecFile::mergingRecords()
		193	{
		194	return p_mergingRecords;
		195	}
		196
		197	void srecFile::setMergingRecords(bool enabled)
		198	{
		199	p_mergingRecords = enabled;
		200	}
		201
		202	bool srecFile::isSREC()
		203	{
		204	return p_isSrec & isopened();
		205	}
		206
		207	bool srecFile::isSREC(const QString &File)
		208	{
		209	QFile file(File);
		210	file.open(QIODevice::ReadOnly);
		211	if(file.isOpen())
		212	{
		213	file.seek(0);
		214	QString line=file.readLine();
		215	file.close();
		216	return ((line.at(0)=='S')&&(line.at(1)=='0'));
		217	}
		218	return false;
		219	}
		220
		221
		222	void srecFile::parseFile(QFile *file)
		223	{
		224	if(file->isOpen())
		225	{
		226	this->p_lineCount = 0;
		227	file->seek(0);
		228	codeFragment* fragment=NULL;
		229	bool newFragment=true;
		230	char* data;
		231	quint64 size=0;
		232	quint64 address=-1;
		233	QString header;
		234	while (!file->atEnd())
		235	{
		236	QString line = file->readLine();
		237	p_lineCount++;
		238	int rectype = parseLine(line,&address,&data,&size);
		239	if(rectype==0)
		240	{
		241	header.clear();
		242	header.append(data);
		243	fragment = new codeFragment(data,size,address);
		244	fragment->header = header;
		245	p_fragments.append(fragment);
		246	}
		247	else
		248	{
		249	if((rectype>=1) && (rectype<=3))
		250	{
		251	if(p_mergingRecords)
		252	{
		253	//Could I merge it with an other fragment?
		254	bool merged = false;
		255	for(int i=0;i<p_fragments.count();i++)
		256	{
		257	codeFragment* frag = p_fragments.at(i);
		258	if(((frag->address+frag->size)==address) && (merged==false) && (size!=0))
		259	{
		260	merged = mergeFragment(frag,data,size);
		261	}
		262	}
		263	if(!merged)
		264	{
		265	fragment = new codeFragment(data,size,address);
		266	fragment->header = header;
		267	p_fragments.append(fragment);
		268	}
		269	}
		270	else
		271	{
		272	if(newFragment)
		273	{
		274	fragment = new codeFragment(data,size,address);
		275	fragment->header = header;
		276	p_fragments.append(fragment);
		277	newFragment = false;
		278	}
		279	else
		280	{
		281	codeFragment* frag = p_fragments.last();
		282	mergeFragment(frag,data,size);
		283	}
		284	}
		285
		286	}
		287	else
		288	{
		289	if((rectype>=7) && (rectype<=9))
		290	{
		291	newFragment = true;
		292	}
		293	}
		294	}
		295	}
		296	}
		297	}
		298
		299
		300	int srecFile::parseLine(const QString &record, quint64 address, char data, quint64 size)
		301	{
		302	#define newData (*data)
		303	#define newAddress (*address)
		304	#define newSize (*size)
		305	int recType = -1;
		306	if((record.count()>4) && checkSum(record))
		307	{
		308	if(record.at(0)=='S')
		309	{
		310	recType = record.at(1).toLatin1() & 0x0F;
		311	//Header type
		312	if(recType==0)
		313	{
		314	newAddress = record.mid(4,4).toInt(0,16);
		315	newSize = record.mid(2,2).toInt(0,16) - 3;
		316	if(newSize>0)
		317	{
		318	newData=(char*)malloc(newSize+1);
		319	for(int i=0;i<(int)newSize;i++)
		320	{
		321	newData[i] = ((char)record.mid((2*i)+8,2).toInt(0,16));
		322	}
		323	newData[newSize] = '\0'; // force string end for header
		324	}
		325	}
		326	//2 address byte record type
		327	if((recType==1) \|\| (recType==5) \|\| (recType==9))
		328	{
		329	newAddress = record.mid(4,4).toInt(0,16);
		330	newSize = record.mid(2,2).toInt(0,16) - 3;
		331	if(newSize>0)
		332	{
		333	newData=(char*)malloc(newSize);
		334	for(int i=0;i<(int)newSize;i++)
		335	{
		336	newData[i] = ((char)record.mid((2*i)+8,2).toInt(0,16));
		337	}
		338	}
		339	}
		340	//3 address byte record type
		341	if((recType==2) \|\| (recType==6) \|\| (recType==8))
		342	{
		343	newAddress = record.mid(4,6).toInt(0,16);
		344	newSize = record.mid(2,2).toInt(0,16) - 4;
		345	if(newSize>0)
		346	{
		347	newData=(char*)malloc(newSize);
		348	for(int i=0;i<(int)newSize;i++)
		349	{
		350	newData[i] = ((char)record.mid((2*i)+10,2).toInt(0,16));
		351	}
		352	}
		353	}
		354	//4 address byte record type
		355	if((recType==3) \|\| (recType==7))
		356	{
		357	newAddress = record.mid(4,8).toInt(0,16);
		358	newSize = record.mid(2,2).toInt(0,16) - 5;
		359	if(newSize>0)
		360	{
		361	newData=(char*)malloc(newSize);
		362	for(int i=0;i<(int)newSize;i++)
		363	{
		364	newData[i] = ((char)record.mid((2*i)+12,2).toInt(0,16));
		365	}
		366	}
		367	}
		368	}
		369	}
		370	return recType;
		371	}
		372
		373
		374	char srecFile::lineCheckSum(const QString &line)
		375	{
		376	char sum=0;
		377	QString localLine = line;
		378	bool ok;
		379	if(localLine.at(0)=='S') // then should skip the first two digits
		380	{
		381	localLine.remove(0,2);
		382	}
		383	for(int i=0;i<localLine.count();i+=2)
		384	{
		385	sum+=(char)(localLine.mid(i,2).toInt(&ok,16));
		386	}
		387	return ~sum;
		388	}
		389
		390	bool srecFile::checkSum(const QString &line)
		391	{
		392	QString scp=line;
		393	scp.remove('\n');
		394	scp.remove('\r');
		395	char ck2 = (char)scp.mid(scp.count()-2,2).toInt(0,16);
		396	char ck=lineCheckSum(scp.remove(scp.count()-2,2));
		397	if(ck==ck2)
		398	{
		399	return true;
		400	}
		401	return false;
		402	// return (ck2==ck);
		403	}
		404
		405
		406	QString srecFile::buildRecord(int recType, int address,const char *data, int size)
		407	{
		408	QString record;
		409	if((recType>=0) && (recType<=9))
		410	{
		411	record.append("S");
		412	record.append(QString::number(recType));
		413	//2 address byte record type
		414	if((recType==0) \|\| (recType==1) \|\| (recType==5) \|\| (recType==9))
		415	{
		416	record.append(QString("%1").arg(3+size,2,16).replace(' ','0'));
		417	record.append(QString("%1").arg(address,4,16).replace(' ','0'));
		418	}
		419	//3 address byte record type
		420	if((recType==2) \|\| (recType==6) \|\| (recType==8))
		421	{
		422	record.append(QString("%1").arg(4+size,2,16).replace(' ','0'));
		423	record.append(QString("%1").arg(address,6,16).replace(' ','0'));
		424	}
		425	//4 address byte record type
		426	if((recType==3) \|\| (recType==7))
		427	{
		428	record.append(QString("%1").arg(5+size,2,16).replace(' ','0'));
		429	record.append(QString("%1").arg(address,8,16).replace(' ','0'));
		430	}
		431	for(int i=0; i<size;i++)
		432	{
		433	record.append(QString("%1").arg((uchar)data[i],2,16).replace(' ','0'));
		434	}
		435	record.append(QString("%1").arg((uchar)srecFile::lineCheckSum(record),2,16).replace(' ','0'));
		436	record.append('\n');
		437	}
		438	return record.toUpper();
		439	}
		440
		441	bool srecFile::mergeFragment(codeFragment fragment, char data, int size)
		442	{
		443	char* mergedData=(char*)malloc(size+fragment->size);
		444	if(mergedData!=NULL)
		445	{
		446	memcpy(mergedData,fragment->data,fragment->size);
		447	memcpy(mergedData+fragment->size,data,size);
		448	free(fragment->data);
		449	free(data);
		450	fragment->data = mergedData;
		451	fragment->size = fragment->size+size;
		452	return true;
		453	}
		454	return false;
		455	}
		456

srec/srecfile.h created 644 +77 0

			@@ -0,0 +1,77
		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 mergingRecords();
		55	void setMergingRecords(bool enabled);
		56	bool isSREC();
		57	static bool isSREC(const QString& File);
		58	static bool checkSum(const QString& line);
		59	signals:
		60
		61	public slots:
		62	private:
		63	void parseFile(QFile* file);
		64	static int parseLine(const QString& record, quint64 address, char* data, quint64 *size);
		65	static char lineCheckSum(const QString& line);
		66	static QString buildRecord(int recType,int address,const char* data,int size);
		67	static bool mergeFragment(codeFragment* fragment, char* data, int size);
		68	QStringList p_fileNames;
		69	QList<QFile*>p_files;
		70	QList<codeFragment*> p_fragments;
		71	int p_lineCount;
		72	bool p_isSrec;
		73	bool p_mergingRecords;
		74
		75	};
		76
		77	#endif // SRECFILE_H

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

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

srec/srecfilewidget.ui created 644 +93 0

			@@ -0,0 +1,93
		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	<attribute name="horizontalHeaderVisible">
		50	<bool>true</bool>
		51	</attribute>
		52	<attribute name="verticalHeaderVisible">
		53	<bool>false</bool>
		54	</attribute>
		55	<column>
		56	<property name="text">
		57	<string>Index</string>
		58	</property>
		59	</column>
		60	<column>
		61	<property name="text">
		62	<string>Address</string>
		63	</property>
		64	</column>
		65	<column>
		66	<property name="text">
		67	<string>Size</string>
		68	</property>
		69	</column>
		70	<column>
		71	<property name="text">
		72	<string>Header</string>
		73	</property>
		74	</column>
		75	</widget>
		76	</item>
		77	</layout>
		78	</widget>
		79	</widget>
		80	</item>
		81	</layout>
		82	</widget>
		83	<customwidgets>
		84	<customwidget>
		85	<class>QHexEdit</class>
		86	<extends>QWidget</extends>
		87	<header location="global">qhexedit.h</header>
		88	<container>1</container>
		89	</customwidget>
		90	</customwidgets>
		91	<resources/>
		92	<connections/>
		93	</ui>

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