]> git.kernelconcepts.de Git - karo-tx-uboot.git/blob - tools/elftosb/common/ELFSourceFile.h
merged tx6dl-devel into denx master branch
[karo-tx-uboot.git] / tools / elftosb / common / ELFSourceFile.h
1 /*
2  * File:        ELFSourceFile.h
3  *
4  * Copyright (c) Freescale Semiconductor, Inc. All rights reserved.
5  * See included license file for license details.
6  */
7 #if !defined(_ELFSourceFile_h_)
8 #define _ELFSourceFile_h_
9
10 #include "SourceFile.h"
11 #include "StELFFile.h"
12 #include "smart_ptr.h"
13 #include "DataSource.h"
14 #include "DataTarget.h"
15 #include "ELF.h"
16
17 namespace elftosb
18 {
19
20 //! Set of supported compiler toolsets.
21 enum elf_toolset_t
22 {
23         kUnknownToolset,        //!< Unknown.
24         kGHSToolset,            //!< Green Hills Software MULTI
25         kGCCToolset,            //!< GNU GCC
26         kADSToolset                     //!< ARM UK RealView
27 };
28
29 //! Options for handling the .secinfo section in GHS-produced ELF files.
30 enum secinfo_clear_t
31 {
32         // Default value for the .secinfo action.
33         kSecinfoDefault,
34
35         //! Ignore the .secinfo section if present. The standard ELF loading
36         //! rules are followed.
37         kSecinfoIgnore,
38
39         //! The boot ROM clears only those SHT_NOBITS sections present in .secinfo.
40         kSecinfoROMClear,
41         
42         //! The C startup is responsible for clearing sections. No fill commands
43         //! are generated for any SHT_NOBITS sections.
44         kSecinfoCStartupClear
45 };
46
47 /*!
48  * \brief Executable and Loading Format (ELF) source file.
49  */
50 class ELFSourceFile : public SourceFile
51 {
52 public:
53         //! \brief Default constructor.
54         ELFSourceFile(const std::string & path);
55         
56         //! \brief Destructor.
57         virtual ~ELFSourceFile();
58         
59         //! \brief Identifies whether the stream contains an ELF file.
60         static bool isELFFile(std::istream & stream);
61         
62         //! \name Opening and closing
63         //@{
64         //! \brief Opens the file.
65         virtual void open();
66         
67         //! \brief Closes the file.
68         virtual void close();
69         //@}
70         
71         //! \name Format capabilities
72         //@{
73         virtual bool supportsNamedSections() const { return true; }
74         virtual bool supportsNamedSymbols() const { return true; }
75         //@}
76         
77         //! \name Data source
78         //@{
79         //! \brief Creates a data source from the entire file.
80         virtual DataSource * createDataSource();
81         
82         //! \brief Creates a data source from one or more sections of the file.
83         virtual DataSource * createDataSource(StringMatcher & matcher);
84         //@}
85         
86         //! \name Entry point
87         //@{
88         //! \brief Returns true if an entry point was set in the file.
89         virtual bool hasEntryPoint();
90         
91         //! \brief Returns the entry point address.
92         virtual uint32_t getEntryPointAddress();
93         //@}
94         
95         //! \name Data target
96         //@{
97         virtual DataTarget * createDataTargetForSection(const std::string & section);
98         virtual DataTarget * createDataTargetForSymbol(const std::string & symbol);
99         //@}
100         
101         //! \name Symbols
102         //@{
103         //! \brief Returns whether a symbol exists in the source file.
104         virtual bool hasSymbol(const std::string & name);
105         
106         //! \brief Returns the value of a symbol.
107         virtual uint32_t getSymbolValue(const std::string & name);
108         
109         //! \brief Returns the size of a symbol.
110         virtual unsigned getSymbolSize(const std::string & name);
111         //@}
112         
113         //! \name Direct ELF format access
114         //@{
115         //! \brief Returns the underlying StELFFile object.
116         StELFFile * getELFFile() { return m_file; }
117         
118         //! \brief Gets information about a symbol in the ELF file.
119         bool lookupSymbol(const std::string & name, Elf32_Sym & info);
120         //@}
121
122 protected:
123         smart_ptr<StELFFile> m_file;    //!< Parser for the ELF file.
124         elf_toolset_t m_toolset;        //!< Toolset that produced the ELF file.
125         secinfo_clear_t m_secinfoOption;        //!< How to deal with the .secinfo section. Ignored if the toolset is not GHS.
126
127 protected:
128         //! \brief Parses the toolset option value.
129         elf_toolset_t readToolsetOption();
130
131         //! \brief Reads the secinfoClear option.
132         secinfo_clear_t readSecinfoClearOption();
133         
134 protected:
135         /*!
136          * \brief A data source with ELF file sections as the contents.
137          *
138          * Each segment of this data source corresponds directly with a named section
139          * of the ELF file it represents. When the data source is created, it contains
140          * no segments. Segments are created with the addSection() method, which takes
141          * the index of an ELF section and creates a corresponding segment.
142          *
143          * Two segment subclasses are used with this data source. The first, ProgBitsSegment,
144          * is used to represent sections whose type is #SHT_PROGBITS. These sections have
145          * binary data stored in the ELF file. The second segment type is NoBitsSegment.
146          * It is used to represent sections whose type is #SHT_NOBITS. These sections have
147          * no data, but simply allocate a region of memory to be filled with zeroes.
148          * As such, the NoBitsSegment class is a subclass of DataSource::PatternSegment.
149          */
150         class ELFDataSource : public DataSource
151         {
152         public:
153                 /*!
154                  * \brief Represents one named #SHT_PROGBITS section within the ELF file.
155                  */
156                 class ProgBitsSegment : public DataSource::Segment
157                 {
158                 public:
159                         ProgBitsSegment(ELFDataSource & source, StELFFile * elf, unsigned index);
160                         
161                         virtual unsigned getData(unsigned offset, unsigned maxBytes, uint8_t * buffer);
162                         virtual unsigned getLength();
163                 
164                         virtual bool hasNaturalLocation() { return true; }
165                         virtual uint32_t getBaseAddress();
166                 
167                 protected:
168                         StELFFile * m_elf;      //!< The format parser instance for this ELF file.
169                         unsigned m_sectionIndex;        //!< The index of the section this segment represents.
170                 };
171                 
172                 /*!
173                  * \brief Represents one named #SHT_NOBITS section within the ELF file.
174                  *
175                  * This segment class is a subclass of DataSource::PatternSegment since it
176                  * represents a region of memory to be filled with zeroes.
177                  */
178                 class NoBitsSegment : public DataSource::PatternSegment
179                 {
180                 public:
181                         NoBitsSegment(ELFDataSource & source, StELFFile * elf, unsigned index);
182                         
183                         virtual unsigned getLength();
184                 
185                         virtual bool hasNaturalLocation() { return true; }
186                         virtual uint32_t getBaseAddress();
187                 
188                 protected:
189                         StELFFile * m_elf;      //!< The format parser instance for this ELF file.
190                         unsigned m_sectionIndex;        //!< The index of the section this segment represents.
191                 };
192                 
193         public:
194                 //! \brief Default constructor.
195                 ELFDataSource(StELFFile * elf) : DataSource(), m_elf(elf) {}
196                 
197                 //! \brief Destructor.
198                 virtual ~ELFDataSource();
199
200                 //! Set the option to control .secinfo usage.
201                 inline void setSecinfoOption(secinfo_clear_t option) { m_secinfoOption = option; }
202                 
203                 //! \brief Adds the ELF section at position \a sectionIndex to the data source.
204                 void addSection(unsigned sectionIndex);
205                 
206                 //! \brief Returns the number of segments in the source.
207                 virtual unsigned getSegmentCount() { return (unsigned)m_segments.size(); }
208                 
209                 //! \brief Returns the segment at position \a index.
210                 virtual DataSource::Segment * getSegmentAt(unsigned index) { return m_segments[index]; }
211                 
212         protected:
213                 StELFFile * m_elf;      //!< The ELF file parser.
214                 secinfo_clear_t m_secinfoOption;        //!< How to deal with the .secinfo section. Ignored if the toolset is not GHS.
215                 
216                 typedef std::vector<DataSource::Segment*> segment_vector_t;     //!< A list of segment instances.
217                 segment_vector_t m_segments;    //!< The segments of this data source.
218         };
219
220 };
221
222 }; // namespace elftosb
223
224 #endif // _ELFSourceFile_h_