GitLab

compiler/simplCore/SimplUtils.lhs:1668:5-25: Irrefutable pattern failed for pattern ((_, _, rhs1) : _)

Fixes 2276_ghci on Win64

This patch allows, for the first time, case expressions with an empty
list of alternatives. Max suggested the idea, and Trac #6067 showed
that it is really quite important.

So I've implemented the idea, fixing #6067. Main changes

 * See Note [Empty case alternatives] in CoreSyn

 * Various foldr1's become foldrs

 * IfaceCase does not record the type of the alternatives.
   I added IfaceECase for empty-alternative cases.

 * Core Lint does not complain about empty cases

 * MkCore.castBottomExpr constructs an empty-alternative case
   expression   (case e of ty {})

 * CoreToStg converts '(case e of {})' to just 'e'

To prevent conflicts with GCC builtins, generate identical code for
calls to mem primos and FFI calls.

Based on a patch by Joachim Breitner.

We now detect if we are given a value that is out of range for a
32bit relocation, and fail with an error.

Added a load more symbols to rtsSyms.

Without this, we ended up using
    (gdb) info symbol 0x7ff756a10ac
    msvcrt!free in section .text of C:\Windows\system32\msvcrt.dll
for free, rather than
    (gdb) info symbol 0x2584128
    free in section .text of C:\m64\ghci2\q/../inplace/bin/ghc-stage2.exe
but we were trying to put the address into a 32bit relocation.

In particular, old-time assumes that mingw32_HOST_OS is set when
we are on Windows, and was going wrong on Win64 because it wasn't
defined.

It doesn't suffice for checkProddableBlock to just check whether the
largest possible write could be made at the address we are writing,
as if we are making a smaller write then checkProddableBlock may
conservatively think we will write off the end of the block.

Thus we now tell checkProddableBlock how many bytes we will write.

This reverts commit 29cd6f43.

This reverts commit 02cf6d6f.

This reverts commit 27e585bd.

This reverts commit 05b55c67.

This reverts commit 0042c478.

This reverts commit e89ef704.

There was one place, in type checking parallel list comprehensions
where we were unifying types, but had no convenient way to use the
resulting coercion; instead we just checked that it was Refl.  This
was Wrong Wrong; it might fail unpredicably in a GADT-like situation,
and it led to extra error-generation code used only in this one place.

This patch tidies it all up, by moving the 'return' method from the
*comprehension* to the ParStmtBlock. The latter is a new data type,
now used for each sub-chunk of a parallel list comprehension.

Because of the data type change, quite a few modules are touched,
but only in a fairly trivial way. The real changes are in TcMatches
(and corresponding desugaring); plus deleting code from TcUnify.

This patch also fixes the pretty-printing bug in Trac #6060

It was causing assertion failures of
    ASSERT(countBlocks(nursery->blocks) == nursery->n_blocks)
at
    ghc-stage2: internal error: ASSERTION FAILED: file rts/sm/Sanity.c, line 878

The stage0 compiler might have a different idea as to what type lnat
corresponds to, so cast the value to the type we want.

GHC currently uses the slightly-dodgy plan that when we proote
a TyCon to be a Kind constructor we leave it with the same Name.

That means that to make sense of a IfaceType we need to know wheter
it is really an IfaceType or an IfaceKind, because in the latter an
occurrence of (say) Maybe will be the *promoted* Maybe.

See Note [Checking IfaceTypes vs IfaceKinds] in TcIface

This reverts commit 745ec959.

Sigh. Seg fault

This reverts commit e3f8557c.

Sigh. Seg fault.

This reverts commit a365a58e.

Sigh.  Seg fault.  Major sigh.

This puts back the earlier behaviour (pre "aggressive-primop" patch)
whereby most primpos were considered cheap.  In the aggressive-primop
patch we made them ones with bigger "code_size" seem not-cheap, but
this slows down fft2 a lot.  So I've reverted to the earlier behaviour.

   +++ b/compiler/prelude/PrimOp.lhs
   @@ -450,6 +450,8 @@ primOpIsCheap op
      -- This is vital; see Note [PrimOp can_fail and has_side_effects]
    && not (primOpOutOfLine op)
  -   -- && primOpCodeSize op <= primOpCodeSizeDefault
  +-- Omitting; it makes fft2 run a lot slower by preventing
  +--           eta expansion in an inner loop, with a primop cosDouble#