NE .EXE new executable file format. More...

#include <neexe.h>

Inheritance diagram for Microsoft::NEFormat:

Classes
class	Entry
	Represents an entry into the binary, typically DLL exported procedures. More...

class	ModuleReference
	Represents an imported module in the module reference table. More...

struct	Name
	A name and ordinal pair, as used for resident and non-resident names. More...

class	Resource
	Represents a resource entry. More...

class	ResourceType
	Windows executables bundle their resources by resource type. More...

class	Segment
	Represents an NE segment as stored in the segment table and segment data. More...

struct	version
	Version number. More...

Public Types
enum	program_flag_type : uint8_t { NODATA = 0 , SINGLEDATA = 1 , MULTIPLEDATA = 2 , GLOBAL_INITIALIZATION = 4 , PROTECTED_MODE_ONLY = 8 , CPU_8086 = 0x10 , CPU_80286 = 0x20 , CPU_80386 = 0x40 , CPU_8087 = 0x80 }

enum	application_flag_type : uint8_t { FULLSCREEN = 1 , GUI_AWARE = 2 , GUI = 3 , FAMILY_APPLICATION = 8 , ERROR_IN_IMAGE = 0x20 , LIBRARY = 0x80 }

enum	system_type : uint8_t { OS2 = 1 , Windows , MSDOS4 , Windows386 , BorlandOSS , PharLap = 0x80 }

enum	additional_flag_type : uint8_t { SUPPORT_LONGFILENAME = 1 , WIN20_PROTECTED_MODE = 2 , WIN20_PROPORTIONAL_FONTS = 4 , FAST_LOAD_AREA = 8 }

enum	memory_model_t { MODEL_SMALL , MODEL_LARGE }

enum	compatibility_type { CompatibleNone , CompatibleWatcom , CompatibleMicrosoft , CompatibleGNU }

Public Member Functions
bool	IsLibrary () const

bool	IsOS2 () const

void	ReadFile (Linker::Reader &rd) override
	Loads file into memory.

offset_t	ImageSize () const override
	Retrieves size of stored data.

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.

	NEFormat (system_type system, unsigned program_flags, unsigned application_flags)

bool	FormatSupportsSegmentation () const override
	Whether the format supports multiple segments.

bool	FormatIs16bit () const override
	Whether the format is 16-bit or not.

bool	FormatSupportsLibraries () const override
	Whether the format supports libraries.

unsigned	FormatAdditionalSectionFlags (std::string section_name) const override

std::shared_ptr< NEFormat >	SimulateLinker (compatibility_type compatibility)

unsigned	GetCodeSegmentFlags () const

unsigned	GetDataSegmentFlags () const

void	AddSegment (const Segment &segment)

uint16_t	FetchModule (std::string name)

uint16_t	FetchImportedName (std::string name)

std::string	MakeProcedureName (std::string name)

uint16_t	MakeEntry (Linker::Position value)

uint16_t	MakeEntry (uint16_t ordinal, Linker::Position value)

uint8_t	CountBundles (size_t entry_index) const

void	SetModel (std::string model) override
	Sets the way memory is organized, typically modifying a built-in script.

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

std::unique_ptr< Script::List >	GetScript (Linker::Module &module)

void	Link (Linker::Module &module)

void	ProcessModule (Linker::Module &module) override
	Processes the module object and initializes format fields.

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.

void	GenerateFile (std::string filename, Linker::Module &module) override
	The main function that handles processing, calculating and generating the final image.

std::string	GetDefaultExtension (Linker::Module &module, std::string filename) const override
	Appends a default extension to the filename.

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.

virtual void	OnNewSegment (std::shared_ptr< Segment > segment)
	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.

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 std::string	GetDefaultExtension (Module &module) const
	Provides a default filename for the output file.

virtual bool	FormatIsLinear () const
	Whether the address space is linear or segmented.

virtual bool	FormatSupportsResources () const
	Whether the format supports resources.

Public Member Functions inherited from Linker::Format
	Format (offset_t file_offset=0)

virtual void	Clear ()
	Resets all fields to their default values, deallocate memory.

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.

Static Public Member Functions
static std::shared_ptr< NEFormat >	CreateConsoleApplication (system_type system=Windows)

