ReleaseNotes.txt

parity is an open source project who's goal is to ease porting applications
from UNIX-like systems to Windows. It relies on the presence of a UNIX Layer
for Windows such as Interix or Cygwin. parity is most tested on x86_64 Cygwin,
so it will work there best.

parity uses the Microsoft Toolchain - like cl.exe, link.exe, etc. - to mimic a
GCC like interface, while really compiling natively for Windows. This results
in pure and native Windows Libraries and Executables, which can be mixed
freely with any existing Software pieces.

The most effort has been put into shared library handling, which now behaves
nearly the same as on common UNIX-like systems. There also is a patch for
libtool, which makes it know about parity (which passes almost all tests of
the libtool test-suite). Advanced Features like a working -rpath option have
been added to improve the handling of DLLs on Windows, but they were not
ported to x86_64 MSVC, and were not really necessary, so these have been
removed in parity 2.0.0 release.

parity ships with a little runtime enhancement library called parity.runtime.
This library abstracts away the need to take care of what kind of paths are
used. This means you can now give a UNIX-style path to an executable built
with parity, and it will understand it. Previously this was not possible, and
all Windows executables would need Windows-style paths to work.

parity 2.0.3
------------

Support up to Visual Studio 2022 (MSVC 17)


parity 2.0.2
------------

implemented --help


parity 2.0.1
------------

Sync libtool patches to what is currently used at SSI.

parity 2.0.0
------------

Support up to Visual Studio 2019 (MSVC 16), and Visual Studio Build Tools.

Drop support for Visual Studio 2003 and older.  Visual Studio 2005 (MSVC 8.0)
is the oldest one that still does run on Windows 10.

Support x86_64 (64bit) MSVC Toolchain.

Switch to Cygwin as build system, Interix and MSVC are unlikely to still work.

Use host triplet to identify the local MSVC Toolchain arch and version to be
used, and also to distinguish the MSVC runtime library variant.  For example:
 32bit (x86) dynamic multithreaded runtime: i686-msvc16-winnt
 32bit (x86) static multithreaded runtime: i686-libcmt-winnt
 64bit (x64) dynamic multithreaded debug runtime: x86_64-msvcd16-winnt
 64bit (x64) static multithreaded debug runtime: x86_64-libcmtd16-winnt

Create symbolic links to MSVC import libraries, to avoid path components being
invalid as shell string (containing blanks or parentheses), for when the 8dot3
filename generation is disabled on the underlying file system.

Identify available Visual Studio or Build Tools instances using the registry
(pre VC15) or vswhere.exe (since VC15) rather than environment variables.

Provide environment values to be used when using MSVC toolchain without
parity, using the "parity-setup --get-environ i686-msvc16-winnt" command.

Disable concept of default MSVC versions, is hard to maintain. You always have
to use an MSVC version as part of the CHOST value.

Toolchain wrappers are installed as real executables, so the can run even from
within native Win32 build systems.

Support binary packaging of parity (using DESTDIR). Compiling the runtime libs
requiring local MSVC is done using the new parity-setup script after install.

Provide more POSIX/MinGW based wrappers: cpp, nm, strip (as noop), windres.

Provide more MSVC based wrappers (cmd, dumpbin, lib, nmake, rc), for build
systems that know about the MS toolchain when available via env vars.

Provide libtool patches, creating NAME.lib as the import library along
NAME.dll, and creating libNAME.lib as the static library.  This implies
searching for NAME.lib upon the -lNAME linker option.

Support distinct binary packages per CHOST value, to have parity-setup enable
or disable installed CHOST values only rather than all the compiled in ones.
To be enabled using the --enable-binpkg-per-chost configure option.

Provide an exemplary parity.cygport, for building Cygwin binary packages.

parity.runtime: Stop switching stdio to binmode, almost everyone does expect 
and can handle textmode with native winnt programs these days.

parity.runtime: Try to run cygpath from PATH for path conversion rather than
trying to dynamically load cygwin1.dll.

parity.runtime: Provide stdint.h, not available in older MSVC versions.

parity.runtime: Provide stdbool.h, not available before VS 2012.

parity.runtime: Provide stdarg.h, lacks va_copy() before VS 2012.

parity.runtime: Switch to StackWalk64 API when creating a backtrace.

