parity: 1.2.0 released

parity is an open source project who's goal it 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 Microsofts Subsystem for UNIX-based Applications, so it will work there best.

parity uses Microsoft Tools - 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 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.

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 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.

Posted by Markus Duft 2008-10-28