Re-enabled exception debug message with custom prefix to collect data on
benchmarks

This reverts commit dc3415be.

The new analysis excludes indirect jumps (like `jmp rax`) from the
candidates `ret` instructions, by checking that the store on the `pc`
global variable comes from `rsp` (x86 return address on stack).

Disable the harvesting of function symbols from debug symbols to run
spec benchmarks.

Disable the call to exception warning during tests.

`BinaryFile::readRawValue` scans the segment list to identify which
segment contains a certain address. However, it was failing if the
target address was in `.bss`, i.e., the portion of a segment after
`p_filesz` but `before `p_memsz`.

This commit lets `BinaryFile::readRawValue` return 0 in that situation.

Fixes for the following things that caused errors in the translated
module due to changes introduced in the `prune-eh` optimization pass:

- `Support.c` is now compiled with support for exceptions, to avoid
  marking the `raise_exception_helper` function to be marked `unwind`
  during the link phase.
- Added a fake `ret` at the end of the `catchblock` to avoid
  optimizations.
- Marked the `invoke` instructions not as candidate for function
inlining.

`revcc` is a simple script that forwards its arguments to a specified
compiler, except in the case in which the compiler is asked to link the
final program. In such case, the compiler is invoked as appropriate, but
the resulting binary is then translated using rev.ng and replaced by the
translated version.

Fix for a situation where the fallthrough basic block of an instruction
calling a helper function is not in an executable segment and therefore
not created.

Quick fix to detect overflow in SET interval computation.

This commit fixes a huge performance issue due to performing a orphan
basic block cleanup every time `JumpTargetManager::peek` was called
instead of only when actual harvesting was required.

Now using the `root` function of the cloned module as a starting point
for the isolation process.

In this way we can ignore the old module, and in particular we can
drop the `ModuleCloningVMap`, a giant map that was used to keep the
match between old and new global objects and was used in the instruction
cloning phase.

Also changed the creation of the trampoline for the isolated function,
using a new basic block and later purging all the unreachable basic
blocks in the `root` function.

Moved the definition of `OBJ` before its first use.

Moved the definition of `CSV` outside the lifting scope, to avoid
erroneous behaviors when invoking the script with the `-s` option.

This commit uses SET, information about canonical values and labels to
detect if an indirect function call is targeting an external symbol.

The strings used for the name of external symbols are uniqued global
variables. This commit also uses this approach for the disassembly of
original instructions, which used to be metadata.

So far we've been tracking only base-relative relocations in an ad-hoc
fashion. This commit introduces a data structure that can describe the
most common relocations, including those for `.got`, `.got.plt`,
base-relative and `R_*_COPY`.

A label describes a range of the binary. A label can be generated from a
symbol (basically assigning a name to range of the binary) or from a
relocation, describing the content of a certain range.

This commit generates labels from symbols and relocations, including
MIPS implicit relocations.

This commit also introduces canonical values.

A register can have a canonical value, i.e., a value that register will
assume when the analyzed module is being run. This is typically useful
for the value of the global pointer, which is different from one module
to another but, within a module, is stable.

This commit registers the canonical value of `gp` (in MIPS), if
available.

`segments_count` provides a way for the runtime to know how many
executable segments the original program had. This is used to implement
the `is_executable` function.

While the `segment_boundaries` contained only the executable segments,
`segments_count` included non-executable segments too, leading to an
out-of-bound read which sometimes led to a spurious `Unknown PC` error.

While translating the code, it might happen that a basic block needs to
be splitted and the second part to be revisited. In such cases, the
second part is register for being "purged" at the next iteration.

Translation failed if we met such a basic block before purging. This
commit correctly handles such situations.

In certain cases we find more than one instruction storing the return
address to a register. In particular, this happens with a `bltzal`
instruction in MIPS, where the return address is stored both in `ra` and
`btarget`.

For now, do not consider these as actual function calls.