Switched to a stronger string hashing function for constants.
string_eq(): test for a == b first.
Use our new standard types for the hash_table_t implementation.

There is no need to define specific hashing function types, key equality
testing types, iterator callback signatures, etc... for all our data
structures now that we have normalized them in "types.h".
Moved position of -lbfd -liberty -lintl ahead of other MinGW libraries.

Apparently, the addition of -lbfd has broken I18N on Windows, although the
reason is not clear.  This move is to try to isolate the problem.
Added XMALLOC() and XMALLOC0() convenience macros.
Added vmm_resize().
Moved symbolic translation of addresses to dedicated lib/symbols.[ch] files.

The lib/stacktrace.c file is now solely concerned with stack unwinding and
printing, but no longer bothers with symbolic translation.
Normalized values for ctz(0) and clz(0).

These values are normally undefined, but we force normalization by defining:

	clz(0) = 32
	ctz(0) = -1

This maintains the expected assertion:

	clz(x) + ctz(x) = 31

for all values.  Of course, we could easily choose the opposite viewpoint
for 0, saying that clz(0) = -1, and this is why the value for 0 is normally
undefined.

Adapted ctz64() to understand our new convention, defining ctz64(0) = -1.
Moved symbol resolution via the BFD library to a dedicated module.

Initially written to assist MinGW debugging in case of a crash, the routines
are actually not MinGW-dependent and therefore have nothing to do with
being implemented in lib/mingw32.c.

Taught metaconfig how to detect the presence of the BFD library at compile
time and regenerated Configure accordingly.
mingw_get_return_address(): was not skipping enough bytes after JMP opcode.

The disassembling code was not correctly skipping the offset/target after
the JMP opcodes, leading to improper routine start recognition in some
circumstances.
mingw_find_esp_subtract(): during analysis, skip filler bytes we can't decode.

When not scanning from the known start of a routine, skip filler bytes that
we don't recognize, since we don't fully disassemble the whole instruction set.
We decide it's a filling byte when we haven't seen any PUSH operation yet.
mingw_find_esp_subtract(): fixed improper decoding of LEA instructions.

Was wrongly using the "source register" bits of the mod byte instead of the
proper "destination register"  bits to derive the instruction length.
Extended the API to allow external construction of the symbol list.
Extended the BFD support to allow section offsetting and nm-like lookups.

On Windows, there are two problems with DLLs:

- They are not necessarily mapped at the static address used by the symbol
  table, so we need to offset these for lookups.  Fortunately, the Windows
  kernel let us know what the base mapping is for the text section.

- Even with proper base offsettting, the debugging entries within the DLL
  are not always providing a routine name from a given symbol address.
  Therefore, use the BFD api to perform a name extraction, sorting the symbols
  in the symbol table and looking them up ourselves.  This cannot provide
  source file locations but at least we are able to get routine names.

This should now allow complete symbolic stack traces on Windows.