static std::shared_ptr< NEFormat >	CreateGUIApplication (system_type system=Windows)

static std::shared_ptr< NEFormat >	CreateLibraryModule (system_type system=Windows)

Public Attributes
std::array< char, 2 >	signature {'N', 'E'}
	The signature, almost always "NE".

version	linker_version {1, 0}
	Version of the linker.

uint32_t	crc32 = 0

program_flag_type	program_flags = program_flag_type(0)
	Properties of the program during execution.

application_flag_type	application_flags = application_flag_type(0)
	Properties of the application.

uint16_t	automatic_data = 0
	Automatic data segment number, starting from 1, only used for SINGLEDATA/MULTIPLEDATA.

uint16_t	stack_size = 0
	Size of initial stack, added to the size of the automatic data segment.

uint16_t	heap_size = 0
	Size of initial heap, added to the size of the automatic data segment.

uint16_t	ip = 0

uint16_t	cs = 0

uint16_t	sp = 0

uint16_t	ss = 0

uint32_t	segment_table_offset = 0
	Offset of segment table.

std::vector< Segment >	segments

uint32_t	resource_table_offset = 0
	Offset of resource table.

uint16_t	resource_count = 0

uint16_t	resource_shift = 0
	Specifies the shift count to get the actual offsets for the resource data.

std::vector< Resource >	resources
	On OS/2, this is a sequence of resources, for non-OS/2 targets, this must be compiled into resource_types.

std::vector< ResourceType >	resource_types
	For non-OS/2 targets, the resources get organized according to their types.

std::vector< std::string >	resource_strings
	For non-OS/2 targets, this is a list of all the resource type strings and resource strings.

uint32_t	resident_name_table_offset = 0
	Offset of resident name table, containing this module's name and the names and ordinals of procedures exported by name.

std::vector< Name >	resident_names

uint32_t	module_reference_table_offset = 0
	Offset of module reference table, containing 16-bit offsets to the names of the imported modules in the imported names table.

std::vector< ModuleReference >	module_references

uint32_t	imported_names_table_offset = 0
	Offset of imported names table, containing the names of imported modules and procedures imported by name.

std::vector< std::string >	imported_names

uint32_t	nonresident_name_table_offset = 0
	Offset of non-resident names table, containing this module's description and the names of procedures exported by ordinal.

uint32_t	nonresident_name_table_length = 0

std::vector< Name >	nonresident_names

uint32_t	entry_table_offset = 0
	Offset of entry table.

uint32_t	entry_table_length = 0
	Size of entry table in bytes.

uint16_t	movable_entry_count = 0
	Number of movable entries in the entry table.

std::vector< Entry >	entries

uint16_t	sector_shift = 9
	Specifies the shift count to get the actual offsets of segments.

system_type	system = system_type(0)

additional_flag_type	additional_flags = additional_flag_type(0)

union {

uint16_t fast_load_area_offset

uint16_t return_thunks_offset

};

union {

uint16_t fast_load_area_length

uint16_t segment_reference_thunks_offset

};

uint16_t	code_swap_area_length = 0

version	windows_version {0, 0}

offset_t	file_size = offset_t(-1)

MZStubWriter	stub

std::shared_ptr< Linker::Segment >	stack

std::shared_ptr< Linker::Segment >	heap

std::map< std::shared_ptr< Linker::Segment >, size_t >	segment_index

std::map< std::string, uint16_t >	module_reference_offsets

std::map< std::string, uint16_t >	imported_name_offsets

uint16_t	imported_names_length = 0

std::string	module_name

std::string	program_name

bool	option_capitalize_names = false

memory_model_t	memory_model = MODEL_SMALL

compatibility_type	compatibility = CompatibleNone

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.

Public Attributes inherited from Linker::Format
offset_t	file_offset

Additional Inherited Members
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

NE .EXE new executable file format.

A segmented 16-bit format First introduced for Windows, it supported multiple segments, resources, dynamic libraries among others. It was later also adopted for the following targets:

16-bit Windows applications
16-bit OS/2 applications
a Multitasking variant of MS-DOS referred to as European MS-DOS 4.0

Member Enumeration Documentation

