GitLab

Summary:
clearNursery resets all the bd->free pointers of nursery blocks to
make the blocks empty.  In profiles we've seen clearNursery taking
significant amounts of time particularly with large -N and -A values.

This patch moves the work of clearNursery to the point at which we
actually need the new block, thereby introducing an invariant that
blocks to the right of the CurrentNursery pointer still need their
bd->free pointer reset.  This should make things faster overall,
because we don't need to clear blocks that we don't use.

Test Plan: validate

Reviewers: AndreasVoellmy, ezyang, austin

Subscribers: thomie, carter, ezyang, simonmar

Differential Revision: https://phabricator.haskell.org/D318

ekmett & hvr.

See b0534f78 for more details

[skip ci]

This redoes part of 475dd93e which was reversed in 452d6aa9 after
breaking validate on windows.

Summary:
Add missing Outputable instance for AnnotationComment

Update documentation

Adjust parser to capture annotations correctly

Test Plan: ./validate

Reviewers: austin

Reviewed By: austin

Subscribers: thomie, carter

Differential Revision: https://phabricator.haskell.org/D520

Summary: Implementation of #5364. Mostly boilerplate, reading FILE fields is missing.

Test Plan:
- Get some feedback on missing parts. (FILE fields)
- Get some feedback on module name.
- Get some feedback on other things.
- Get code reviewed.
- Make sure test suite is passing. (I haven't run it myself)

Reviewers: hvr, austin, ezyang

Reviewed By: ezyang

Subscribers: ekmett, simonmar, ezyang, carter, thomie

Differential Revision: https://phabricator.haskell.org/D306

GHC Trac Issues: #5364

Conflicts:
	includes/rts/Flags.h

...instead of invoking `patch` directly in `integer-gmp2/gmp/ghc.mk`

This will hopefully workaround an issue where
`libraries/integer-gmp2/include/ghc-gmp.h` gets deleted
during cleanup but isn't regenerated.

This situation is caused by `./validate` cleaning the tree with

  $make maintainer-clean NO_CLEAN_GMP=YES

which doesn't doesn't clean the `gmp/` folder, and so the `include/ghc-gmp.h`
file wasn't recreated (as it was previously a side-effect of building
the intree GMP).

Reviewed By: luite

Differential Revision: https://phabricator.haskell.org/D523

This is mostly a proof of concept for updating the in-tree GMP via patch files
(and therefore w/o introducing new blobs into the Git history).

NOTE: The updated GMP 5.0.4 version is only used by the integer-gmp2 backend.

This creates the additional macro definitions in `HsIntegerGmp.h` which
are useful for 3rd party `integer-gmp`-addon libraries.

Here's an example for the definitions created for the in-tree GMP:

  #define GHC_GMP_INTREE     1
  #define GHC_GMP_VERSION_MJ 5
  #define GHC_GMP_VERSION_MI 0
  #define GHC_GMP_VERSION_PL 4
  #define GHC_GMP_VERSION   (5 * 10000 + 0 * 100 + 4)

And here's an example for a system-installed GMP:

  #define GHC_GMP_INTREE     0
  #define GHC_GMP_VERSION_MJ 6
  #define GHC_GMP_VERSION_MI 0
  #define GHC_GMP_VERSION_PL 0
  #define GHC_GMP_VERSION   (6 * 10000 + 0 * 100 + 0)

Part of #9281

Reviewed By: ekmett (via D522)

This is mostly interesting when using the in-tree GMP, as there's
no way otherwise to access the in-tree `gmp.h` header file after installation.

In case `integer-gmp2` was build against a system-installed GMP library,
`ghc-gmp.h` simply contains `#include <gmp.h>` for convenience.

Reviewed By: ekmett

Differential Revision: https://phabricator.haskell.org/D522

The actual type-signatures of the new instances are:

  instance Storable a => Storable (Complex a)

  instance (Storable a, Integral a) => Storable (Ratio a)

See also

  https://groups.google.com/d/msg/haskell-core-libraries/mjBSo2CQ3LU/0gwg0QvviOIJ

Addresses #9826

Reviewed By: ekmett

Differential Revision: https://phabricator.haskell.org/D519

`() <$ x` is sometimes better than `fmap (const ()) x` and should
never be worse.

Reviewed By: ekmett

Differential Revision: https://phabricator.haskell.org/D521

This calls the `popCountBigNat` primitive directly instead of going
through `Integer`'s `popCount`.

This provides the equivalent of the existing `{gcd,lcm}/Integer`
optimisations for the `Natural` type, when using the `integer-gmp2`
backend.

This fixes a case where `isValidNatural . fromInteger` would be `False`.

Re #9818

This predicate function encodes the internal `Natural` invariants, and
is useful for testsuites or code that directly constructs `Natural`
values.

C.f. `integer-gmp2`'s `isValidBigNat#` and `isValidInteger#` predicates
for testing internal invariants.

This makes use of the `gcdWord` primitive provided by
be7fb7e5 which should make the
`Word`-variant of `gcd` as performant as the `Int`-variant.