parity.runtime: Have pid_t of type int, to allow for using pthreads4w
(https://sourceforge.net/projects/pthreads4w/).

parity.runtime: Provide clock_gettime(), wrapping timespec_get().

parity.loader: Stop caching dll handles. Provide dlclose() instead.

parity.gnu.gcc: Support the -include file option.

parity.gnu.gcc: Support --define, --undefine options.

parity.gnu.gcc: Support -std=c++XX and -ansi compiler options.

parity.gnu.gcc: Distinguish -Dmacro (value 1) from -Dmacro= (empty value).

parity.gnu.gcc: Distinguish --version from -v compiler option.

parity.gnu.gcc: Support -dumpmachine, -dumpversion, -print-prog-name,
-print-search-dirs commandline options.

parity.gnu.gcc: Improve support for assembly (.S) files.

parity.gnu.ld: Support Module Definition (.def) files when linking.

parity.gnu.ld: Support -Wl,--out-implib linker flag.

parity.gnu.ld: Upon -lNAME, search for NAME.dll.lib, as created by MinGW.

parity.gnu.as: Relax from /Cp to /Cx assembler (ml.exe) flag.

parity.gnu.as: Run C preprocessor before assembling, the preprocessor
available within ml.exe uses a different syntax.

parity.ms.cl: Distinguish /c from /cygdrive/path compiler arguments.

parity 1.3.0
------------

This release adds support for REX (https://github.com/mduft/rex). This allows to run parity on a Linux host to compile windows binaries remotely on a windows box.

parity 1.2.7
------------

parity.runtime: greatly improve exception handling, both for SEH and (especially) C++

parity.runtime: introduce new entry point wrapper that wraps application code into the new exception handling

parity.runtime: introduce "safer" version of strftime - don't choke on zeroe'd out struct tm

parity.runtime: add invalid parameter handler for C-runtime which gives console feedback.

Add required code to generate "better" entry point code that forwards initialization to the new PcrtCxxEhStartup

parity 1.2.6
------------

parity.runtime: Terminate process on fatal exceptions caught by parity.

parity.runtime: Stop backtrace generation on obviously invalid stack pointer.

parity.runtime: Stop backtrace generation at a depth of 100.

parity.runtime: Reorder contents of core file, to be more readable hopefully.

Stop matching ".a.c" or "x.a.c" and similar filenames as ".a"-argument.


parity 1.2.5
------------

Add support for legacy Visual Studio 2005, but with static runtime only.

parity.ms.cl.exe, parity.ms.link.exe: Support '@filename' commandline argument, for 'filename' containing additional commandline arguments.

parity.ms.cl.exe, parity.ms.link.exe: Accept '/EH' (exception handling) and '/GR' (runtime types) commandline argument.

parity.ms.cl.exe: Accept /LD and /LDd instead of /DLL to link a dll.

parity.ms.cl.exe: Wrap VC-headers without _POSIX_ being defined.

Ignore case when searching for implicit libraries (/DEFAULTLIB directive), using lowercase by "C" locale.

Identify duplicate /DEFAULTLIB directives by the directive value, not the complete resolved library filename. Have seen this improving link speed by a factor of 10 here.

Fix handling of /NODEFAULTLIB directive to actually ignore specified default libraries.

Dynamically load procedures for exception handling from kernel32.dll to allow binaries built with up to Visual Studio 2005 to actually run on Windows NT, where those procedures are missing.

List loaded modules to core-file when available (not on Windows NT).

Reorder ReleaseNotes to have most recent version first.


parity 1.2.4
------------

fixed crash with empty archives, and nameless archive members.

added support for visual studio 2010.

fixed library searching during command line parsing, which mistakingly ignored library paths set in the configuration files.

increased value of _WIN32_WINNT from 0x0400 (Windows NT 4.0) to 0x0501 (Windows XP), which was the minimum supported windows version anyway.

fixed linking against various different CRT versions (the static ones especially).


parity 1.2.3
------------

changed the behaviour regarding configuration-set include and library paths; configuration set paths are appended in the order of appearance in the file to the set of command line set paths in their order of appearance on the command line.

after failing to link, stray files are cleaned up properly now.

fixed a bug making the linker find a directory instead of a file while looking up libraries.

added support for reading source files from stdin. any valid source file can be passed via stdin by passing the "-" argument to parity. this only works if parity operates using the GCC type frontend.

parity.inspector has been extended with the --raw option, which allows to output information about a shared library in a more machine readable fashion. initially required to more easely implement the preserve-libs feature of portage for native windows.

added missing extern C in sys/time.h, fixing gettimeofday for C++ users.

made the dynamic loader a little less loud, when it fails to preload a library. this is required, since windows executables fail to preload interix libraries, which use the same variable.


parity 1.2.2
------------

colorization of output in all parity executables is now controlled by the output stream type (terminal, file, etc.)

some general cleanup removed dead code.

disable stream buffers on stdout and stderr in windows executables. parity may implement line buffering in the future (which is missing on native windows).


parity 1.2.1
------------

fixed handling of frame pointer omission setting.

fixed a problem in the loader when passing NULL to dlopen.

added a little profiling information to the loader, telling the number of milliseconds it took to load all childs.

parity.inspector has been improved, and now defaults to a more ldd like interface.

parity.inspector now knows about native libraries, not linked with parity.

parity.loader has a much improved loading failure output, which allows for much easier isolation of the real loading problem for shared libraries.

parity.inspector verbose processing status output is now much more readable.

parity.runtime doesn't allow for more than 3 nested exceptions before doing a hard exit. in previous versions exceptions kept flying until stack space was too low.

parity.inspector has now a much improved memory utilization and overal performance.


parity 1.2.0
------------

fixed a bug which caused parity to be unable to link binaries including the custom loader. there where too many underscores added to the entry point symbol name.

fixed a bug which caused shared libraries to bypass the entry point required for the custom loader, which resulted in crashes at runtime, since symbols had faulty addresses.

added support for files with unknown extensions. any unknown argument is now processed a second time, to see wether it could be an input file. depending on the current mode, the file is assumed to be a source file (compile mode, preprocess mode), or an object file (link mode).

added support for overriding the dll name of shared libraries linked with the GNU frontend. when /OUT: is found somewhere in the linker pass throughs (pass with -Y), /OUT: is not added to the link command explicitly.

added debugging support functions to parity.runtime, allowing to easily add code to make a process wait for a debugger to be attached, or break at a specified statement.

added parity.diagnostic, which in fact is a micro-debugger, which can start a process with itself attached. while the started process is executed normally, parity.diagnostic catches and processes various debug events and messages, and displays them on the console. future plans include function call tracing (when debug information is present), etc.

the default parity.conf now sets the WIN32_LEAN_AND_MEAN define.

made the dlopen function a little more intelligent, making it now search for .dll files too.

corrected the expansion of define values given on the command line, so that the percent character ("%") is escaped correctly before beeing passed to cl.exe.

corrected code that reads environment variables in the loader to ignore variables that are set but empty.

be default, no longer link executables with fixed base addresses, but relocateable to allow purifying. this makes executables unsignificantly slower. This can be overridden using the "LinkerDefaults" setting in any parity configuration file.

a lot of test cases have been added to the testsuite, to guarantee better code quality.

updated some internal classes to provide some more detailed output in verbose mode, and to provide better/more stable functionality.

errors in the threading classes don't immediately exit parity, but rather throw exceptions as they should.

the timing information is no longer displayed if no timing records are available.

parity now ignores libraries not built by himself while gathering symbols to be loaded through the generated loader.

fixed a bug in the directive section processing of object files, which could have caused crashes, since string offsets were calculated wrong.

fixed a bug which could crash the routine responsible for colorizing the output of a task.

made testsuite output more readable.

fixed a memory leak in the binary file handling code, which could have resulted in out of memory conditions when linking very many files.

fixed a problem in the exception base class which could have caused memory leaks.

fixed a bug in the external task execution code, which resulted in a handle leak, leaving pipes open after the task finished.

fixed various compiler warnings.

made parity compile with gcc's -pedantic switch. also some -Wall -Wextra warnings have been fixed.

made parity compile wihtout warnings with gcc's -Weffc++ option enabled. this assures much better overal code quality.

optimized parity source code and resulting binaries, by removing functions which are not currently required, but take up a lot of space.

replaced old-style (C-style) casts in all the source code with the correct C++ cast equivalents.

fixed a few warnings that occured when building core parity libraries with /W4 in visual studio.

parity now generates a symbol table for every linked binary (can be disabled). this means that the images get a little larger on disk. this should have a minimal impact on loading times (in the range of a few microseconds), but no other disadvantages.

added capabilities to create stacktraces of the running program, and for fixed EIP/EBP register pairs as one can obtain from exception records.

added capabilities to get symbol information for a certain address. this finds the nearest symbol at an address lower than the given one. of course this can report wrong symbol names if the given address is inside a static symbol for example, for which no symbolic information is stored in the symbol tables.

added capabilities to parity.runtime to handle exceptions the way other Unices do, and write a "core" file (plain text) instead of showing a messagebox.

all parity built images now set the mode for stdin/out/err to _O_BINARY for compatability with other Unices.

added the configuration option to disable the generation of the so called PcrtInitEntry function which initializes the new exception handling mechanism and sets stream and error handling modes described above.

changed lots of include directives in parity.runtime to use some uppercase letters to avoid clashes with defines.

added an implementation for the gettimeofday function, which is missing in windows.

added the capability to parse configuration directives directly from command line arguments, which makes it possible to influence all possible internals of parity per call.

parity-built binaries don't support windows 2000 any longer, because of the new features built into them. those binaries may still work on windows 2000 if new features are disabled.

added exception tracing capabilities to parity.runtime. this feature can be eneabled by setting the environment variable PCRT_TRACE_EXCEPTIONS to either any number, "on", "yes", or any filename where the information should be written to instead of stderr.

added debug symbol handling capabilities to parity.runtime for exception handling and tracing. to enable set the environment variable to PCRT_DEBUG_SYMBOLS to any value. be aware the binaries have to be built debugable for this to work. also the dbghel.dll has to be present an recent enough. in contrary to this mode, the internal symbol resolution works also with release builds and is faster, but is less accurate.

parity now knows how to handle SIGPIPE correctly; all child processes are now terminated, instead of keeping them running, while parity dies. this solves issues with file handles staying open in child processes, blocking those files for new processes. this happend for example if doing "parity.gnu.gcc -E <somefile>.c | head". this still does not work in the win32 version of parity, since there is no easy way of detecting a broken pipe on win32 with C++ streams.

forcing inline function expansion with -finline-functions now works as expected. previously inline expansion was only enabled, when the optimization level was greater than zero.

fixed the -fno-ms-extensions switch, which was not working correctly.

fixed the -fno-rtti switch, which was not working correctly.

fixed the -ffor-scope switch, which was not working correctly.

fixed the -fshort-wchar switch, which was not working correctly.

fixed the -fsyntax switch, which was not working correctly.

the parity.doc documentation project has been added, which provides thorough descriptions of configuration and command line switches, also including some information about the internal workings of parity.

not finding one of the executable (assembler, compiler, linker, manifest tool) during configure, is no longer fatal. also the checks for this executables at runtime have been moved to right before using them, so a missing assembler is now ok, as long as you don't try to assemble something.

fixed a problem with, which caused structures to be misaligned in some parts of parity when using gcc 4.2, causing parity.inspector to crash on import table reads.

parity no longer generates things required for the generated loader, if there are zero symbols to load.

changed parts of the parity.runtime library to use internal output routines in favor of fprintf, to assure full functionality even when calling those functions while initializing binaries, where standard handled may not yet be initialized.

the ignorance of foreign libraries is now configurable through the IgnoreForeignLibs configuration directive.


parity 1.1.0
------------

fixed a bug, which made parity crash, if a file given to the dependency tracker had exactly the size of a page in memory.

parity now allows passing .res files through to the compiler/linker.

The search order for libraries has been corrected. Previously parity would look for all possible names of a library in each directory before advancing to the next one. The new (and correct) behaviour is, to look for each possible library name in each directory, before advancing to the next best library name.

Using the preload feature of parity binaries with an interix library set in LD_PRELOAD made parity crash in previous versions. This has been fixed. Since interix Libraries are still valid windows binaries, loading them succeeds, but no symbols are found to preload. This could still cause troubles in special cases.

Resolved some internal inter-library dependency mess, which caused too many libraries to be linked, even if the parity loader was not generated. Path conversion has been moved to the runtime library to achieve this.

The Configuration loading code has been extended to support profiles. This way multiple configurations can be saved to a single file. The Graphical Configurator has been updated to be able to read such files, but cannot write them (yet) due to architectural limitations.

Added internal capabilities and configuration profiles to support compiling of POSIX subsystem and MixedMode Interix applications. This has the great advantage over gcc, that the result can be debugged in Visual Studio, rather than gdb. The main difference to native Windows builds is the dependency to the SUA subsystem, and the use of the POSIX libc (and thus the availablility of fork(), etc.). The full POSIX mode does not support C++ or shared libraries. The MixedMode does not (yet) support C++, but shared libraries work.


parity 1.0.6
------------

corrected a spelling mistake, which made parity ignore LD_LIBRARY_PATH.

Slightly adjusted the output of the -v switch, to identify the platform parity was built on/for, since now the windows version is not so easily distinguishable from the interix version.

When automatically exporting symbols from an object file, ignore symbols which where introduced by the compiler for strings. All symbols starting with (mangled) ??_C@ are now ignored.


parity 1.0.5
------------

fixed support for Interix 6.0. Support for Visual Studio 2008 tested.

Migrated Project Files and Solutions to Visual Studio 2008.

Enabled color support for native windows builds, if it is built using autotools (i.e. build parity with itself).

Parity no longer decides wether certain paths are "bad", like /usr/local. This fixes issues with a Gentoo Prefix installation.

Fixed the -O switches, which had no effect until now. Now proper optimizations are performed by the target compiler.

Added an x86 binary decoder to support fixing certain instructions at link time. Insertion of instructions in unlinked code is now fully supported. This is the basic building block for beeing able to avoid the __declspec(dllimport)'s. The plan is, to fix every instruction that accesses a global data symbol to use a symbol that possibly comes from a DLL by adding an additional indirection. There is still lot of work to be done, since every x86 instruction that can access such a global data symbol (every instruction that can take an address as operand) needs to be recognized and patched.


parity 1.0.4
------------

added propper support for the RTLD_NOW flag in dlopen.

added supporting patches for a lot of packages. these patches are not all required for a working environment, but make live easier. each of the patches need to be applied to the respective packages before building and installing them. some patches might require a re-bootstrap of the respective package.

path conversion using the cygwin dll has been fixed to only initialize the dll once.

fixed the parsing of PATH style environment variables while creating caches for the dynamic loader.


parity 1.0.3
------------

Configuration File lookup and loading has been reviewed. now it is possible to load partial configuration files, which only contain additions to an allready loaded one.

Fixed an issue, where parity would use a lot of CPU time, while waiting for external tasks.

Added support for Visual Studio 2008 (allthough not throughout tested yet).

The parity.loader allways logs to debug output (using OutputDebugStringA). This can be monitored using a tool like the DbgView utility from SysInternals.

Minor improvements to parity.runtime made the whole package behave better with existing code.

Added support for Cygwin (not throughout tested yes). See the wiki http://parity.wiki.sourceforge.net/Building+parity+from+Cygwin on how to install, and http://parity.wiki.sourceforge.net/HowTo+Use+parity+and+libtool+together on how to use parity.
Cygwin support was also added to the native Windows build of parity. This means, that you can build parity using cl.exe (instead of gcc) and still be able to use parity inside cygwin with full patch conversion capabilities.

Added a new graphical configuration editor, writte in managed C++. This has it's own configuration inside the solution, since it need to build parity.utils as managed code.

Fixed an issue, where the -rpath option was not recognized correctly.

Fixed an issue, where the loader would output junk to the console.

Fixed an issue, where the order of option recognition made parity fail to recognize some options correctly

The Libtool 1.5.24 patch (contained within the parity package in parity.patches) has been reviewed, and now only supports parity if the host is i586-pc-winnt (really *-*-winnt*).


parity 1.0.2
------------

This release fixes minor issues with Visul Studio .NET 2003. It also introduces a brand new statistic collection mechanism, which allows for much more informations to be collected during a parity run. To enable statistics collection, simply add a line containing "StatisticsFile=/path/to/stat.file" to your parity.conf.

parity now supports setting the Stack and Heap reserve and commit sizes via configuration.


parity 1.0.1
------------

This intermediate release fixes path conversion issues in the parity.runtime. now the functions chdir, mkdir, rmdir, all spawn and all exec support on-the-fly path conversion from Interix to Windows correctly.

There is a new WIKI available on how to build parity at http://parity.wiki.sourceforge.net/Building+parity+from+Interix


parity 1.0.0
------------

This is the initial Release of parity, which offers feature completeness in regard to it's predecessor WGCC.