configure-any-target.patch: set CFLAGS according to target arch

The whole point of TARGET_CFLAGS is in fact to ensure that off_t is
always (at least) 64 bits large. Whether or not it is necessary to
define _FILE_OFFSET_BITS depends on the host architecture rather than
on the target.
target-printf-spec.patch: refresh
subst_other_var_decls: fix global scope substitution

If a variable's scope is NULL, then the declaration may be repeated
in a non-header file, that is with a non-NULL scope. We have to walk
the file list to find these declarations.
target-types-use.patch: remove

This patch is now superseded by variable tracking. Further refinement
should happen in the vartrack code, not here.
target_var: convert to the vartrack API

Instead of improving the older type conversion code, let's use the
new fancy algorithm.
Fake macro return type and statement

Treat macro declarations like functions, faking a "return" statement,
so it can be tracked via track_return().
is_host_type: fix check for function call's return type

The code incorrectly checked for the function type itself instead of
the function's return type.

Plus macros now have a dummy return type.
track_expr: handle the binary AND operator

The result of a binary operation on a target type is a target type.
Reverse ind_t stack direction

Let it grow downwards. This makes debugging a bit easier, because gdb
interprets the stack as a C string. Since the stack always ends with
ind_stop, which is numerically identical to the NUL character, you can
directly see the whole stack in gdb if it is ordered this way.
Kill ind_warn()

These debugging messages are no longer useful, cluttering program
output instead.
Add ADDR_OF and DEREF_OP operators

Distinguishing between unary and binary versions of these operators
is a PITA in many places, and we already knew which one it was when
the input file was parsed.
is_host_type: treat macro expansions as non-determinate type

Using a macro without parameters is parsed the same as a function
identifier, which would normally be a host-specific function pointer
type. A macro expands instead.

TODO: It would be better to trace the macro expansion, but that would
be a major effort. Better fix the result afterwards if necessary.
is_host_type: handle '!', '~', and '%'

Handle some of the unhandled operators...
build_scopes: skip children when a var is found

Take code like this:

struct foo { int bar; } x;
void *bar;

foo->bar = 1;

When walking the tree, "foo->bar" is first correctly recognized as the
"bar" member of struct foo, but the walk then continues and "bar" is
incorrectly recognized as the "void *" variable.
subst_target_expr: a better way for top-down substitution

If we know that the type of an expression is target-specific, decompose
the expression and try to change the types where appropriate.

This cannot be solved in the general case, of course, so let's hope
that our heuristics is good enough for the crash sources...
subst_target_type: do not track struct, union, array and func types

These types should never be treated as target types, because otherwise
we could screw up what is host-specific and what is target-specific
later on.
manual.patch: refresh
subst_target_type: convert struct members when converting a struct

If we identify a struct type as target-specific, then convert all
struct members.

See "struct chrdevs" for an example.
cleanup: nth_element -> nth_node

There was first_node but nth_element. Plus, the nth_element() function
only worked on nodes.

No functional change.
Move type indirection handling into indirect.c

The xform.c file has been growing too much. Let's split off some
functions.