This is slipped in by accident as part of
c774b28f (re #9281)

It's trivial for `integer-gmp2` (#9281) to provide it, and it'll be
useful for a future 'Natural'-related commit, as well as providing a
`Word` optimised `gcd`-RULE.

This reverts commit 5760eb59
because the very same test was already added via
5eebd990 and is causing
`./validate` to fail due to "framework failure".

This should silence the

   perf/haddock  haddock.compiler [stat not good enough] (normal)

test-failure...

This implements a `Natural` type for representing unsigned arbitrary
precision integers.

When available, `integer-gmp>=1.0.0`'s `BigNat` type is used as
building-block to construct `Natural` as an algebraic data-type.
Otherwise, `Natural` falls back being a `newtype`-wrapper around
`Integer` (as is done in Edward Kmett's `nats` package).

The `GHC.Natural` module exposes an internal GHC-specific API, while
`Numeric.Natural` provides the official & portable API.

Reviewed By: austin, ekmett

Differential Revision: https://phabricator.haskell.org/D473

The library submission was accepted:

  http://www.haskell.org/pipermail/libraries/2014-September/023777.html

The T5892ab testcases were changed to use `Data.Tree` instead of `Data.Version`

Reviewed By: ekmett

Differential Revision: https://phabricator.haskell.org/D395

Summary:
As proposed by Richard on Trac. This patch adds a new flag -fdefer-typed-holes
and changes the semantics of the -fno-warn-typed-holes flag.

To summarise, by default GHC has typed holes enabled and produces a compile
error when it encounters a typed hole.

When -fdefer-type-errors OR -fdefer-typed-holes is enabled, hole errors are
converted to warnings and result in runtime errors when evaluated.

The warning flag -fwarn-typed-holes is on by default. Without -fdefer-type-errors
or -fdefer-typed-holes this flag is a no-op, since typed holes are an error
under these conditions. If either of the defer flags are enabled (converting
typed hole errors into warnings) the -fno-warn-typed-holes flag disables the
warnings. This means compilation silently succeeds and evaluating a hole will
produce a runtime error.

The rationale behind allowing typed holes warnings to be silenced is that tools
like Syntastic for vim highlight warnings and hole warnings may be undesirable.
Signed-off-by: Merijn Verstraaten <merijn@inconsistent.nl>

Test Plan: validate

Reviewers: austin, simonpj, thomie

Reviewed By: simonpj, thomie

Subscribers: Fuuzetsu, thomie, carter

Differential Revision: https://phabricator.haskell.org/D442

GHC Trac Issues: #9497

Conflicts:
	compiler/main/DynFlags.hs

Summary:
Previously 'ghc --show-options' showed all options that GHC can possibly
accept. With this patch, it'll only show the options that have effect in
non-interactive modes.
This change also adds support for using 'ghc --interactive --show-options'
which previously was disallowed. This command will show all options that have
effect in the interactive mode.
The CmdLineParser is updated to know about the GHC modes, and then each flag
is annotated with which mode it has effect.
This fixes #9259.

Test Plan:
Try out --show-options with --interactive on the command line. With and without
--interactive should give different results.
Run the test suite, mode001 has been updated to verify this new flag
combination.

Reviewers: austin, jstolarek

Reviewed By: austin, jstolarek

Subscribers: jstolarek, thomie, carter, simonmar

Differential Revision: https://phabricator.haskell.org/D337

GHC Trac Issues: #9259

The new function `Data.Bits.toIntegralSized` provides a similar
functionality to `fromIntegral` but adds validation that the
argument fits in the result type's size.

The implementation of `toIntegralSized` has been derived from `intCastMaybe`
(which is part of Herbert Valerio Riedel's `int-cast` package,
see http://hackage.haskell.org/package/int-cast)

Addresses #9816

Reviewed By: ekmett, austin

Differential Revision: https://phabricator.haskell.org/D512

Defaults to using `show` to prevent any breakage of existing code.  Also
provide a custom implementation for `SomeException` which uses the
underlying exception's `displayException`.

Differential Revision: https://phabricator.haskell.org/D517

Due to changes in LLVM 3.5 aliases now may only refer to definitions.
Previously to handle symbols defined outside of the current commpilation
unit GHC would emit both an `external` declaration, as well as an alias
pointing to it, e.g.,

    @stg_BCO_info = external global i8
    @stg_BCO_info$alias = alias private i8* @stg_BCO_info

Where references to `stg_BCO_info` will use the alias
`stg_BCO_info$alias`. This is not permitted under the new alias
behavior, resulting in errors resembling,

    Alias must point to a definition
    i8* @"stg_BCO_info$alias"

To fix this, we invert the naming relationship between aliases and
definitions. That is, now the symbol definition takes the name
`@stg_BCO_info$def` and references use the actual name, `@stg_BCO_info`.
This means the external symbols can be handled by simply emitting an
`external` declaration,

    @stg_BCO_info = external global i8

Whereas in the case of a forward declaration we emit,

    @stg_BCO_info = alias private i8* @stg_BCO_info$def

Reviewed By: austin

Differential Revision: https://phabricator.haskell.org/D155

which presumably was just forgotten when creating the testcase in
commit 7b1a8562.

fillBytes uses 'memset' to fill a memory area with a given byte value.

Reviewed By: austin, hvr

Differential Revision: https://phabricator.haskell.org/D465

Summary:
Make HsLit and OverLitVal have original source strings, for source to
source conversions using the GHC API

This is part of the ongoing AST Annotations work, as captured in
https://ghc.haskell.org/trac/ghc/wiki/GhcAstAnnotations and
https://ghc.haskell.org/trac/ghc/ticket/9628#comment:28

The motivations for the literals is as follows

```lang=haskell
x,y :: Int
x = 0003
y = 0x04

s :: String
s = "\x20"

c :: Char
c = '\x20'

d :: Double
d = 0.00

blah = x
  where
    charH = '\x41'#
    intH = 0004#
    wordH = 005##
    floatH = 3.20#
    doubleH = 04.16##
    x = 1
```

Test Plan: ./sh validate

Reviewers: simonpj, austin

Reviewed By: simonpj, austin

Subscribers: thomie, goldfire, carter, simonmar

Differential Revision: https://phabricator.haskell.org/D412

GHC Trac Issues: #9628