Since the Trees That Grow effort started, we had `type LPat = Pat`.
This is so that `SrcLoc`s would only be annotated in GHC's AST, which is
the reason why all GHC passes use the extension constructor `XPat` to
attach source locations. See #15495 for the design discussion behind
that.

But now suddenly there are `XPat`s everywhere!
There are several functions which dont't cope with `XPat`s by either
crashing (`hsPatType`) or simply returning incorrect results
(`collectEvVarsPat`).

This issue was raised in #17330. I also came up with a rather clean and
type-safe solution to the problem: We define

```haskell
type family XRec p (f :: * -> *) = r | r -> p f
type instance XRec (GhcPass p) f = Located (f (GhcPass p))
type instance XRec TH          f =          f p
type LPat p = XRec p Pat
```

This is a rather modular embedding of the old "ping-pong" style, while
we only pay for the `Located` wrapper within GHC. No ping-ponging in
a potential Template Haskell AST, for example. Yet, we miss no case
where we should've handled a `SrcLoc`: `hsPatType` and
`collectEvVarsPat` are not callable at an `LPat`.

Also, this gets rid of one indirection in `Located` variants:
Previously, we'd have to go through `XPat` and `Located` to get from
`LPat` to the wrapped `Pat`. Now it's just `Located` again.

Thus we fix #17330.

Sets `MiscFlags.disableDelayedOsMemoryReturn`.

See the added `Note [MADV_FREE and MADV_DONTNEED]` for details.

CSE delays inlining a little bit, to avoid losing vital
specialisations; see Note [Delay inlining after CSE] in CSE.

But it was being over-enthusiastic.  This patch makes the
delay only apply to Ids with specialisation rules, which
avoids unnecessary delay (#17409).

Use True/False instead of 0/1. This shouldn't be a functional change but
we should be consistent.

As described in #16588.

Previously the test relied on `id` not inlining. Fix this.

failIO has useful information in its demand signature (specifically that
it bottoms) which is hidden if it is SOURCE imported, as noted
in #16588. Rejigger things such that we don't SOURCE import it.

Metric Increase:
    T13701

This patch fixes #17395, a very subtle and hard-to-trigger
bug in tcMatchTy.  It's all explained in
  Note [Matching in the presence of casts (2)]

I have not added a regression test because it is very hard
to trigger it, until we have the upcoming mkAppTyM patch,
after which lacking this patch means you can't even compile
the libraries.

This one came in a comment from James Payor

I found in #17415 that Lint was printing out truly gigantic
warnings, unmanageably huge, with repeated copies of the
same thing.

This patch makes Lint less chatty, especially for warnings:

* For **warnings**, I don't print details of the location,
  unless you add `-dppr-debug`.

* For **errors**, I still print all the info. They are fatal
  and stop exection, whereas warnings appear repeatedly.

* I've made much less use of `AnExpr` in `LintLocInfo`;
  the expression can be gigantic.

MacOS Catalina is finally going to force our hand in forbidden writable
exeutable mappings. Unfortunately, this is quite incompatible with the
current global m32 allocator, which mixes symbols from various objects
in a single page. The problem here is that some of these symbols may not
yet be resolved (e.g. had relocations performed) as this happens lazily
(and therefore we can't yet make the section read-only and therefore
executable).

The easiest way around this is to simply create one m32 allocator per
ObjectCode. This may slightly increase fragmentation for short-running
programs but I suspect will actually improve fragmentation for programs
doing lots of loading/unloading since we can always free all of the
pages allocated to an object when it is unloaded (although this ability
will only be implemented in a later patch).

Just a few things I found while looking at #17383.

As reported in #17414, Darwin throws EINVAL in response to large
writes.

Before: 0x0000004200c86888
After:  0x42000224f8

This is more concise and consistent with the RTS's printer (which uses
%p formatter, and at least on Linux gcc prints the short form) and gdb's
pointer formatter.

Previously we were configuring the ARMv7 builds with a host/target
triple of arm-linux-gnueabihf, which caused us to target ARMv6 and
consequently rely on the old CP15 memory barrier implementation. This
barrier has to be emulated on ARMv8 machines which is glacially slow.

Hopefully this should fix the ARMv7 builds which currently consistently
time out.

GHC Proposal #229 changes the lexical rules of Haskell, which may
require slight whitespace adjustments in certain cases.

This patch changes formatting in a few places in GHC and its testsuite
in a way that enables it to compile under the proposed rules.

AP_NOUPD entry code doesn't use the arity field, but not initializing
this field confuses printers/debuggers, and also makes testing harder as
the field's value changes randomly.

The configuration in the installation environment (as determined by
`autoconf`) may differ from the build environment and therefore we
need to be sure to rebuild the settings file.

Fixes #17374.

This had silently regressed due to 81860281 and the variable renaming performed
in b55ee979, as noted in #17374.

This reverts commit aa31ceaf as
suggested in #17392.

Not only is it now unused but we generally can't assume that we are
compiling with GCC, so it really shouldn't be used.

This makes the CPP significantly easier to follow.

The OFD locking path introduced in
3b784d44 due to #13945 appears to have
never actually worked but we never noticed due to an oversight in the
autoconf check. Fix it.

Thanks to Oleg Grenrus for noticing this.

Previously `hadrian` would pass `-optc-Werror=unused-but-set-variable`
to all GHC invocations. This was a difference from the make build system
and cause the unregisterised build to fail as the C that GHC produces
contains many unused functions. Drop it from the GHC flags.

Note, however, that the flag is still present in
`Settings.Builders.Common.cWarnings` and therefore will still be applied
during compilation of C sources.

Some of these flags wanted to be passed to .cmm builds as well as C
builds.

It seems that NOSMP was previously only defined when compiling the
compiler, not the RTS. Fix this.

In addition do some spring-cleaning and make the logic match that of the
Make build system.