◆ application_flag_type

enum Microsoft::NEFormat::application_flag_type : uint8_t

Enumerator
FULLSCREEN	Application can only run in full screen mode. This is typically the case for programs that directly access video memory
GUI_AWARE	Application is well behaved when running in windowed mode. This is typically the case for programs that are text/console only but use BIOS and/or DOS calls to access the screen, as these can be translated by the system to windowing functions
GUI	Graphical application.
LIBRARY	Set for library modules (DLL)

◆ program_flag_type

enum Microsoft::NEFormat::program_flag_type : uint8_t

Enumerator

NODATA

There are no automatic data segments.

SINGLEDATA

There is a single, shared automatic segment, used for libraries (DLL)

       Cannot be set with MULTIPLEDATA at the same time

MULTIPLEDATA

There is an automatic data segment for each task instance, used for applications (EXE)

       Cannot be set with SINGLEDATA at the same time

◆ system_type

enum Microsoft::NEFormat::system_type : uint8_t

Enumerator
OS2	Used for OS/2 1.0 - 1.3.
Windows	Used for Windows 1.0 - 3.11.
MSDOS4	Signifies Multitasking MS-DOS 4.0.

Member Function Documentation

◆ CalculateValues()

void NEFormat::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 Linker::OutputFormat.

◆ Dump()

void NEFormat::Dump ( Dumper::Dumper & dump ) const

overridevirtual

Display file contents in a nice manner.

Reimplemented from Linker::Format.

◆ FormatAdditionalSectionFlags()

unsigned NEFormat::FormatAdditionalSectionFlags ( std::string section_name ) const

overridevirtual

Reimplemented from Linker::OutputFormat.

◆ FormatIs16bit()

bool NEFormat::FormatIs16bit ( ) const

overridevirtual

Whether the format is 16-bit or not.

This is needed for the ELF parser which can not distinguish between the 8086 and 80386 backends.

Reimplemented from Linker::OutputFormat.

◆ FormatSupportsLibraries()

bool NEFormat::FormatSupportsLibraries ( ) const

overridevirtual

Whether the format supports libraries.

Reimplemented from Linker::OutputFormat.

◆ FormatSupportsSegmentation()

bool NEFormat::FormatSupportsSegmentation ( ) const

overridevirtual

Whether the format supports multiple segments.

This is typically true for Intel 8086 targets and false for non-Intel targets. The ELF parser uses this to provide extended relocations, including the following:

$$SEG$<section name>
$$SEGOF$<symbol name>
$$SEGAT$<symbol name>
$$WRTSEG$<symbol name>$<section name>
$$SEGDIF$<section name>$<section name>

Reimplemented from Linker::OutputFormat.

◆ GenerateFile()

void NEFormat::GenerateFile	(	std::string	filename,
		Linker::Module &	module )

overridevirtual

The main function that handles processing, calculating and generating the final image.

Reimplemented from Linker::OutputFormat.

◆ GetDefaultExtension()

std::string NEFormat::GetDefaultExtension	(	Linker::Module &	module,
		std::string	filename ) const

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 Linker::OutputFormat.

◆ ImageSize()

offset_t NEFormat::ImageSize ( ) const

overridevirtual

Retrieves size of stored data.

Reimplemented from Linker::Format.

◆ ProcessModule()

void NEFormat::ProcessModule ( Linker::Module & object )

overridevirtual

Processes the module object and initializes format fields.

Reimplemented from Linker::OutputFormat.

◆ ReadFile()

void NEFormat::ReadFile ( Linker::Reader & rd )

overridevirtual

Loads file into memory.

Implements Linker::Format.

◆ SetModel()

void NEFormat::SetModel ( std::string model )

overridevirtual

Sets the way memory is organized, typically modifying a built-in script.

Reimplemented from Linker::OutputFormat.

◆ SetOptions()

void NEFormat::SetOptions ( std::map< std::string, std::string > & options )

overridevirtual

Passes command line parameters as settings over to format object.

Reimplemented from Linker::OutputFormat.

◆ WriteFile()

offset_t NEFormat::WriteFile ( Linker::Writer & wr ) const

overridevirtual

Stores data in memory to file.

Implements Linker::Format.