@@ -0,0 +1,14 | |||
|
1 | #include "elffilewidget.h" | |
|
2 | #include "ui_elffilewidget.h" | |
|
3 | ||
|
4 | elfFileWidget::elfFileWidget(QWidget *parent) : | |
|
5 | QWidget(parent), | |
|
6 | ui(new Ui::elfFileWidget) | |
|
7 | { | |
|
8 | ui->setupUi(this); | |
|
9 | } | |
|
10 | ||
|
11 | elfFileWidget::~elfFileWidget() | |
|
12 | { | |
|
13 | delete ui; | |
|
14 | } |
@@ -0,0 +1,22 | |||
|
1 | #ifndef ELFFILEWIDGET_H | |
|
2 | #define ELFFILEWIDGET_H | |
|
3 | ||
|
4 | #include <QWidget> | |
|
5 | ||
|
6 | namespace Ui { | |
|
7 | class elfFileWidget; | |
|
8 | } | |
|
9 | ||
|
10 | class elfFileWidget : public QWidget | |
|
11 | { | |
|
12 | Q_OBJECT | |
|
13 | ||
|
14 | public: | |
|
15 | explicit elfFileWidget(QWidget *parent = 0); | |
|
16 | ~elfFileWidget(); | |
|
17 | ||
|
18 | private: | |
|
19 | Ui::elfFileWidget *ui; | |
|
20 | }; | |
|
21 | ||
|
22 | #endif // ELFFILEWIDGET_H |
@@ -0,0 +1,80 | |||
|
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>622</width> | |
|
10 | <height>398</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>General Informations</string> | |
|
34 | </attribute> | |
|
35 | </widget> | |
|
36 | <widget class="QWidget" name="symbolsTab"> | |
|
37 | <attribute name="title"> | |
|
38 | <string>Symbols</string> | |
|
39 | </attribute> | |
|
40 | <layout class="QGridLayout" name="gridLayout_2"> | |
|
41 | <item row="0" column="0"> | |
|
42 | <widget class="QTableWidget" name="symbolsList"/> | |
|
43 | </item> | |
|
44 | </layout> | |
|
45 | </widget> | |
|
46 | <widget class="QWidget" name="sectionsTab"> | |
|
47 | <attribute name="title"> | |
|
48 | <string>Sections</string> | |
|
49 | </attribute> | |
|
50 | <layout class="QGridLayout" name="gridLayout_3"> | |
|
51 | <item row="0" column="0"> | |
|
52 | <widget class="QHexEdit" name="sectionsHexView" native="true"> | |
|
53 | <property name="minimumSize"> | |
|
54 | <size> | |
|
55 | <width>100</width> | |
|
56 | <height>0</height> | |
|
57 | </size> | |
|
58 | </property> | |
|
59 | </widget> | |
|
60 | </item> | |
|
61 | <item row="0" column="1"> | |
|
62 | <widget class="QTableWidget" name="sectionsList"/> | |
|
63 | </item> | |
|
64 | </layout> | |
|
65 | </widget> | |
|
66 | </widget> | |
|
67 | </item> | |
|
68 | </layout> | |
|
69 | </widget> | |
|
70 | <customwidgets> | |
|
71 | <customwidget> | |
|
72 | <class>QHexEdit</class> | |
|
73 | <extends>QWidget</extends> | |
|
74 | <header location="global">qhexedit.h</header> | |
|
75 | <container>1</container> | |
|
76 | </customwidget> | |
|
77 | </customwidgets> | |
|
78 | <resources/> | |
|
79 | <connections/> | |
|
80 | </ui> |
@@ -1,63 +1,38 | |||
|
1 | 1 | /*------------------------------------------------------------------------------ |
|
2 | 2 | -- This file is a part of the SocExplorer Software |
|
3 | 3 | -- Copyright (C) 2014, Plasma Physics Laboratory - CNRS |
|
4 | 4 | -- |
|
5 | 5 | -- This program is free software; you can redistribute it and/or modify |
|
6 | 6 | -- it under the terms of the GNU General Public License as published by |
|
7 | 7 | -- the Free Software Foundation; either version 2 of the License, or |
|
8 | 8 | -- (at your option) any later version. |
|
9 | 9 | -- |
|
10 | 10 | -- This program is distributed in the hope that it will be useful, |
|
11 | 11 | -- but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
12 | 12 | -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
13 | 13 | -- GNU General Public License for more details. |
|
14 | 14 | -- |
|
15 | 15 | -- You should have received a copy of the GNU General Public License |
|
16 | 16 | -- along with this program; if not, write to the Free Software |
|
17 | 17 | -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
|
18 | 18 | -------------------------------------------------------------------------------*/ |
|
19 | 19 | /*-- Author : Alexis Jeandet |
|
20 | 20 | -- Mail : alexis.jeandet@member.fsf.org |
|
21 | 21 | ----------------------------------------------------------------------------*/ |
|
22 | 22 | #include "abstractexecfile.h" |
|
23 | 23 | |
|
24 | 24 | abstractExecFile::abstractExecFile(QObject *parent) : |
|
25 | 25 | QObject(parent) |
|
26 | 26 | { |
|
27 | 27 | } |
|
28 | 28 | |
|
29 | 29 | abstractExecFile::abstractExecFile(const QString &File, QObject *parent) |
|
30 | 30 | { |
|
31 | 31 | |
|
32 | 32 | } |
|
33 | 33 | |
|
34 | bool abstractExecFile::openFile(const QString &File) | |
|
35 | { | |
|
36 | ||
|
37 | } | |
|
38 | ||
|
39 | bool abstractExecFile::isopened() | |
|
40 | { | |
|
41 | ||
|
42 | } | |
|
43 | ||
|
44 | int abstractExecFile::setFilename(const QString &name) | |
|
45 | { | |
|
46 | ||
|
47 | } | |
|
48 | ||
|
49 | int abstractExecFile::closeFile() | |
|
50 | { | |
|
51 | ||
|
52 | } | |
|
53 | ||
|
54 | QList<codeFragment> abstractExecFile::getFragments() | |
|
55 | { | |
|
56 | ||
|
57 | } | |
|
58 | ||
|
59 | 34 | |
|
60 | 35 | codeFragment::codeFragment() |
|
61 | 36 | { |
|
62 | 37 | |
|
63 | 38 | } |
@@ -1,53 +1,54 | |||
|
1 | 1 | /*------------------------------------------------------------------------------ |
|
2 | 2 | -- This file is a part of the SocExplorer Software |
|
3 | 3 | -- Copyright (C) 2014, Plasma Physics Laboratory - CNRS |
|
4 | 4 | -- |
|
5 | 5 | -- This program is free software; you can redistribute it and/or modify |
|
6 | 6 | -- it under the terms of the GNU General Public License as published by |
|
7 | 7 | -- the Free Software Foundation; either version 2 of the License, or |
|
8 | 8 | -- (at your option) any later version. |
|
9 | 9 | -- |
|
10 | 10 | -- This program is distributed in the hope that it will be useful, |
|
11 | 11 | -- but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
12 | 12 | -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
13 | 13 | -- GNU General Public License for more details. |
|
14 | 14 | -- |
|
15 | 15 | -- You should have received a copy of the GNU General Public License |
|
16 | 16 | -- along with this program; if not, write to the Free Software |
|
17 | 17 | -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
|
18 | 18 | -------------------------------------------------------------------------------*/ |
|
19 | 19 | /*-- Author : Alexis Jeandet |
|
20 | 20 | -- Mail : alexis.jeandet@member.fsf.org |
|
21 | 21 | ----------------------------------------------------------------------------*/ |
|
22 | 22 | #ifndef ABSTRACTEXECFILE_H |
|
23 | 23 | #define ABSTRACTEXECFILE_H |
|
24 | 24 | |
|
25 | 25 | #include <QObject> |
|
26 | 26 | |
|
27 | 27 | class codeFragment |
|
28 | 28 | { |
|
29 | 29 | public: |
|
30 | 30 | codeFragment(); |
|
31 | 31 | char* data; |
|
32 | 32 | quint32 size; |
|
33 | 33 | quint32 address; |
|
34 | 34 | }; |
|
35 | 35 | |
|
36 | 36 | class abstractExecFile : public QObject |
|
37 | 37 | { |
|
38 | 38 | Q_OBJECT |
|
39 | 39 | public: |
|
40 | 40 | abstractExecFile(QObject *parent = 0); |
|
41 | 41 | abstractExecFile(const QString& File,QObject *parent = 0); |
|
42 | virtual bool openFile(const QString& File); | |
|
43 | virtual bool isopened(); | |
|
44 |
virtual int se |
|
|
45 | virtual int closeFile(); | |
|
46 | virtual QList<codeFragment> getFragments(); | |
|
42 | virtual bool openFile(const QString& File)=0; | |
|
43 | virtual bool isopened()=0; | |
|
44 | virtual int closeFile()=0; | |
|
45 | virtual QList<codeFragment> getFragments()=0; | |
|
47 | 46 | signals: |
|
48 | 47 | |
|
49 | 48 | public slots: |
|
50 | 49 | |
|
50 | protected: | |
|
51 | QString p_fileName; | |
|
51 | 52 | }; |
|
52 | 53 | |
|
53 | 54 | #endif // ABSTRACTEXECFILE_H |
@@ -1,108 +1,113 | |||
|
1 | 1 | SOCEXPLORER_ROOT = \"$${PWD}/../..\" |
|
2 | 2 | include($${PWD}/../../build_cfg/socexplorer.pri) |
|
3 | 3 | include($${PWD}/lppserial/lppserial.pri) |
|
4 | 4 | |
|
5 | 5 | TEMPLATE = lib |
|
6 | 6 | TARGET = socexplorercommon$${DEBUG_EXT} |
|
7 | 7 | |
|
8 | 8 | win32:CONFIG += dll |
|
9 | 9 | win32:CONFIG -= static |
|
10 | 10 | |
|
11 | 11 | win32:INCLUDEPATH += $${PWD}/elf/libelfWin32/include |
|
12 | 12 | win32:INCLUDEPATH += $${PWD}/elf/libelfWin32/include/libelf |
|
13 | 13 | win32:DEFINES+=_ELF_WINDOWS_ |
|
14 | 14 | DEFINES+=RS232_debug |
|
15 | 15 | |
|
16 | 16 | win32:LIBS += $${PWD}/elf/libelfWin32/bin/libelf.a |
|
17 | 17 | unix:LIBS += -lelf |
|
18 | 18 | |
|
19 | 19 | QMAKE_LFLAGS_RELEASE += --enable-auto-import |
|
20 | 20 | QMAKE_LFLAGS_DEBUG += --enable-auto-import |
|
21 | 21 | |
|
22 | 22 | target.path = $$[QT_INSTALL_LIBS] |
|
23 | 23 | isEmpty(target.path) { |
|
24 | 24 | error(can\'t get QT_INSTALL_LIBS) |
|
25 | 25 | } |
|
26 | 26 | |
|
27 | 27 | header.path = $$[QT_INSTALL_HEADERS]/SocExplorer/common |
|
28 | 28 | header.files = \ |
|
29 | 29 | memsizewdgt.h \ |
|
30 | 30 | qhexspinbox.h \ |
|
31 | 31 | qsvgicon.h \ |
|
32 | 32 | qhexedit/qhexedit_p.h \ |
|
33 | 33 | qhexedit/qhexedit.h \ |
|
34 | 34 | qhexedit/xbytearray.h \ |
|
35 | 35 | QCustomPlot/qcustomplot.h \ |
|
36 | 36 | SocExplorerPlot.h \ |
|
37 | 37 | tcp_terminal_client.h \ |
|
38 | 38 | elf/elfinfowdgt.h \ |
|
39 | 39 | elf/elfparser.h \ |
|
40 | 40 | elf/elffile.h \ |
|
41 | 41 | qipdialogbox.h \ |
|
42 | 42 | lppserial/src/RS232.h |
|
43 | 43 | |
|
44 | 44 | win32{ |
|
45 | 45 | elfheader.path = $$[QT_INSTALL_HEADERS]/SocExplorer/common/libelf |
|
46 | 46 | elfheader.files += \ |
|
47 | 47 | elf/libelfWin32/include/libelf/byteswap.h \ |
|
48 | 48 | elf/libelfWin32/include/libelf/errors.h \ |
|
49 | 49 | elf/libelfWin32/include/libelf/gelf.h \ |
|
50 | 50 | elf/libelfWin32/include/libelf/nlist.h \ |
|
51 | 51 | elf/libelfWin32/include/libelf/sys_elf.h \ |
|
52 | 52 | elf/libelfWin32/include/libelf/verneed.h \ |
|
53 | 53 | elf/libelfWin32/include/libelf/elf_repl.h \ |
|
54 | 54 | elf/libelfWin32/include/libelf/ext_types.h \ |
|
55 | 55 | elf/libelfWin32/include/libelf/libelf.h \ |
|
56 | 56 | elf/libelfWin32/include/libelf/private.h \ |
|
57 | 57 | elf/libelfWin32/include/libelf/verdef.h |
|
58 | 58 | INSTALLS += elfheader |
|
59 | 59 | } |
|
60 | 60 | |
|
61 | 61 | |
|
62 | 62 | isEmpty(header.path) { |
|
63 | 63 | error(can\'t get QT_INSTALL_HEADERS) |
|
64 | 64 | } |
|
65 | 65 | |
|
66 | 66 | INSTALLS += target header |
|
67 | 67 | |
|
68 | 68 | INCLUDEPATH += QCustomPlot qhexedit |
|
69 | 69 | |
|
70 | 70 | HEADERS += \ |
|
71 | 71 | memsizewdgt.h \ |
|
72 | 72 | qhexspinbox.h \ |
|
73 | 73 | qsvgicon.h \ |
|
74 | 74 | qhexedit/qhexedit_p.h \ |
|
75 | 75 | qhexedit/qhexedit.h \ |
|
76 | 76 | qhexedit/xbytearray.h \ |
|
77 | 77 | qhexedit/commands.h \ |
|
78 | 78 | QCustomPlot/qcustomplot.h \ |
|
79 | 79 | tcp_terminal_client.h \ |
|
80 | 80 | elf/elfinfowdgt.h \ |
|
81 | 81 | elf/elfparser.h \ |
|
82 | 82 | abstractexecfile.h \ |
|
83 | 83 | elf/elffile.h \ |
|
84 | 84 | qipdialogbox.h \ |
|
85 | 85 | PySocExplorer.h \ |
|
86 | SocExplorerPlot.h | |
|
86 | SocExplorerPlot.h \ | |
|
87 | elf/elffilewidget.h | |
|
87 | 88 | |
|
88 | 89 | |
|
89 | 90 | SOURCES += \ |
|
90 | 91 | memsizewdgt.cpp \ |
|
91 | 92 | qhexspinbox.cpp \ |
|
92 | 93 | qsvgicon.cpp \ |
|
93 | 94 | qhexedit/qhexedit_p.cpp \ |
|
94 | 95 | qhexedit/qhexedit.cpp \ |
|
95 | 96 | qhexedit/xbytearray.cpp \ |
|
96 | 97 | qhexedit/commands.cpp \ |
|
97 | 98 | QCustomPlot/qcustomplot.cpp \ |
|
98 | 99 | tcp_terminal_client.cpp \ |
|
99 | 100 | elf/elfinfowdgt.cpp \ |
|
100 | 101 | elf/elfparser.cpp \ |
|
101 | 102 | abstractexecfile.cpp \ |
|
102 | 103 | elf/elffile.cpp \ |
|
103 | 104 | qipdialogbox.cpp \ |
|
104 | SocExplorerPlot.cpp | |
|
105 | SocExplorerPlot.cpp \ | |
|
106 | elf/elffilewidget.cpp | |
|
107 | ||
|
108 | FORMS += \ | |
|
109 | elf/elffilewidget.ui | |
|
105 | 110 | |
|
106 | 111 | |
|
107 | 112 | |
|
108 | 113 |
@@ -1,32 +1,104 | |||
|
1 | 1 | /*------------------------------------------------------------------------------ |
|
2 | 2 | -- This file is a part of the SocExplorer Software |
|
3 | 3 | -- Copyright (C) 2014, Plasma Physics Laboratory - CNRS |
|
4 | 4 | -- |
|
5 | 5 | -- This program is free software; you can redistribute it and/or modify |
|
6 | 6 | -- it under the terms of the GNU General Public License as published by |
|
7 | 7 | -- the Free Software Foundation; either version 2 of the License, or |
|
8 | 8 | -- (at your option) any later version. |
|
9 | 9 | -- |
|
10 | 10 | -- This program is distributed in the hope that it will be useful, |
|
11 | 11 | -- but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
12 | 12 | -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
13 | 13 | -- GNU General Public License for more details. |
|
14 | 14 | -- |
|
15 | 15 | -- You should have received a copy of the GNU General Public License |
|
16 | 16 | -- along with this program; if not, write to the Free Software |
|
17 | 17 | -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
|
18 | 18 | -------------------------------------------------------------------------------*/ |
|
19 |
/*-- Author : |
|
|
20 | -- Mail : alexis.jeandet@member.fsf.org | |
|
19 | /*-- Author : | |
|
20 | Alexis Jeandet | |
|
21 | -- Mail : | |
|
22 | alexis.jeandet@member.fsf.org | |
|
21 | 23 | ----------------------------------------------------------------------------*/ |
|
22 | 24 | #include "elffile.h" |
|
23 | 25 | |
|
24 | 26 | ElfFile::ElfFile(QObject *parent) : |
|
25 | 27 | abstractExecFile(parent) |
|
26 | 28 | { |
|
27 | 29 | } |
|
28 | 30 | |
|
29 | 31 | ElfFile::ElfFile(const QString &File, QObject *parent) |
|
32 | :abstractExecFile(parent) | |
|
30 | 33 | { |
|
34 | this->p_fileName = File; | |
|
35 | parser.setFilename(File); | |
|
36 | } | |
|
37 | ||
|
38 | bool ElfFile::openFile(const QString &File) | |
|
39 | { | |
|
40 | this->p_fileName = File; | |
|
41 | parser.setFilename(File); | |
|
42 | } | |
|
43 | ||
|
44 | bool ElfFile::isopened() | |
|
45 | { | |
|
46 | return parser.isopened(); | |
|
47 | } | |
|
48 | ||
|
49 | int ElfFile::closeFile() | |
|
50 | { | |
|
51 | return parser.closeFile(); | |
|
52 | } | |
|
53 | ||
|
54 | QList<codeFragment> ElfFile::getFragments() | |
|
55 | { | |
|
56 | QList<codeFragment> fragments; | |
|
57 | if (parser.isopened()) | |
|
58 | { | |
|
59 | fragments.append(getFragment(".text")); | |
|
60 | fragments.append(getFragment(".data")); | |
|
61 | } | |
|
62 | } | |
|
63 | ||
|
64 | QList<codeFragment> ElfFile::getFragments(QStringList fragmentList) | |
|
65 | { | |
|
66 | QList<codeFragment> fragments; | |
|
67 | if (parser.isopened()) | |
|
68 | { | |
|
69 | for(int i =0;i<fragmentList.count();i++) | |
|
70 | { | |
|
71 | fragments.append(getFragment(fragmentList.at(i))); | |
|
72 | } | |
|
73 | } | |
|
74 | } | |
|
75 | ||
|
76 | codeFragment ElfFile::getFragment(const QString &name) | |
|
77 | { | |
|
78 | codeFragment fragment; | |
|
79 | for(int i=0;i<parser.getSectioncount();i++) | |
|
80 | { | |
|
81 | if(parser.getSectionName(i) == name) | |
|
82 | { | |
|
83 | fragment.data =NULL; | |
|
84 | fragment.size = parser.getSectionDatasz(i); | |
|
85 | fragment.address = parser.getSectionPaddr(i); | |
|
86 | parser.getSectionData(i,&fragment.data); | |
|
87 | } | |
|
88 | } | |
|
31 | 89 | |
|
32 | 90 | } |
|
91 | ||
|
92 | ||
|
93 | ||
|
94 | ||
|
95 | ||
|
96 | ||
|
97 | ||
|
98 | ||
|
99 | ||
|
100 | ||
|
101 | ||
|
102 | ||
|
103 | ||
|
104 |
@@ -1,40 +1,50 | |||
|
1 | 1 | /*------------------------------------------------------------------------------ |
|
2 | 2 | -- This file is a part of the SocExplorer Software |
|
3 | 3 | -- Copyright (C) 2014, Plasma Physics Laboratory - CNRS |
|
4 | 4 | -- |
|
5 | 5 | -- This program is free software; you can redistribute it and/or modify |
|
6 | 6 | -- it under the terms of the GNU General Public License as published by |
|
7 | 7 | -- the Free Software Foundation; either version 2 of the License, or |
|
8 | 8 | -- (at your option) any later version. |
|
9 | 9 | -- |
|
10 | 10 | -- This program is distributed in the hope that it will be useful, |
|
11 | 11 | -- but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
12 | 12 | -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
13 | 13 | -- GNU General Public License for more details. |
|
14 | 14 | -- |
|
15 | 15 | -- You should have received a copy of the GNU General Public License |
|
16 | 16 | -- along with this program; if not, write to the Free Software |
|
17 | 17 | -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
|
18 | 18 | -------------------------------------------------------------------------------*/ |
|
19 | 19 | /*-- Author : Alexis Jeandet |
|
20 | 20 | -- Mail : alexis.jeandet@member.fsf.org |
|
21 | 21 | ----------------------------------------------------------------------------*/ |
|
22 | 22 | #include <abstractexecfile.h> |
|
23 | 23 | #include <elf.h> |
|
24 | #include "elfparser.h" | |
|
25 | #include <QStringList> | |
|
26 | ||
|
24 | 27 | #ifndef ELFFILE_H |
|
25 | 28 | #define ELFFILE_H |
|
26 | 29 | |
|
27 | 30 | class ElfFile : public abstractExecFile |
|
28 | 31 | { |
|
29 | 32 | Q_OBJECT |
|
30 | 33 | public: |
|
31 | 34 | ElfFile(QObject *parent = 0); |
|
32 | 35 | ElfFile(const QString& File,QObject *parent = 0); |
|
33 | ||
|
36 | bool openFile(const QString& File); | |
|
37 | bool isopened(); | |
|
38 | int closeFile(); | |
|
39 | QList<codeFragment> getFragments(); | |
|
40 | QList<codeFragment> getFragments(QStringList fragmentList); | |
|
34 | 41 | signals: |
|
35 | 42 | |
|
36 | 43 | public slots: |
|
44 | private: | |
|
45 | elfparser parser; | |
|
46 | codeFragment getFragment(const QString& name); | |
|
37 | 47 | |
|
38 | 48 | }; |
|
39 | 49 | |
|
40 | 50 | #endif // ELFFILE_H |
@@ -1,701 +1,716 | |||
|
1 | 1 | /*------------------------------------------------------------------------------ |
|
2 | 2 | -- This file is a part of the SocExplorer Software |
|
3 | 3 | -- Copyright (C) 2013, Plasma Physics Laboratory - CNRS |
|
4 | 4 | -- |
|
5 | 5 | -- This program is free software; you can redistribute it and/or modify |
|
6 | 6 | -- it under the terms of the GNU General Public License as published by |
|
7 | 7 | -- the Free Software Foundation; either version 3 of the License, or |
|
8 | 8 | -- (at your option) any later version. |
|
9 | 9 | -- |
|
10 | 10 | -- This program is distributed in the hope that it will be useful, |
|
11 | 11 | -- but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
12 | 12 | -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
13 | 13 | -- GNU General Public License for more details. |
|
14 | 14 | -- |
|
15 | 15 | -- You should have received a copy of the GNU General Public License |
|
16 | 16 | -- along with this program; if not, write to the Free Software |
|
17 | 17 | -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
|
18 | 18 | -------------------------------------------------------------------------------*/ |
|
19 | 19 | /*-- Author : Alexis Jeandet |
|
20 | 20 | -- Mail : alexis.jeandet@lpp.polytechnique.fr |
|
21 | 21 | ----------------------------------------------------------------------------*/ |
|
22 | 22 | #include "elfparser.h" |
|
23 | 23 | #include <sys/types.h> |
|
24 | 24 | #include <sys/stat.h> |
|
25 | 25 | #include <fcntl.h> |
|
26 | 26 | #include <unistd.h> |
|
27 | 27 | |
|
28 |
|
|
|
28 | QString elfresolveMachine(Elf64_Half e_machine) | |
|
29 | 29 | { |
|
30 | ||
|
30 | QString machineName; | |
|
31 | 31 | //Update from with bash script don't write it by yourself! |
|
32 | 32 | switch(e_machine) |
|
33 | 33 | { |
|
34 |
case EM_NONE |
|
|
35 |
|
|
|
34 | case EM_NONE: | |
|
35 | machineName = " No machine "; | |
|
36 | 36 | break; |
|
37 |
case EM_M32 |
|
|
38 |
|
|
|
37 | case EM_M32: | |
|
38 | machineName = " AT&T WE 32100 "; | |
|
39 | 39 | break; |
|
40 |
case EM_SPARC |
|
|
41 |
|
|
|
40 | case EM_SPARC: | |
|
41 | machineName = " SUN SPARC "; | |
|
42 | 42 | break; |
|
43 |
case EM_386 |
|
|
44 |
|
|
|
43 | case EM_386: | |
|
44 | machineName = " Intel 80386 "; | |
|
45 | 45 | break; |
|
46 |
case EM_68K |
|
|
47 |
|
|
|
46 | case EM_68K: | |
|
47 | machineName = " Motorola m68k family "; | |
|
48 | 48 | break; |
|
49 |
case EM_88K |
|
|
50 |
|
|
|
49 | case EM_88K: | |
|
50 | machineName = " Motorola m88k family "; | |
|
51 | 51 | break; |
|
52 |
case EM_860 |
|
|
53 |
|
|
|
52 | case EM_860: | |
|
53 | machineName = " Intel 80860 "; | |
|
54 | 54 | break; |
|
55 |
case EM_MIPS |
|
|
56 |
|
|
|
55 | case EM_MIPS: | |
|
56 | machineName = " MIPS R3000 big-endian "; | |
|
57 | 57 | break; |
|
58 |
case EM_S370 |
|
|
59 |
|
|
|
58 | case EM_S370: | |
|
59 | machineName = " IBM System/370 "; | |
|
60 | 60 | break; |
|
61 |
case EM_MIPS_RS3_LE |
|
|
62 |
|
|
|
61 | case EM_MIPS_RS3_LE: | |
|
62 | machineName = " MIPS R3000 little-endian "; | |
|
63 | 63 | break; |
|
64 |
case EM_PARISC |
|
|
65 |
|
|
|
64 | case EM_PARISC: | |
|
65 | machineName = " HPPA "; | |
|
66 | 66 | break; |
|
67 |
case EM_VPP500 |
|
|
68 |
|
|
|
67 | case EM_VPP500: | |
|
68 | machineName = " Fujitsu VPP500 "; | |
|
69 | 69 | break; |
|
70 |
case EM_SPARC32PLUS |
|
|
71 |
|
|
|
70 | case EM_SPARC32PLUS: | |
|
71 | machineName = " Sun's \"v8plus\" "; | |
|
72 | break; | |
|
73 | case EM_960: | |
|
74 | machineName = " Intel 80960 "; | |
|
72 | 75 | break; |
|
73 |
case EM_ |
|
|
74 |
|
|
|
76 | case EM_PPC: | |
|
77 | machineName = " PowerPC "; | |
|
75 | 78 | break; |
|
76 |
case EM_PPC |
|
|
77 |
|
|
|
79 | case EM_PPC64: | |
|
80 | machineName = " PowerPC 64-bit "; | |
|
78 | 81 | break; |
|
79 |
case EM_ |
|
|
80 | strcpy(MachineName,"PowerPC 64-bit"); | |
|
82 | case EM_S390: | |
|
83 | machineName = " IBM S390 "; | |
|
81 | 84 | break; |
|
82 |
case EM_ |
|
|
83 | strcpy(MachineName,"IBM S390"); | |
|
85 | case EM_V800: | |
|
86 | machineName = " NEC V800 series "; | |
|
84 | 87 | break; |
|
85 |
case EM_ |
|
|
86 | strcpy(MachineName,"NEC V800 series"); | |
|
88 | case EM_FR20: | |
|
89 | machineName = " Fujitsu FR20 "; | |
|
87 | 90 | break; |
|
88 |
case EM_ |
|
|
89 |
|
|
|
91 | case EM_RH32: | |
|
92 | machineName = " TRW RH-32 "; | |
|
90 | 93 | break; |
|
91 |
case EM_R |
|
|
92 | strcpy(MachineName,"TRW RH-32"); | |
|
94 | case EM_RCE: | |
|
95 | machineName = " Motorola RCE "; | |
|
93 | 96 | break; |
|
94 |
case EM_ |
|
|
95 |
|
|
|
97 | case EM_ARM: | |
|
98 | machineName = " ARM "; | |
|
96 | 99 | break; |
|
97 |
case EM_ |
|
|
98 | strcpy(MachineName,"ARM"); | |
|
100 | case EM_FAKE_ALPHA: | |
|
101 | machineName = " Digital Alpha "; | |
|
102 | break; | |
|
103 | case EM_SH: | |
|
104 | machineName = " Hitachi SH "; | |
|
99 | 105 | break; |
|
100 |
case EM_S |
|
|
101 | strcpy(MachineName,"Hitachi SH"); | |
|
106 | case EM_SPARCV9: | |
|
107 | machineName = " SPARC v9 64-bit "; | |
|
102 | 108 | break; |
|
103 |
case EM_ |
|
|
104 | strcpy(MachineName,"SPARC v9 64-bit"); | |
|
109 | case EM_TRICORE: | |
|
110 | machineName = " Siemens Tricore "; | |
|
105 | 111 | break; |
|
106 |
case EM_ |
|
|
107 | strcpy(MachineName,"Siemens Tricore"); | |
|
112 | case EM_ARC: | |
|
113 | machineName = " Argonaut RISC Core "; | |
|
108 | 114 | break; |
|
109 |
case EM_ |
|
|
110 | strcpy(MachineName,"Argonaut RISC Core"); | |
|
115 | case EM_H8_300: | |
|
116 | machineName = " Hitachi H8/300 "; | |
|
111 | 117 | break; |
|
112 |
case EM_H8_300 |
|
|
113 |
|
|
|
118 | case EM_H8_300H: | |
|
119 | machineName = " Hitachi H8/300H "; | |
|
114 | 120 | break; |
|
115 |
case EM_H8 |
|
|
116 |
|
|
|
121 | case EM_H8S: | |
|
122 | machineName = " Hitachi H8S "; | |
|
117 | 123 | break; |
|
118 |
case EM_H8 |
|
|
119 |
|
|
|
124 | case EM_H8_500: | |
|
125 | machineName = " Hitachi H8/500 "; | |
|
120 | 126 | break; |
|
121 |
case EM_ |
|
|
122 | strcpy(MachineName,"Hitachi H8\/500"); | |
|
127 | case EM_IA_64: | |
|
128 | machineName = " Intel Merced "; | |
|
123 | 129 | break; |
|
124 |
case EM_ |
|
|
125 | strcpy(MachineName,"Intel Merced"); | |
|
130 | case EM_MIPS_X: | |
|
131 | machineName = " Stanford MIPS-X "; | |
|
132 | break; | |
|
133 | case EM_COLDFIRE: | |
|
134 | machineName = " Motorola Coldfire "; | |
|
126 | 135 | break; |
|
127 |
case EM_ |
|
|
128 | strcpy(MachineName,"Stanford MIPS-X"); | |
|
136 | case EM_68HC12: | |
|
137 | machineName = " Motorola M68HC12 "; | |
|
129 | 138 | break; |
|
130 |
case EM_ |
|
|
131 | strcpy(MachineName,"Motorola Coldfire"); | |
|
139 | case EM_MMA: | |
|
140 | machineName = " Fujitsu MMA Multimedia Accelerator"; | |
|
132 | 141 | break; |
|
133 |
case EM_ |
|
|
134 | strcpy(MachineName,"Motorola M68HC12"); | |
|
142 | case EM_PCP: | |
|
143 | machineName = " Siemens PCP "; | |
|
135 | 144 | break; |
|
136 |
case EM_ |
|
|
137 | strcpy(MachineName,"Fujitsu MMA Multimedia Accelerator"); | |
|
145 | case EM_NCPU: | |
|
146 | machineName = " Sony nCPU embeeded RISC "; | |
|
138 | 147 | break; |
|
139 |
case EM_ |
|
|
140 | strcpy(MachineName,"Siemens PCP"); | |
|
148 | case EM_NDR1: | |
|
149 | machineName = " Denso NDR1 microprocessor "; | |
|
141 | 150 | break; |
|
142 |
case EM_ |
|
|
143 | strcpy(MachineName,"Sony nCPU embeeded RISC"); | |
|
151 | case EM_STARCORE: | |
|
152 | machineName = " Motorola Start*Core processor "; | |
|
144 | 153 | break; |
|
145 |
case EM_ |
|
|
146 |
|
|
|
154 | case EM_ME16: | |
|
155 | machineName = " Toyota ME16 processor "; | |
|
147 | 156 | break; |
|
148 |
case EM_ST |
|
|
149 |
|
|
|
157 | case EM_ST100: | |
|
158 | machineName = " STMicroelectronic ST100 processor "; | |
|
150 | 159 | break; |
|
151 |
case EM_ |
|
|
152 | strcpy(MachineName,"Toyota ME16 processor"); | |
|
160 | case EM_TINYJ: | |
|
161 | machineName = " Advanced Logic Corp. Tinyj emb.fam"; | |
|
162 | break; | |
|
163 | case EM_X86_64: | |
|
164 | machineName = " AMD x86-64 architecture "; | |
|
153 | 165 | break; |
|
154 |
case EM_ |
|
|
155 |
|
|
|
166 | case EM_PDSP: | |
|
167 | machineName = " Sony DSP Processor "; | |
|
156 | 168 | break; |
|
157 |
case EM_ |
|
|
158 | strcpy(MachineName,"Advanced Logic Corp. Tinyj emb.fam"); | |
|
169 | case EM_FX66: | |
|
170 | machineName = " Siemens FX66 microcontroller "; | |
|
159 | 171 | break; |
|
160 |
case EM_ |
|
|
161 | strcpy(MachineName,"AMD x86-64 architecture"); | |
|
172 | case EM_ST9PLUS: | |
|
173 | machineName = " STMicroelectronics ST9+ 8/16 mc "; | |
|
162 | 174 | break; |
|
163 |
case EM_ |
|
|
164 | strcpy(MachineName,"Sony DSP Processor"); | |
|
175 | case EM_ST7: | |
|
176 | machineName = " STmicroelectronics ST7 8 bit mc "; | |
|
165 | 177 | break; |
|
166 |
case EM_ |
|
|
167 |
|
|
|
178 | case EM_68HC16: | |
|
179 | machineName = " Motorola MC68HC16 microcontroller "; | |
|
168 | 180 | break; |
|
169 |
case EM_ |
|
|
170 | strcpy(MachineName,"STMicroelectronics ST9+ 8\/16 mc"); | |
|
181 | case EM_68HC11: | |
|
182 | machineName = " Motorola MC68HC11 microcontroller "; | |
|
171 | 183 | break; |
|
172 |
case EM_ |
|
|
173 | strcpy(MachineName,"STmicroelectronics ST7 8 bit mc"); | |
|
184 | case EM_68HC08: | |
|
185 | machineName = " Motorola MC68HC08 microcontroller "; | |
|
174 | 186 | break; |
|
175 |
case EM_68HC |
|
|
176 |
|
|
|
187 | case EM_68HC05: | |
|
188 | machineName = " Motorola MC68HC05 microcontroller "; | |
|
177 | 189 | break; |
|
178 |
case EM_ |
|
|
179 | strcpy(MachineName,"Motorola MC68HC11 microcontroller"); | |
|
190 | case EM_SVX: | |
|
191 | machineName = " Silicon Graphics SVx "; | |
|
192 | break; | |
|
193 | case EM_ST19: | |
|
194 | machineName = " STMicroelectronics ST19 8 bit mc "; | |
|
180 | 195 | break; |
|
181 |
case EM_ |
|
|
182 | strcpy(MachineName,"Motorola MC68HC08 microcontroller"); | |
|
196 | case EM_VAX: | |
|
197 | machineName = " Digital VAX "; | |
|
183 | 198 | break; |
|
184 |
case EM_ |
|
|
185 | strcpy(MachineName,"Motorola MC68HC05 microcontroller"); | |
|
199 | case EM_CRIS: | |
|
200 | machineName = " Axis Communications 32-bit embedded processor "; | |
|
186 | 201 | break; |
|
187 |
case EM_ |
|
|
188 | strcpy(MachineName,"Silicon Graphics SVx"); | |
|
202 | case EM_JAVELIN: | |
|
203 | machineName = " Infineon Technologies 32-bit embedded processor "; | |
|
189 | 204 | break; |
|
190 |
case EM_ |
|
|
191 | strcpy(MachineName,"STMicroelectronics ST19 8 bit mc"); | |
|
205 | case EM_FIREPATH: | |
|
206 | machineName = " Element 14 64-bit DSP Processor "; | |
|
192 | 207 | break; |
|
193 |
case EM_ |
|
|
194 | strcpy(MachineName,"Digital VAX"); | |
|
208 | case EM_ZSP: | |
|
209 | machineName = " LSI Logic 16-bit DSP Processor "; | |
|
195 | 210 | break; |
|
196 |
case EM_ |
|
|
197 |
|
|
|
211 | case EM_MMIX: | |
|
212 | machineName = " Donald Knuth's educational 64-bit processor "; | |
|
198 | 213 | break; |
|
199 |
case EM_ |
|
|
200 | strcpy(MachineName,"Infineon Technologies 32-bit embedded processor"); | |
|
214 | case EM_HUANY: | |
|
215 | machineName = " Harvard University machine-independent object files "; | |
|
201 | 216 | break; |
|
202 |
case EM_ |
|
|
203 | strcpy(MachineName,"Element 14 64-bit DSP Processor"); | |
|
217 | case EM_PRISM: | |
|
218 | machineName = " SiTera Prism "; | |
|
204 | 219 | break; |
|
205 |
case EM_ |
|
|
206 | strcpy(MachineName,"LSI Logic 16-bit DSP Processor"); | |
|
220 | case EM_AVR: | |
|
221 | machineName = " Atmel AVR 8-bit microcontroller "; | |
|
222 | break; | |
|
223 | case EM_FR30: | |
|
224 | machineName = " Fujitsu FR30 "; | |
|
207 | 225 | break; |
|
208 |
case EM_ |
|
|
209 | strcpy(MachineName,"Donald Knuth's educational 64-bit processor"); | |
|
226 | case EM_D10V: | |
|
227 | machineName = " Mitsubishi D10V "; | |
|
210 | 228 | break; |
|
211 |
case EM_ |
|
|
212 | strcpy(MachineName,"Harvard University machine-independent object files"); | |
|
229 | case EM_D30V: | |
|
230 | machineName = " Mitsubishi D30V "; | |
|
213 | 231 | break; |
|
214 |
case EM_ |
|
|
215 | strcpy(MachineName,"SiTera Prism"); | |
|
232 | case EM_V850: | |
|
233 | machineName = " NEC v850 "; | |
|
216 | 234 | break; |
|
217 |
case EM_ |
|
|
218 | strcpy(MachineName,"Atmel AVR 8-bit microcontroller"); | |
|
235 | case EM_M32R: | |
|
236 | machineName = " Mitsubishi M32R "; | |
|
219 | 237 | break; |
|
220 |
case EM_ |
|
|
221 |
|
|
|
238 | case EM_MN10300: | |
|
239 | machineName = " Matsushita MN10300 "; | |
|
222 | 240 | break; |
|
223 |
case EM_ |
|
|
224 |
|
|
|
241 | case EM_MN10200: | |
|
242 | machineName = " Matsushita MN10200 "; | |
|
225 | 243 | break; |
|
226 |
case EM_ |
|
|
227 | strcpy(MachineName,"Mitsubishi D30V"); | |
|
244 | case EM_PJ: | |
|
245 | machineName = " picoJava "; | |
|
228 | 246 | break; |
|
229 |
case EM_ |
|
|
230 | strcpy(MachineName,"NEC v850"); | |
|
247 | case EM_OPENRISC: | |
|
248 | machineName = " OpenRISC 32-bit embedded processor "; | |
|
231 | 249 | break; |
|
232 |
case EM_ |
|
|
233 | strcpy(MachineName,"Mitsubishi M32R"); | |
|
250 | case EM_ARC_A5: | |
|
251 | machineName = " ARC Cores Tangent-A5 "; | |
|
234 | 252 | break; |
|
235 |
case EM_ |
|
|
236 | strcpy(MachineName,"Matsushita MN10300"); | |
|
253 | case EM_XTENSA: | |
|
254 | machineName = " Tensilica Xtensa Architecture "; | |
|
237 | 255 | break; |
|
238 |
case EM_ |
|
|
239 | strcpy(MachineName,"Matsushita MN10200"); | |
|
256 | case EM_AARCH64: | |
|
257 | machineName = " ARM AARCH64 "; | |
|
240 | 258 | break; |
|
241 |
case EM_ |
|
|
242 | strcpy(MachineName,"picoJava"); | |
|
259 | case EM_TILEPRO: | |
|
260 | machineName = " Tilera TILEPro "; | |
|
243 | 261 | break; |
|
244 |
case EM_ |
|
|
245 | strcpy(MachineName,"OpenRISC 32-bit embedded processor"); | |
|
262 | case EM_MICROBLAZE: | |
|
263 | machineName = " Xilinx MicroBlaze "; | |
|
246 | 264 | break; |
|
247 |
case EM_ |
|
|
248 | strcpy(MachineName,"ARC Cores Tangent-A5"); | |
|
265 | case EM_TILEGX: | |
|
266 | machineName = " Tilera TILE-Gx "; | |
|
249 | 267 | break; |
|
250 |
case EM_ |
|
|
251 | strcpy(MachineName,"Tensilica Xtensa Architecture"); | |
|
268 | case EM_NUM: | |
|
269 | machineName = ""; | |
|
252 | 270 | break; |
|
253 | 271 | default: |
|
254 |
|
|
|
272 | machineName ="Unknow Machine"; | |
|
255 | 273 | break; |
|
256 | 274 | } |
|
257 | ||
|
275 | return machineName; | |
|
258 | 276 | } |
|
259 | 277 | |
|
260 | 278 | |
|
261 | 279 | elfparser::elfparser() |
|
262 | 280 | { |
|
263 | 281 | this->opened = false; |
|
264 | 282 | this->type_elf = false; |
|
265 | 283 | this->elfFile = NULL; |
|
266 | 284 | this->e = NULL; |
|
267 | 285 | } |
|
268 | 286 | |
|
269 | 287 | |
|
270 | 288 | int elfparser::setFilename(const QString &name) |
|
271 | 289 | { |
|
272 | 290 | this->closeFile(); |
|
273 | 291 | if(elf_version(EV_CURRENT)==EV_NONE)return 0; |
|
274 | 292 | #ifdef _ELF_WINDOWS_ |
|
275 | 293 | this->elfFile = open(name.toStdString().c_str(),O_RDONLY|O_BINARY ,0); |
|
276 | 294 | #else |
|
277 | 295 | this->elfFile = open(name.toStdString().c_str(),O_RDONLY ,0); |
|
278 | 296 | #endif |
|
279 | 297 | if(this->elfFile==NULL)return 0; |
|
280 | 298 | this->e = elf_begin(this->elfFile,ELF_C_READ,NULL); |
|
281 | 299 | if(this->e==NULL)return 0; |
|
282 | 300 | this->ek = elf_kind(this->e); |
|
283 | 301 | gelf_getehdr (this->e, &this->ehdr ); |
|
284 | 302 | elf_getshdrstrndx (this->e, &this->shstrndx); |
|
285 | 303 | this->updateSegments(); |
|
286 | 304 | this->updateSections(); |
|
287 | 305 | return 1; |
|
288 | 306 | } |
|
289 | 307 | |
|
290 | 308 | |
|
291 | 309 | int elfparser::closeFile() |
|
292 | 310 | { |
|
293 | 311 | if(this->elfFile!=NULL) |
|
294 | 312 | { |
|
295 | 313 | if(this->e!=NULL) |
|
296 | 314 | { |
|
297 | 315 | elf_end(this->e); |
|
298 | 316 | this->e = NULL; |
|
299 | 317 | } |
|
300 | 318 | close(this->elfFile); |
|
301 | 319 | this->elfFile = NULL; |
|
302 | 320 | } |
|
303 | 321 | return 0; |
|
304 | 322 | } |
|
305 | 323 | |
|
306 | 324 | |
|
307 | 325 | bool elfparser::isopened() |
|
308 | 326 | { |
|
309 | 327 | return this->opened; |
|
310 | 328 | } |
|
311 | 329 | |
|
312 | 330 | |
|
313 | 331 | bool elfparser::iself() |
|
314 | 332 | { |
|
315 | 333 | return this->type_elf; |
|
316 | 334 | } |
|
317 | 335 | |
|
318 | 336 | |
|
319 | 337 | QString elfparser::getArchitecture() |
|
320 | 338 | { |
|
321 | QString arch(""); | |
|
322 | char archName[256]=""; | |
|
323 | 339 | if(this->e!=NULL) |
|
324 | 340 | { |
|
325 |
elfresolveMachine(this->ehdr.e_machine |
|
|
326 | arch = archName; | |
|
341 | return elfresolveMachine(this->ehdr.e_machine); | |
|
327 | 342 | } |
|
328 |
return |
|
|
343 | return ""; | |
|
329 | 344 | } |
|
330 | 345 | |
|
331 | 346 | |
|
332 | 347 | QString elfparser::getType() |
|
333 | 348 | { |
|
334 | 349 | QString kind(""); |
|
335 | 350 | if(this->e!=NULL) |
|
336 | 351 | { |
|
337 | 352 | switch(this->ek) |
|
338 | 353 | { |
|
339 | 354 | case ELF_K_AR: |
|
340 | 355 | kind = "Archive"; |
|
341 | 356 | break; |
|
342 | 357 | case ELF_K_ELF: |
|
343 | 358 | kind = "Elf"; |
|
344 | 359 | break; |
|
345 | 360 | case ELF_K_COFF: |
|
346 | 361 | kind = "COFF"; |
|
347 | 362 | break; |
|
348 | 363 | case ELF_K_NUM: |
|
349 | 364 | kind = "NUM"; |
|
350 | 365 | break; |
|
351 | 366 | case ELF_K_NONE: |
|
352 | 367 | kind = "Data"; |
|
353 | 368 | break; |
|
354 | 369 | default: |
|
355 | 370 | kind = "Unknow"; |
|
356 | 371 | break; |
|
357 | 372 | } |
|
358 | 373 | } |
|
359 | 374 | return kind; |
|
360 | 375 | } |
|
361 | 376 | |
|
362 | 377 | |
|
363 | 378 | int32_t elfparser::getVersion() |
|
364 | 379 | { |
|
365 | 380 | if(this->e!=NULL) |
|
366 | 381 | { |
|
367 | 382 | return this->ehdr.e_version; |
|
368 | 383 | } |
|
369 | 384 | } |
|
370 | 385 | |
|
371 | 386 | |
|
372 | 387 | int elfparser::getSectioncount() |
|
373 | 388 | { |
|
374 | 389 | return (int)this->SectionCount; |
|
375 | 390 | } |
|
376 | 391 | |
|
377 | 392 | |
|
378 | 393 | int elfparser::getSegmentcount() |
|
379 | 394 | { |
|
380 | 395 | return (int)this->SegmentCount; |
|
381 | 396 | } |
|
382 | 397 | |
|
383 | 398 | |
|
384 | 399 | QString elfparser::getSegmentType(int index) |
|
385 | 400 | { |
|
386 | 401 | QString type(""); |
|
387 | 402 | if(this->e!=NULL) |
|
388 | 403 | { |
|
389 | 404 | if(index < this->Segments.count()) |
|
390 | 405 | { |
|
391 | 406 | switch(this->Segments.at(index)->p_type) |
|
392 | 407 | { |
|
393 | 408 | case PT_NULL: |
|
394 | 409 | type = "Program header table entry unused"; |
|
395 | 410 | break; |
|
396 | 411 | case PT_LOAD: |
|
397 | 412 | type = "Loadable program segment"; |
|
398 | 413 | break; |
|
399 | 414 | case PT_DYNAMIC : |
|
400 | 415 | type = "Dynamic linking information"; |
|
401 | 416 | break; |
|
402 | 417 | case PT_INTERP: |
|
403 | 418 | type ="Program interpreter"; |
|
404 | 419 | break; |
|
405 | 420 | case PT_NOTE: |
|
406 | 421 | type = "Auxiliary information"; |
|
407 | 422 | break; |
|
408 | 423 | case PT_SHLIB: |
|
409 | 424 | type = "Reserved"; |
|
410 | 425 | break; |
|
411 | 426 | case PT_PHDR: |
|
412 | 427 | type = "Entry for header table itself"; |
|
413 | 428 | break; |
|
414 | 429 | case PT_TLS: |
|
415 | 430 | type = "Thread-local storage segment"; |
|
416 | 431 | break; |
|
417 | 432 | case PT_NUM: |
|
418 | 433 | type = "Number of defined types"; |
|
419 | 434 | break; |
|
420 | 435 | case PT_LOOS: |
|
421 | 436 | type = "Start of OS-specific"; |
|
422 | 437 | break; |
|
423 | 438 | case PT_SUNWSTACK: |
|
424 | 439 | type = "Stack segment"; |
|
425 | 440 | break; |
|
426 | 441 | case PT_LOPROC: |
|
427 | 442 | type = "Start of processor-specific"; |
|
428 | 443 | break; |
|
429 | 444 | case PT_HIPROC: |
|
430 | 445 | type = "End of processor-specific"; |
|
431 | 446 | break; |
|
432 | 447 | default: |
|
433 | 448 | type = "Unknow Section Type"; |
|
434 | 449 | break; |
|
435 | 450 | } |
|
436 | 451 | } |
|
437 | 452 | } |
|
438 | 453 | |
|
439 | 454 | return type; |
|
440 | 455 | } |
|
441 | 456 | |
|
442 | 457 | |
|
443 | 458 | int64_t elfparser::getSegmentOffset(int index) |
|
444 | 459 | { |
|
445 | 460 | int64_t Offset; |
|
446 | 461 | if(this->e!=NULL) |
|
447 | 462 | { |
|
448 | 463 | if(index < this->Segments.count()) |
|
449 | 464 | { |
|
450 | 465 | Offset = (int64_t)this->Segments.at(index)->p_offset; |
|
451 | 466 | } |
|
452 | 467 | } |
|
453 | 468 | return Offset; |
|
454 | 469 | } |
|
455 | 470 | |
|
456 | 471 | |
|
457 | 472 | int64_t elfparser::getSegmentVaddr(int index) |
|
458 | 473 | { |
|
459 | 474 | int64_t Vaddr = 0; |
|
460 | 475 | if(this->e!=NULL) |
|
461 | 476 | { |
|
462 | 477 | if(index < this->Segments.count()) |
|
463 | 478 | { |
|
464 | 479 | Vaddr = (int64_t)this->Segments.at(index)->p_vaddr; |
|
465 | 480 | } |
|
466 | 481 | } |
|
467 | 482 | return Vaddr; |
|
468 | 483 | } |
|
469 | 484 | |
|
470 | 485 | |
|
471 | 486 | int64_t elfparser::getSegmentPaddr(int index) |
|
472 | 487 | { |
|
473 | 488 | int64_t Paddr=0; |
|
474 | 489 | if(this->e!=NULL) |
|
475 | 490 | { |
|
476 | 491 | if(index < this->Segments.count()) |
|
477 | 492 | { |
|
478 | 493 | Paddr = (int64_t)this->Segments.at(index)->p_paddr; |
|
479 | 494 | } |
|
480 | 495 | } |
|
481 | 496 | return Paddr; |
|
482 | 497 | } |
|
483 | 498 | |
|
484 | 499 | int64_t elfparser::getSectionPaddr(int index) |
|
485 | 500 | { |
|
486 | 501 | int64_t Paddr=0; |
|
487 | 502 | if(this->e!=NULL) |
|
488 | 503 | { |
|
489 | 504 | if(index < this->sections.count()) |
|
490 | 505 | { |
|
491 | 506 | Paddr = (int64_t)this->sections.at(index)->section_header->sh_addr; |
|
492 | 507 | } |
|
493 | 508 | } |
|
494 | 509 | return Paddr; |
|
495 | 510 | } |
|
496 | 511 | |
|
497 | 512 | |
|
498 | 513 | int64_t elfparser::getSegmentFilesz(int index) |
|
499 | 514 | { |
|
500 | 515 | int64_t FileSz=0; |
|
501 | 516 | if(this->e!=NULL) |
|
502 | 517 | { |
|
503 | 518 | if(index < this->Segments.count()) |
|
504 | 519 | { |
|
505 | 520 | FileSz = (int64_t)this->Segments.at(index)->p_filesz; |
|
506 | 521 | } |
|
507 | 522 | } |
|
508 | 523 | return FileSz; |
|
509 | 524 | } |
|
510 | 525 | |
|
511 | 526 | int64_t elfparser::getSectionDatasz(int index) |
|
512 | 527 | { |
|
513 | 528 | int64_t DataSz=0; |
|
514 | 529 | if(this->e!=NULL) |
|
515 | 530 | { |
|
516 | 531 | if(index < this->sections.count()) |
|
517 | 532 | { |
|
518 | 533 | DataSz = (int64_t)this->sections.at(index)->data->d_size; |
|
519 | 534 | } |
|
520 | 535 | } |
|
521 | 536 | return DataSz; |
|
522 | 537 | } |
|
523 | 538 | |
|
524 | 539 | bool elfparser::getSectionData(int index, char **buffer) |
|
525 | 540 | { |
|
526 | 541 | if(this->e!=NULL) |
|
527 | 542 | { |
|
528 | 543 | if(index < this->sections.count()) |
|
529 | 544 | { |
|
530 | 545 | *buffer = (char *)this->sections.at(index)->data->d_buf; |
|
531 | 546 | return true; |
|
532 | 547 | } |
|
533 | 548 | } |
|
534 | 549 | return false; |
|
535 | 550 | } |
|
536 | 551 | |
|
537 | 552 | |
|
538 | 553 | int64_t elfparser::getSegmentMemsz(int index) |
|
539 | 554 | { |
|
540 | 555 | int64_t MemSz=0; |
|
541 | 556 | if(this->e!=NULL) |
|
542 | 557 | { |
|
543 | 558 | if(index < this->Segments.count()) |
|
544 | 559 | { |
|
545 | 560 | MemSz = (int64_t)this->Segments.at(index)->p_memsz; |
|
546 | 561 | } |
|
547 | 562 | } |
|
548 | 563 | return MemSz; |
|
549 | 564 | } |
|
550 | 565 | |
|
551 | 566 | int64_t elfparser::getSectionMemsz(int index) |
|
552 | 567 | { |
|
553 | 568 | int64_t MemSz=0; |
|
554 | 569 | if(this->e!=NULL) |
|
555 | 570 | { |
|
556 | 571 | if(index < this->sections.count()) |
|
557 | 572 | { |
|
558 | 573 | MemSz = (int64_t)this->sections.at(index)->section_header->sh_size; |
|
559 | 574 | } |
|
560 | 575 | } |
|
561 | 576 | return MemSz; |
|
562 | 577 | } |
|
563 | 578 | |
|
564 | 579 | |
|
565 | 580 | QString elfparser::getSegmentFlags(int index) |
|
566 | 581 | { |
|
567 | 582 | QString flags(""); |
|
568 | 583 | if(this->e!=NULL) |
|
569 | 584 | { |
|
570 | 585 | if(index < this->Segments.count()) |
|
571 | 586 | { |
|
572 | 587 | if((this->Segments.at(index)->p_flags&PF_X) == PF_X)flags+="x"; |
|
573 | 588 | if((this->Segments.at(index)->p_flags&PF_W) == PF_W)flags+="w"; |
|
574 | 589 | if((this->Segments.at(index)->p_flags&PF_R) == PF_R)flags+="r"; |
|
575 | 590 | if((this->Segments.at(index)->p_flags&PF_MASKOS) == PF_MASKOS)flags+=" OS-specific"; |
|
576 | 591 | if((this->Segments.at(index)->p_flags&PF_MASKPROC) == PF_MASKPROC)flags+=" Processor-specific"; |
|
577 | 592 | } |
|
578 | 593 | } |
|
579 | 594 | return flags; |
|
580 | 595 | } |
|
581 | 596 | |
|
582 | 597 | |
|
583 | 598 | QString elfparser::getSectionName(int index) |
|
584 | 599 | { |
|
585 | 600 | char* nameChr = elf_strptr(this->e , this->shstrndx , this->sections.at(index)->section_header->sh_name); |
|
586 | 601 | return QString(nameChr); |
|
587 | 602 | } |
|
588 | 603 | |
|
589 | 604 | |
|
590 | 605 | void elfparser::updateSections() |
|
591 | 606 | { |
|
592 | 607 | for(int i=0;i<this->sections.count();i++) |
|
593 | 608 | { |
|
594 | 609 | delete this->sections.at(i); |
|
595 | 610 | } |
|
596 | 611 | this->sections.clear(); |
|
597 | 612 | this->scn = elf_nextscn (this->e , NULL ); |
|
598 | 613 | this->SectionCount = 0; |
|
599 | 614 | while( this->scn != NULL ) |
|
600 | 615 | { |
|
601 | 616 | GElf_Shdr* shdr = (GElf_Shdr*)malloc(sizeof(GElf_Shdr)); |
|
602 | 617 | gelf_getshdr ( this->scn , shdr ); |
|
603 | 618 | Elf_Data* data = elf_getdata(this->scn, NULL); |
|
604 | 619 | this->sections.append(new Elf_Section(data,shdr)); |
|
605 | 620 | this->SectionCount+=1; |
|
606 | 621 | this->scn = elf_nextscn(e , scn); |
|
607 | 622 | } |
|
608 | 623 | } |
|
609 | 624 | |
|
610 | 625 | |
|
611 | 626 | void elfparser::updateSegments() |
|
612 | 627 | { |
|
613 | 628 | elf_getphdrnum (this->e , &this->SegmentCount); |
|
614 | 629 | for(int i=0;i<this->Segments.count();i++) |
|
615 | 630 | { |
|
616 | 631 | free(this->Segments.at(i)); |
|
617 | 632 | } |
|
618 | 633 | this->Segments.clear(); |
|
619 | 634 | for(int i=0;i<this->SegmentCount;i++) |
|
620 | 635 | { |
|
621 | 636 | GElf_Phdr* header=(GElf_Phdr*)malloc(sizeof(GElf_Phdr)); |
|
622 | 637 | gelf_getphdr (this->e , i , header ); |
|
623 | 638 | this->Segments.append(header); |
|
624 | 639 | } |
|
625 | 640 | } |
|
626 | 641 | |
|
627 | 642 | |
|
628 | 643 | |
|
629 | 644 | |
|
630 | 645 | |
|
631 | 646 | QString elfparser::getSectionType(int index) |
|
632 | 647 | { |
|
633 | 648 | QString type(""); |
|
634 | 649 | if(this->e!=NULL) |
|
635 | 650 | { |
|
636 | 651 | if(index < this->Segments.count()) |
|
637 | 652 | { |
|
638 | 653 | switch(this->Segments.at(index)->p_type) |
|
639 | 654 | { |
|
640 | 655 | case SHT_NULL : type = "Section header table entry unused"; break; |
|
641 | 656 | case SHT_PROGBITS : type = "Program data"; break; |
|
642 | 657 | case SHT_SYMTAB : type = "Symbol table"; break; |
|
643 | 658 | case SHT_STRTAB : type = "String table"; break; |
|
644 | 659 | case SHT_RELA : type = "Relocation entries with addends"; break; |
|
645 | 660 | case SHT_HASH : type = "Symbol hash table"; break; |
|
646 | 661 | case SHT_DYNAMIC : type = "Dynamic linking information"; break; |
|
647 | 662 | case SHT_NOTE : type = "Notes"; break; |
|
648 | 663 | case SHT_NOBITS :type = "Program space with no data (bss)"; break; |
|
649 | 664 | case SHT_REL :type = "Relocation entries, no addends"; break; |
|
650 | 665 | case SHT_SHLIB : type = "Reserved"; break; |
|
651 | 666 | case SHT_DYNSYM : type = "Dynamic linker symbol table"; break; |
|
652 | 667 | case SHT_INIT_ARRAY : type = "Array of constructors"; break; |
|
653 | 668 | case SHT_FINI_ARRAY : type = "Array of destructors"; break; |
|
654 | 669 | case SHT_PREINIT_ARRAY : type = "Array of pre-constructors"; break; |
|
655 | 670 | case SHT_GROUP : type = "Section group"; break; |
|
656 | 671 | case SHT_SYMTAB_SHNDX : type = "Extended section indeces"; break; |
|
657 | 672 | case SHT_NUM : type = "Number of defined types. "; break; |
|
658 | 673 | case SHT_LOOS : type = "Start OS-specific. "; break; |
|
659 | 674 | case SHT_LOSUNW : type = "Sun-specific low bound. "; break; |
|
660 | 675 | case SHT_SUNW_COMDAT : type = " "; break; |
|
661 | 676 | case SHT_SUNW_syminfo : type = " "; break; |
|
662 | 677 | case SHT_GNU_verdef : type = "Version definition section. "; break; |
|
663 | 678 | case SHT_GNU_verneed : type = "Version needs section. "; break; |
|
664 | 679 | case SHT_GNU_versym : type = "Version symbol table. "; break; |
|
665 | 680 | case SHT_LOPROC : type = "Start of processor-specific"; break; |
|
666 | 681 | case SHT_HIPROC : type = "End of processor-specific"; break; |
|
667 | 682 | case SHT_HIUSER : type = "End of application-specific"; break; |
|
668 | 683 | } |
|
669 | 684 | } |
|
670 | 685 | } |
|
671 | 686 | return type; |
|
672 | 687 | } |
|
673 | 688 | |
|
674 | 689 | bool elfparser::isElf(const QString &File) |
|
675 | 690 | { |
|
676 | 691 | int file =0; |
|
677 | 692 | #ifdef _ELF_WINDOWS_ |
|
678 | 693 | file = open(File.toStdString().c_str(),O_RDONLY|O_BINARY ,0); |
|
679 | 694 | #else |
|
680 | 695 | file = open(File.toStdString().c_str(),O_RDONLY ,0); |
|
681 | 696 | #endif |
|
682 | 697 | char Magic[4]; |
|
683 | 698 | if(file!=-1) |
|
684 | 699 | { |
|
685 | 700 | read(file,Magic,4); |
|
686 | 701 | close(file); |
|
687 | 702 | if(Magic[0]==0x7f && Magic[1]==0x45 && Magic[2]==0x4c && Magic[3]==0x46) |
|
688 | 703 | { |
|
689 | 704 | return true; |
|
690 | 705 | } |
|
691 | 706 | } |
|
692 | 707 | return false; |
|
693 | 708 | } |
|
694 | 709 | |
|
695 | 710 | |
|
696 | 711 | |
|
697 | 712 | |
|
698 | 713 | |
|
699 | 714 | |
|
700 | 715 | |
|
701 | 716 |
General Comments 0
You need to be logged in to leave comments.
Login now