-Wimplicit

 -include

 rts/include/ghcversion.h

 -DDEBUG

 -DDYNAMIC

 -DPROFILING

 import GHC.Utils.Outputable

 -- Debug Instance

 instance Outputable JumpDest where

 import GHC.Types.Unique

 import GHC.Utils.Outputable (ppr, text, Outputable, (<>))

 -- Debug Instance

 instance Outputable JumpDest where

 -- We also need to do the same for multiplicity! Which, since multiplicities are

 -- encoded simply as a 'Type', amounts to have a Trie for a pair of types. Tries

 -- of pairs are composition.

 -- TODO(22292): derive

 instance Functor BndrMap where

 -- Currently implemented with unsafe lazy IO. But it could be implemented with

 -- an IORef as the exposed interface is in IO.

 data LlvmConfigCache = LlvmConfigCache LlvmConfig

 initLlvmConfigCache :: FilePath -> IO LlvmConfigCache

 initLlvmConfigCache top_dir = pure $ LlvmConfigCache (unsafePerformIO $ initLlvmConfig top_dir)

   T_MergeForeign :: PipeEnv -> HscEnv -> FilePath -> [FilePath] -> TPhase FilePath

 -- | A wrapper around the interpretation function for phases.

                                       -- in module Language.Haskell.Syntax.Extension

 {-# LANGUAGE TypeFamilies #-}

 {-# LANGUAGE LambdaCase #-}

 module GHC.Tc.Utils.Env(

         TyThing(..), TcTyThing(..), TcId,

 notFound :: Name -> TcM TyThing

 notFound name

   = do { lcl_env <- getLclEnv

        ; if isTermVarOrFieldNameSpace (nameNameSpace name)

            then

                -- This code path is only reachable with RequiredTypeArguments enabled

 {- Note [Out of scope might be a staging error]

 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 Consider

 -}

  *  3. [STW] Root collection: Here we walk over a variety of root sources

  *     and add them to the mark queue (see nonmovingCollect).

  *

  *

  *  5. [STW] Final sync: Here we interrupt the mutators, ask them to

  *     flush their final update remembered sets, and mark any new references

  *  - Note [Concurrent read barrier on deRefWeak#] (NonMovingMark.c) describes

  *    the read barrier on Weak# objects.

  *

  *

  *  - Note [Origin references in the nonmoving collector] (NonMovingMark.h)

  *    describes how we implement indirection short-cutting and the selector

  *  - Note [StgStack dirtiness flags and concurrent marking] (TSO.h) describes

  *    the protocol for concurrent marking of stacks.

  *

  *    operations.

  *

  *  - Note [Static objects under the nonmoving collector] (Storage.c) describes

  *    how we use the DIRTY flags associated with MUT_VARs and TVARs to improve

  *    barrier efficiency.

  *

  *

  *  - Note [Sync phase marking budget] describes how we avoid long mutator

  *    pauses during the sync phase

  *

  *

  *  - Note [Segment allocation strategy] explains our segment allocation strategy.

  *

  * Concurrency-control of non-moving garbage collection is a bit tricky. There

  * are a few things to keep in mind:

  *

  *

  *    stopAllCapabilitiesWith(SYNC_FLUSH_UPD_REM_SET). Capabilities are held

  *    the final mark has concluded.

  *

  *        ╰─────────────────╯

  *                    ┆

  *

  * collector], the MVAR_TSO_QUEUE will be evacuated. If MVAR_TSO_QUEUE is aged

  * (e.g. evacuated to the young generation) then the MVAR will be added to the

  * mark queue. Consequently, we will falsely conclude that the MVAR is still

  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

  * The nonmoving collector uses an approximate heuristic for reporting live

  * data quantity. Specifically, during mark we record how much live data we

  * oldest_gen->live_estimate).

  *

  * In addition, we update oldest_gen->live_estimate every time we fill a

  *  - Minor collections assume that all sparks living in the non-moving heap

  *    are reachable.

  *

  *

  *

  * Note [Dirty flags in the non-moving collector]

  * In the non-moving collector we use the same dirty flag to implement a

  * related optimisation on the non-moving write barrier: Specifically, the

  * snapshot invariant only requires that the non-moving write barrier applies

  *

  *     An object being marked as dirty implies that all of its fields are on

  *     the mark queue (or, equivalently, update remembered set).

  *                        ┊

  *

  * This is bad. When we resume mutation a mutator may mutate MVAR A; since it's

  *

  * To avoid this nonmovingScavengeOne we eagerly pushes the values of the

  * fields of all objects which it fails to evacuate (e.g. MVAR A) to the update

  * Note [Allocator sizes]

  * ~~~~~~~~~~~~~~~~~~~~~~

  * Our choice of allocator sizes has to balance several considerations:

  * - It should be possible to efficiently determine which allocator services

  *   a certain block size.

  * - The amount of allocators should be kept down to avoid overheads

  *   arbitrary allocator sizes, we need to do some precomputation and make

  *   use of the integer division by constants optimisation.

  *

  * These service the vast majority of allocations.

  * In practice, Haskell programs tend to allocate a lot of small objects.

  *

  *

  * See #23340

  *

  * quick.

  *

  * See #24150

  */

 memcount nonmoving_segment_live_words = 0;

     else:

         return normal;

 def expect_fail( name, opts ):

     # The compiler, testdriver, OS or platform is missing a certain

     # feature, and we don't plan to or can't fix it now or in the

 def normalise_version_( *pkgs ):

     def normalise_version__( str ):

         # (name)(-version)(-hash)(-components)

                       r'\1-<VERSION>-<HASH>', str)

     return normalise_version__

     # of whether we expected the compilation to fail or not (successful

     # compilations may generate warnings).

     actual_stderr_file = add_suffix(name, 'comp.stderr')

     diff_file_name = in_testdir(add_suffix(name, 'comp.diff'))

     # of whether we expected the compilation to fail or not (successful

     # compilations may generate warnings).

     actual_asm_file = add_suffix(name, 's')

     if not await compare_outputs(way, 'asm',

     if badResult(result):

         return result

     actual_asm_file = add_suffix(name, 's')

     if not grep_output(join_normalisers(normalise_errmsg),

     if badResult(result):

         return result

     actual_core_file = add_suffix(name, 'dump-simpl')

     if not grep_output(join_normalisers(normalise_errmsg),

             return result

         if compile_stderr:

             actual_stderr_file = add_suffix(name, 'comp.stderr')

             diff_file_name = in_testdir(add_suffix(name, 'comp.diff'))

 async def stdout_ok(name: TestName, way: WayName) -> bool:

    actual_stdout_file = add_suffix(name, 'run.stdout')

    extra_norm = join_normalisers(normalise_output, getTestOpts().extra_normaliser)

 async def stderr_ok(name: TestName, way: WayName) -> bool:

    actual_stderr_file = add_suffix(name, 'run.stderr')

    return await compare_outputs(way, 'stderr',

                           join_normalisers(normalise_errmsg, getTestOpts().extra_errmsg_normaliser), \

         return False

 async def check_prof_ok(name: TestName, way: WayName) -> bool:

     expected_prof_path = in_testdir(expected_prof_file)

     # Check actual prof file only if we have an expected prof file to

 # Finding the sample output.  The filename is of the form

 #

 #

     basename = add_suffix(name, suff)

     # Override the basename if the user has specified one, this will then be

     # subjected to the same name mangling scheme as normal to allow platform

     # specific overrides to work.

     basename = getTestOpts().use_specs.get(suff, basename)

              for plat in ['-' + config.platform, '-' + config.os, '']

     for f in files:

         if in_srcdir(f).exists():

 test('arr015', when(fast(), skip), compile_and_run, [''])

 test('arr017', when(fast(), skip), compile_and_run, [''])

 test('arr018', when(fast(), skip), compile_and_run, [''])

 test('T21962', normal, compile_and_run, [''])

 # -----------------------------------------------------------------------------

 # These tests we do even for 'make fast'

 if ('threaded1' in config.run_ways):

    only_threaded_ways = only_ways(['ghci','threaded1','threaded2', 'nonmoving_thr'])

 else:

    only_threaded_ways = skip

 # this test gives slightly different results for non-threaded ways, so omit

 # those for now.

 test('conc070', only_threaded_ways, compile_and_run, [''])

 # times out with ghci

 test('T4030', omit_ghci, compile_and_run, ['-O'])

 test('mask001', normal, compile_and_run, [''])

 test('mask002', js_broken(22261), compile_and_run, [''])

 test('T5238', normal, compile_and_run, [''])

 test('T5866', exit_code(1), compile_and_run, [''])

 test('tryReadMVar1', normal, compile_and_run, [''])

 test('tryReadMVar2', normal, compile_and_run, [''])

 setTestOpts(when(fast(), skip))

 test('conc007', extra_run_opts('+RTS -H128M -RTS'), compile_and_run, [''])

 test('conc008', normal, compile_and_run, [''])

 test('conc009', exit_code(1), compile_and_run, [''])

 test('conc040', [exit_code(1), omit_ghci, js_skip], compile_and_run, [''])

 # STM-related tests.

 test('conc059',

      [only_ways(['threaded1', 'threaded2', 'nonmoving_thr']),

       pre_cmd('$MAKE -s --no-print-directory conc059_setup')],

      compile_and_run, ['conc059_c.c -no-hs-main'])

 test('T20696', [extra_files(['A.hs', 'B.hs', 'C.hs'])

                , unless(ghc_dynamic(), skip)], multimod_compile, ['A', ''])

 test('T20696-static', [extra_files(['A.hs', 'B.hs', 'C.hs'])

                , when(ghc_dynamic(), skip)], multimod_compile, ['A', ''])

 # Check linking works when using -fbyte-code-and-object-code

 test('fat011', [req_th, extra_files(['FatMain.hs', 'FatTH.hs', 'FatQuote.hs'])], multimod_compile, ['FatMain', '-fbyte-code-and-object-code -fprefer-byte-code'])

 # Check that we use interpreter rather than enable dynamic-too if needed for TH

 # Check that no objects are generated if using -fno-code and -fprefer-byte-code

 test('fat013', [req_th, req_bco, extra_files(['FatTH.hs', 'FatQuote.hs'])], multimod_compile, ['FatTH', '-fno-code -fprefer-byte-code'])

 # When using interpreter should not produce objects

 test('fat014', [req_th, extra_files(['FatTH.hs', 'FatQuote.hs']), extra_run_opts('-fno-code')], ghci_script, ['fat014.script'])

 test('T22807', [req_th, unless(ghc_dynamic(), skip), extra_files(['T22807A.hs', 'T22807B.hs'])]

              , makefile_test, ['T22807'])

 test('T22807_ghci', [req_th, unless(ghc_dynamic(), skip), extra_files(['T22807_ghci.hs'])]

 test('SI04', [extra_files(["SI01A.hs"])], multimod_compile, ['SI04', '-v0'])

 test('SI05', [extra_files(["SI01A.hs"])], multimod_compile_fail, ['SI05', '-v0'])

 test('SI06', [extra_files(["SI01A.hs"])], multimod_compile, ['SI06', '-v0'])

 # Instance tests

 test('SI08', [extra_files(["ClassA.hs", "InstanceA.hs"])], multimod_compile_fail, ['SI08', '-v0'])

 test('SI09', [extra_files(["ClassA.hs", "InstanceA.hs"])], multimod_compile, ['SI09', '-v0'])

 test('QQTopError', normal, compile_fail, ['-fdiagnostics-show-caret'])

 test('GadtConSigs_th_pprint1', normal, compile, [''])

 test('GadtConSigs_th_dump1', normal, compile, ['-v0 -ddump-splices -dsuppress-uniques'])