Commits on Source (36)
-
This replaces all Word<N> = W<N># Word# and Int<N> = I<N># Int# with Word<N> = W<N># Word<N># and Int<N> = I<N># Int<N>#, thus providing us with properly sized primitives in the codegenerator instead of pretending they are all full machine words. This came up when implementing darwinpcs for arm64. The darwinpcs reqires us to pack function argugments in excess of registers on the stack. While most procedure call standards (pcs) assume arguments are just passed in 8 byte slots; and thus the caller does not know the exact signature to make the call, darwinpcs requires us to adhere to the prototype, and thus have the correct sizes. If we specify CInt in the FFI call, it should correspond to the C int, and not just be Word sized, when it's only half the size. This does change the expected output of T16402 but the new result is no less correct as it eliminates the narrowing (instead of the `and` as was previously done). Bumps the array, bytestring, text, and binary submodules. Co-Authored-By:Ben Gamari <ben@well-typed.com> Metric Increase: T13701 T14697
be5d74ca -
On windows using gcc-10 gcc failed to inline copy_tag into evacuate. To fix this we now set the always_inline attribute for the various copy* functions in Evac.c. The main motivation here is not the overhead of the function call, but rather that this allows the code to "specialize" for the size of the closure we copy which is often known at compile time. An earlier commit also tried to avoid evacuate_large inlining. But didn't quite succeed. So I also marked evacuate_large as noinline. Fixes #12416
a84e53f9 -
[This is @Ericson2314 writing a commit message for @hsyl20's patch.] (Progress towards #11953, #17377, #17375) `Int64Rep` and `Word64Rep` are currently broken on 64-bit systems. This is because they should use "native arg rep" but instead use "large arg rep" as they do on 32-bit systems, which is either a non-concept or a 128-bit rep depending on one's vantage point. Now, these reps currently aren't used during 64-bit compilation, so the brokenness isn't observed, but I don't think that constitutes reasons not to fix it. Firstly, the linked issues there is a clearly expressed desire to use explicit-bitwidth constructs in more places. Secondly, per [1], there are other bugs that *do* manifest from not threading explicit-bitwidth information all the way through the compilation pipeline. One can therefore view this as one piece of the larger effort to do that, improve ergnomics, and squash remaining bugs. Also, this is needed for !3658. I could just merge this as part of that, but I'm keen on merging fixes "as they are ready" so the fixes that aren't ready are isolated and easier to debug. [1]: https://mail.haskell.org/pipermail/ghc-devs/2020-October/019332.html
cdbd16f5 -
a9378e69
-
Most compilers probably already infer that `barf` diverges but it nevertheless doesn't hurt to be explicit.
86a59d93 -
This was added in https://github.com/nomeata/ghc-heap-view/commit/34935206e51b9c86902481d84d2f368a6fd93423 GHC.ByteCode.Instr.BreakInfo no longer exists so the special case is dead code. Any check like this can be easily dealt with in client code.
5757e82b -
Motivation 1. Don't enforce the repeated decoding of an info table, when the client can cache it (ghc-debug) 2. Allow the constructor information decoding to be overridden, this casues segfaults in ghc-debug
d9c8b5b4 -
Fixes #18994 Co-Author: Benjamin Maurer <maurer.benjamin@gmail.com>
3e3555cc -
As noted in #18991, we would previously allocate heap in low memory. Due to this the linker, which typically *needs* low memory, would end up competing with the heap. In longer builds we end up running out of low memory entirely, leading to linking failures.
a1a75aa9 -
75fc1ed5
-
Make sure ghc-pkg doesn't read the compiler "settings" file by passing --no-user-package-db.
7cb5df96 -
This adds a job to test cross-compilation from x86-64 to AArch64 with Hadrian. Fixes #18234
e3fd4226 -
The deployments are quite large and yet are currently only served for the ghc/ghc> project.
698d3d96 -
Co-authored-by:
Sven Tennie <sven.tennie@gmail.com> Co-authored-by:
Matthew Pickering <matthewtpickering@gmail.com> Co-authored-by:
Ben Gamari <bgamari.foss@gmail.com>
625726f9 -
Inside `regsUsedIn` we can avoid some thunks by specializing the recursion. In particular we avoid the thunk for `(f e z)` in the MachOp/Load branches, where we know this will evaluate to z. Reduces allocations for T3294 by ~1%.
22ea9c29 -
bba42c62
-
Harmonize the internal (big sum type) names of the native vs fixed-sized number primops a bit. (Mainly by renaming the former.) No user-facing names are changed.
c82bc8e9 -
Due to #18953.
ae14f160 -
This will allow us to back out the allocations per compiler pass from the eventlog. Note that we dump the allocation counter rather than the difference since this will allow us to determine how much work is done *between* `withTiming` blocks.
1bc104b0 -
When threadPaused blackholes a thunk it calls `OVERWRITING_CLOSURE` to zero the slop for the benefit of the sanity checker. Previously this was done *before* pushing the thunk's free variables to the update remembered set. Consequently we would pull zero'd pointers to the update remembered set.
e992ea84 -
-
After a THROWTO message has been handle the message closure is overwritten by a NULL message. We must ensure that the original closure's pointers continue to be visible to the nonmoving GC.
35a5207e -
0120829f
-
Ensure that the the free variables have been pushed to the update remembered set before we zero the slop.
8a4d8fb6 -
pthread_join returns its error code and apparently doesn't set errno.
2793cfdc -
The mark thread is not joinable as we detach from it on creation.
e391a16f -
60d088ab
-
See Note [Non-moving GC: Marking evacuated objects].
3aa60362 -
Previously, in an attempt to reduce fragmentation, each new allocator would map a region of M32_MAX_PAGES fresh pages to seed itself. However, this ends up being extremely wasteful since it turns out that we often use fewer than this. Consequently, these pages end up getting freed which, ends up fragmenting our address space more than than we would have if we had naively allocated pages on-demand. Here we refactor m32 to avoid this waste while achieving the fragmentation mitigation previously desired. In particular, we move all page allocation into the global m32_alloc_page, which will pull a page from the free page pool. If the free page pool is empty we then refill it by allocating a region of M32_MAP_PAGES and adding them to the pool. Furthermore, we do away with the initial seeding entirely. That is, the allocator starts with no active pages: pages are rather allocated on an as-needed basis. On the whole this ends up being a pleasingly simple change, simultaneously making m32 more efficient, more robust, and simpler. Fixes #18980.
8d304a99 -
Use the GHC wrappers instead of <assert.h>.
b6629289 -
In the past some people have confused ASSERT, which is for checking internal invariants, which CHECK, which should be used when checking things that might fail due to bad input (and therefore should be enabled even in the release compiler). Change some of these cases in the linker to use CHECK.
9f4efa6a -
See #18973.
0f8a4655 -
Richard Eisenberg authored
This sets the stage for a later change, where this algorithm will be needed from GHC.Core.InstEnv. This commit also splits GHC.Core.Map into GHC.Core.Map.Type and GHC.Core.Map.Expr, in order to avoid module import cycles with GHC.Core.
636db9ef -
Richard Eisenberg authored
The previous value of 75 meant that a feature branch with more than 75 commits would get spurious CI passes. This affects #18692, but does not fix that ticket, because if a baseline cannot be found, we should fail, not succeed.
da912d0a -
Richard Eisenberg authored
This patch redesigns the flattener to simplify type family applications directly instead of using flattening meta-variables and skolems. The key new innovation is the CanEqLHS type and the new CEqCan constraint (Ct). A CanEqLHS is either a type variable or exactly-saturated type family application; either can now be rewritten using a CEqCan constraint in the inert set. Because the flattener no longer reduces all type family applications to variables, there was some performance degradation if a lengthy type family application is now flattened over and over (not making progress). To compensate, this patch contains some extra optimizations in the flattener, leading to a number of performance improvements. Close #18875. Close #18910. There are many extra parts of the compiler that had to be affected in writing this patch: * The family-application cache (formerly the flat-cache) sometimes stores coercions built from Given inerts. When these inerts get kicked out, we must kick out from the cache as well. (This was, I believe, true previously, but somehow never caused trouble.) Kicking out from the cache requires adding a filterTM function to TrieMap. * This patch obviates the need to distinguish "blocking" coercion holes from non-blocking ones (which, previously, arose from CFunEqCans). There is thus some simplification around coercion holes. * Extra commentary throughout parts of the code I read through, to preserve the knowledge I gained while working. * A change in the pure unifier around unifying skolems with other types. Unifying a skolem now leads to SurelyApart, not MaybeApart, as documented in Note [Binding when looking up instances] in GHC.Core.InstEnv. * Some more use of MCoercion where appropriate. * Previously, class-instance lookup automatically noticed that e.g. C Int was a "unifier" to a target [W] C (F Bool), because the F Bool was flattened to a variable. Now, a little more care must be taken around checking for unifying instances. * Previously, tcSplitTyConApp_maybe would split (Eq a => a). This is silly, because (=>) is not a tycon in Haskell. Fixed now, but there are some knock-on changes in e.g. TrieMap code and in the canonicaliser. * New function anyFreeVarsOf{Type,Co} to check whether a free variable satisfies a certain predicate. * Type synonyms now remember whether or not they are "forgetful"; a forgetful synonym drops at least one argument. This is useful when flattening; see flattenView. * The pattern-match completeness checker invokes the solver. This invocation might need to look through newtypes when checking representational equality. Thus, the desugarer needs to keep track of the in-scope variables to know what newtype constructors are in scope. I bet this bug was around before but never noticed. * Extra-constraints wildcards are no longer simplified before printing. See Note [Do not simplify ConstraintHoles] in GHC.Tc.Solver. * Whether or not there are Given equalities has become slightly subtler. See the new HasGivenEqs datatype. * Note [Type variable cycles in Givens] in GHC.Tc.Solver.Canonical explains a significant new wrinkle in the new approach. * See Note [What might match later?] in GHC.Tc.Solver.Interact, which explains the fix to #18910. * The inert_count field of InertCans wasn't actually used, so I removed it. Though I (Richard) did the implementation, Simon PJ was very involved in design and review. This updates the Haddock submodule to avoid #18932 by adding a type signature. ------------------------- Metric Decrease: T12227 T5030 T9872a T9872b T9872c Metric Increase: T9872d -------------------------
50b22545 -
Richard Eisenberg authored
Now that flattening doesn't produce flattening variables, it's not really flattening anything: it's rewriting. This change also means that the rewriter can no longer be confused the core flattener (in GHC.Core.Unify), which is sometimes used during type-checking.
973fb509
Showing
- .gitlab-ci.yml 32 additions, 1 deletion.gitlab-ci.yml
- .gitlab/ci.sh 20 additions, 5 deletions.gitlab/ci.sh
- compiler/GHC/Builtin/Names.hs 3 additions, 2 deletionscompiler/GHC/Builtin/Names.hs
- compiler/GHC/Builtin/Types.hs 3 additions, 5 deletionscompiler/GHC/Builtin/Types.hs
- compiler/GHC/Builtin/primops.txt.pp 43 additions, 23 deletionscompiler/GHC/Builtin/primops.txt.pp
- compiler/GHC/ByteCode/Asm.hs 9 additions, 0 deletionscompiler/GHC/ByteCode/Asm.hs
- compiler/GHC/ByteCode/Types.hs 2 additions, 2 deletionscompiler/GHC/ByteCode/Types.hs
- compiler/GHC/Cmm.hs 6 additions, 0 deletionscompiler/GHC/Cmm.hs
- compiler/GHC/Cmm/CommonBlockElim.hs 1 addition, 1 deletioncompiler/GHC/Cmm/CommonBlockElim.hs
- compiler/GHC/Cmm/Dataflow/Label.hs 1 addition, 0 deletionscompiler/GHC/Cmm/Dataflow/Label.hs
- compiler/GHC/Cmm/Expr.hs 11 additions, 0 deletionscompiler/GHC/Cmm/Expr.hs
- compiler/GHC/Cmm/Sink.hs 11 additions, 4 deletionscompiler/GHC/Cmm/Sink.hs
- compiler/GHC/CmmToAsm/Ppr.hs 11 additions, 3 deletionscompiler/GHC/CmmToAsm/Ppr.hs
- compiler/GHC/CmmToAsm/Reg/Graph.hs 2 additions, 1 deletioncompiler/GHC/CmmToAsm/Reg/Graph.hs
- compiler/GHC/CmmToAsm/Reg/Graph/Stats.hs 5 additions, 1 deletioncompiler/GHC/CmmToAsm/Reg/Graph/Stats.hs
- compiler/GHC/CmmToC.hs 85 additions, 108 deletionscompiler/GHC/CmmToC.hs
- compiler/GHC/Core.hs 4 additions, 0 deletionscompiler/GHC/Core.hs
- compiler/GHC/Core/Coercion.hs 114 additions, 68 deletionscompiler/GHC/Core/Coercion.hs
- compiler/GHC/Core/Coercion.hs-boot 1 addition, 1 deletioncompiler/GHC/Core/Coercion.hs-boot
- compiler/GHC/Core/Coercion/Axiom.hs 12 additions, 0 deletionscompiler/GHC/Core/Coercion/Axiom.hs