Microsoft PE .EXE portable executable file format. More...
#include <peexe.h>
Inheritance diagram for Microsoft::PEFormat:
Classes | |
| class | PEOptionalHeader |
Public Member Functions | |
| void | ReadFile (Linker::Reader &rd) override |
| Loads file into memory. | |
| void | CalculateValues () override |
| Intermediate step between processing module and generating output file to set up headers and management sections It is expected that after a module is processed, additional steps are required to evaluate the final values of the fields. | |
| offset_t | WriteFile (Linker::Writer &wr) const override |
| Stores data in memory to file. | |
| void | Dump (Dumper::Dumper &dump) const override |
| Display file contents in a nice manner. | |
| std::string | GetDefaultExtension (Linker::Module &module, std::string filename) const override |
| Appends a default extension to the filename. | |
 Public Member Functions inherited from COFF::COFFFormat | |
| ::EndianType | GetEndianType () const |
| Retrieves the natural byte order for the architecture. | |
| void | Clear () override |
| Resets all fields to their default values, deallocate memory. | |
| void | AssignMagicValue () |
| bool | DetectCpuType (::EndianType expected) |
| void | DetectCpuType () |
| offset_t | ImageSize () const override |
| Retrieves size of stored data. | |
| void | SetupOptions (std::shared_ptr< Linker::OutputFormat > format) override |
| Initializes the reader for linking purposes. | |
| bool | FormatRequiresDataStreamFix () const override |
| Whether the generated file might contain bugs that require fixing. | |
| void | GenerateModule (Linker::Module &module) const override |
| Loads the information into a module object, a convenience method when there is a single module generated. | |
| COFFFormat (format_type type=GENERIC, COFFVariantType coff_variant=COFF) | |
| unsigned | FormatAdditionalSectionFlags (std::string section_name) const override |
| void | SetOptions (std::map< std::string, std::string > &options) override |
| Passes command line parameters as settings over to format object. | |
| void | OnNewSegment (std::shared_ptr< Linker::Segment > segment) override |
| Callback function when allocating a new segment When the linker script runs, it creates segments consecutively. Overriding this method permits the output format to handle the allocated segment. | |
| void | CreateDefaultSegments () |
| std::unique_ptr< Script::List > | GetScript (Linker::Module &module) |
| void | Link (Linker::Module &module) |
| std::shared_ptr< Linker::Segment > | GetSegment (std::unique_ptr< Section > §ion) |
| Return the segment stored inside the section, note that this only works for binary generation. | |
| std::shared_ptr< Linker::Segment > | GetCodeSegment () |
| std::shared_ptr< Linker::Segment > | GetDataSegment () |
| std::shared_ptr< Linker::Segment > | GetBssSegment () |
| void | ProcessModule (Linker::Module &module) override |
| Processes the module object and initializes format fields. | |
| void | GenerateFile (std::string filename, Linker::Module &module) override |
| The main function that handles processing, calculating and generating the final image. | |
| Public Member Functions inherited from Linker::InputFormat | |
| virtual void | ProduceModule (ModuleCollector &linker, Reader &rd, std::string file_name) |
| Reads a file and loads the information into a module object. | |
| virtual void | ProduceModule (Module &module, Reader &rd) |
| Reads a file and loads the information into a module object, a convenience method when there is a single module generated. | |
| virtual void | GenerateModule (ModuleCollector &linker, std::string file_name, bool is_library=false) const |
| Loads the information into a module object. | |
| virtual bool | FormatProvidesSegmentation () const |
| Whether the format enables multiple x86 segments. | |
| virtual bool | FormatProvidesResources () const |
| Whether the format supports resources. | |
| virtual bool | FormatProvidesLibraries () const |
| Whether the format enables importing/exporting libraries. | |
| Public Member Functions inherited from Linker::Format | |
| Format (offset_t file_offset=0) | |
| offset_t | ImageSize () const override |
| Retrieves size of stored data. | |
| offset_t | WriteFile (Writer &wr, offset_t count, offset_t offset=0) const override |
| Writes data of non-zero filled sections. | |
| Public Member Functions inherited from Linker::Image | |
| virtual std::shared_ptr< const ActualImage > | AsImage () const |
| Retrieves a randomly accessible image. | |
| std::shared_ptr< ActualImage > | AsImage () |
| Retrieves a randomly accessible image. | |
| Public Member Functions inherited from Linker::SegmentManager | |
| void | ClearSegmentManager () |
| void | SetLinkScript (std::string script_file, std::map< std::string, std::string > &options) override |
| Sets up the linker script and linker parameters. | |
| std::unique_ptr< Script::List > | GetScript (Module &module) |
| Compiles the linker script into an internal format. | |
| offset_t | GetCurrentAddress () const |
| Retrieves current address pointer. | |
| void | SetCurrentAddress (offset_t address) |
| Moves the current address pointer further, and if the current segment already contains data, fill it up to the point. | |
| void | AlignCurrentAddress (offset_t align) |
| Aligns current address to alignment, using SetCurrentAddress. | |
| void | SetLatestBase (offset_t address) |
| Sets the base of the current section (the value from which offsets are counted from) | |
| void | FinishCurrentSegment () |
| Closes the current segment, sets current_segment to null. | |
| std::shared_ptr< Segment > | AppendSegment (std::string name) |
| Terminates the current segment (if there is one), creates a new segment and attaches it to the image. | |
| std::shared_ptr< Segment > | FetchSegment (std::string name) |
| Attempts to fetch a segment, returns null if not found. | |
| void | AppendSection (std::shared_ptr< Section > section) |
| Adds a new section to the current segment, sets the base to the same as the segment. | |
| void | ProcessScript (std::unique_ptr< Script::List > &directives, Module &module) |
| Executes a parsed linker script on a module and collects segments The function OnNewSegment can be defined to handle each newly allocated segment. | |
| void | ProcessAction (std::unique_ptr< Script::Node > &action, Module &module) |
| void | PostProcessAction (std::unique_ptr< Script::Node > &action, Module &module) |
| void | ProcessCommand (std::unique_ptr< Script::Node > &command, Module &module) |
| bool | CheckPredicate (std::unique_ptr< Script::Node > &predicate, std::shared_ptr< Section > section, Module &module) |
| offset_t | EvaluateExpression (std::unique_ptr< Script::Node > &expression, Module &module) |
| Public Member Functions inherited from Linker::OutputFormat | |
| virtual bool | AddSupplementaryOutputFormat (std::string subformat) |
| If the output format actually drives multiple output formats (resource file, apple double, etc.), specify multiple types, return false if unknown. | |
| std::optional< std::string > | FetchOption (std::map< std::string, std::string > &options, std::string name) |
| Convenience method to look up option by name. | |
| std::string | FetchOption (std::map< std::string, std::string > &options, std::string name, std::string default_value) |
| Convenience method to look up option by name, returning default value if name is missing. | |
| std::optional< offset_t > | FetchIntegerOption (std::map< std::string, std::string > &options, std::string name) |
| Convenience method to look up option by name and convert it to integer. | |
| virtual void | SetModel (std::string model) |
| Sets the way memory is organized, typically modifying a built-in script. | |
| virtual std::string | GetDefaultExtension (Module &module) const |
| Provides a default filename for the output file. | |
| virtual bool | FormatSupportsSegmentation () const |
| Whether the format supports multiple segments. | |
| virtual bool | FormatIs16bit () const |
| Whether the format is 16-bit or not. | |
| virtual bool | FormatIsLinear () const |
| Whether the address space is linear or segmented. | |
| virtual bool | FormatSupportsResources () const |
| Whether the format supports resources. | |
| virtual bool | FormatSupportsLibraries () const |
| Whether the format supports libraries. | |
Public Attributes | |
| char | pe_signature [4] |
| MZStubWriter | stub |
| Public Attributes inherited from COFF::COFFFormat | |
| offset_t | file_size |
| char | signature [2] = { } |
| The actual value of the magic number (COFF name: f_magic) | |
| std::vector< std::unique_ptr< Section > > | sections |
| The list of COFF sections. | |
| uint16_t | section_count = 0 |
| Section count (COFF name: f_nscns) | |
| uint32_t | timestamp = 0 |
| Time stamp, unused (COFF name: f_timdat) | |
| offset_t | symbol_table_offset = 0 |
| Offset to the first symbol (COFF name: f_symptr) | |
| uint32_t | symbol_count = 0 |
| The number of symbols (COFF name: f_nsyms) | |
| std::vector< std::unique_ptr< Symbol > > | symbols |
| The symbols stored inside the COFF file. | |
| uint32_t | optional_header_size = 0 |
| The size of the optional header (COFF: f_opthdr) | |
| uint16_t | flags = 0 |
| COFF flags, such as whether the file is executable (f_flags) | |
| std::unique_ptr< OptionalHeader > | optional_header = nullptr |
| The optional header instance used for reading/writing the COFF file. | |
| std::map< uint32_t, size_t > | relocations |
| Concurrent DOS 68K requires a special block of data to represent "crunched" relocations (see CPM68KWriter for more details) | |
| COFFVariantType | coff_variant = COFFVariantType(0) |
| cpu | cpu_type = CPU_UNKNOWN |
| The CPU type, reflected by the first 16-bit word of a COFF file. | |
| ::EndianType | endiantype = ::UndefinedEndian |
| The byte order. | |
| bool | option_segmentation = false |
| Microsoft::MZSimpleStubWriter | stub |
| format_type | type = GENERIC |
| A representation of the format to generate. | |
| bool | option_no_relocation = false |
| Suppress relocation generation, only relevant for Concurrent DOS 68K, since the other target formats do not store relocations. | |
| uint32_t | stub_size = 0 |
| Size of MZ stub, only used for DJGPP COFF executables. | |
| std::shared_ptr< Linker::Segment > | stack |
| Concurrent DOS 68K and FlexOS 386: The stack segment, not stored as part of any section. | |
| uint32_t | entry_address = 0 |
| Entry address, gets stored in optional header later. | |
| uint32_t | relocations_offset = 0 |
| Concurrent DOS 68K: Offset to relocations. | |
| Public Attributes inherited from Linker::Format | |
| offset_t | file_offset |
| Public Attributes inherited from Linker::SegmentManager | |
| offset_t | current_base = 0 |
| The base address of the current section. | |
| std::vector< std::shared_ptr< Segment > > | segment_vector |
| Ordered sequence of segments. | |
| std::map< std::string, std::shared_ptr< Segment > > | segment_map |
| Map of segments from their names. | |
| std::shared_ptr< Segment > | current_segment |
| Currently processed segment. | |
| std::map< std::string, Location > | linker_parameters |
| Parameters that permit customizing the linker script. | |
| std::string | linker_script |
| Contents of the linker script. | |
Protected Member Functions | |
| void | ReadOptionalHeader (Linker::Reader &rd) |
| Protected Member Functions inherited from COFF::COFFFormat | |
| void | ReadCOFFHeader (Linker::Reader &rd) |
| void | ReadOptionalHeader (Linker::Reader &rd) |
| void | ReadRestOfFile (Linker::Reader &rd) |
| offset_t | WriteFileContents (Linker::Writer &wr) const |
Additional Inherited Members | |
| Public Types inherited from COFF::COFFFormat | |
| enum | cpu { CPU_UNKNOWN = 0 , CPU_I386 = 0x014C , CPU_M68K = 0x0150 , CPU_W65 = 0x6500 , CPU_Z80 = 0x805A , CPU_Z8K = 0x8000 , CPU_I86 = 0x0148 , CPU_NS32K = 0x0154 , CPU_I370 = 0x0158 , CPU_MIPS = 0x0160 , CPU_M88K = 0x016D , CPU_WE32K = 0x0170 , CPU_VAX = 0x0178 , CPU_AM29K = 0x017A , CPU_ALPHA = 0x0183 , CPU_PPC = 0x01DF , CPU_PPC64 = 0x01F7 , CPU_SHARC = 0x521C , CPU_I860 = 0x014D , CPU_SH = 0x01A2 , CPU_ARM = 0x01C0 , CPU_AM33 = 0x01D3 , CPU_IA64 = 0x0200 , CPU_HPPA = 0x0290 , CPU_EFI = 0x0EBC , CPU_RISCV32 = 0x5032 , CPU_RISCV64 = 0x5064 , CPU_RISCV128 = 0x5128 , CPU_AMD64 = 0x8664 , CPU_M32R = 0x9041 , CPU_ARM64 = 0xAA64 } |
| Represents the first 16-bit word of a COFF file. More... | |
| enum | COFFVariantType { COFF = 1 , ECOFF = 2 , XCOFF32 = 3 , XCOFF64 = 4 , PECOFF = 5 } |
| enum | format_type { GENERIC , DJGPP , CDOS68K , CDOS386 } |
| Represents the type of target system, which will determine the CPU type and several other fields. More... | |
| enum | { FLAG_NO_RELOCATIONS = 0x0001 , FLAG_EXECUTABLE = 0x0002 , FLAG_NO_LINE_NUMBERS = 0x0004 , FLAG_NO_SYMBOLS = 0x0008 , FLAG_32BIT_LITTLE_ENDIAN = 0x0100 , FLAG_32BIT_BIG_ENDIAN = 0x0200 , ZMAGIC = 0x010B } |
| COFF file header flags, most of these are obsolete, we only use them as precombined flag sets. More... | |
| Static Public Member Functions inherited from COFF::COFFFormat | |
| static std::shared_ptr< COFFFormat > | CreateWriter (format_type type) |
| Static Public Attributes inherited from COFF::COFFFormat | |
| static const std::map< uint32_t, MachineType > | MACHINE_TYPES |
| Protected Attributes inherited from Linker::SegmentManager | |
| offset_t | current_address = 0 |
| Holds the current address value when there is no current_segment. | |
| bool | current_is_template = false |
| bool | current_is_template_head = false |
| offset_t | template_counter = 0 |
| std::string | current_template_name |
Detailed Description
Microsoft PE .EXE portable executable file format.
Member Function Documentation
◆ CalculateValues()
|
overridevirtual |
Intermediate step between processing module and generating output file to set up headers and management sections It is expected that after a module is processed, additional steps are required to evaluate the final values of the fields.
Reimplemented from COFF::COFFFormat.
◆ Dump()
|
overridevirtual |
Display file contents in a nice manner.
Reimplemented from COFF::COFFFormat.
◆ GetDefaultExtension()
|
overridevirtual |
Appends a default extension to the filename.
A typical behavior would be to append .exe at the end of the filename. The default action is to leave it intact.
Reimplemented from COFF::COFFFormat.
◆ ReadFile()
|
overridevirtual |
Loads file into memory.
Reimplemented from COFF::COFFFormat.
◆ WriteFile()
|
overridevirtual |
Stores data in memory to file.
Reimplemented from COFF::COFFFormat.
The documentation for this class was generated from the following files:
- src/format/peexe.h
- src/format/peexe.cc
