import Language.Haskell.Syntax.Extension

 import Language.Haskell.Syntax.Module.Name

 type instance Anno (WithHsDocIdentifiers (HsDocString (GhcPass pass)) (GhcPass pass)) = SrcSpan

 deriving instance (Data pass, Data (LIdP pass), Data a) => Data (WithHsDocIdentifiers a pass)

 -- but pass-independent, source location

 type XRecGhc a = GenLocated (Anno a) a

 type instance Anno (HsDocString (GhcPass _))  = SrcSpan

 type instance Anno HsDocStringChunk           = SrcSpan

              mg = MG{ mg_alts = L (l2l $ getLoc match) [match]

                     , mg_ext = MatchGroupTc [] res_ty gen

                     }

        -- Add INLINE pragmas; see Note [Pragmas for pattern synonyms]

        -- NB: prag_fn is keyed by the PatSyn Name, not the (internal) matcher name

          let builder_id = mkExportedVanillaId builder_name builder_ty

                          -- See Note [Exported LocalIds] in GHC.Types.Id

                              + (if need_dummy_arg then 1 else 0)

        -- Add INLINE pragmas; see Note [Pragmas for pattern synonyms]

 When no pragma is provided for a pattern, the inlining decision might change

 between different versions of GHC.

  -}

 # versions of LLVM simultaneously, but that stopped working around

 # 3.5/3.6 release of LLVM.

 LlvmMinVersion=13  # inclusive

 AC_SUBST([LlvmMinVersion])

 AC_SUBST([LlvmMaxVersion])

 test('hWaitForInput-accurate-stdin', [js_broken(22349), expect_broken_for(16535, threaded_ways), req_process], compile_and_run, [''])

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

 test('T9848',

         , only_ways(['normal'])

         , js_broken(22261)

         ],

  * store only up to (max_era - 1) as its creation or last use time.

  * -------------------------------------------------------------------------- */

 unsigned int era;

 static uint32_t max_era;

 StgWord user_era;

         n_censuses = 1;

     }

     // max_era = 2^LDV_SHIFT

     max_era = 1 << LDV_SHIFT;

     censuses = stgMallocBytes(sizeof(Census) * n_censuses, "initHeapProfiling");

 // See Note [Maximum event length]

 #define EVENT_LOG_SIZE 2 * (1024 * 1024) // 2MB

 // Struct for record keeping of buffer to store event types and events.

 //

 // Invariant: The event buffer will always begin with a block-start marker.

         }

         resetEventsBuf(ebuf);

         postBlockMarker(ebuf);

     }

   return __atomic_fetch_nand((volatile StgWord64 *) x, val, __ATOMIC_SEQ_CST);

 }

 // FetchOrByteArrayOp_Int

 StgWord hs_atomic_or8(StgWord x, StgWord val)

 test writer anymore. This is due to the fact that the test comparison relies

 entirely on locally collected metrics on the testing machine.

 The function `collect_compiler_stats()` is completely equivalent in every way to

 `collect_stats` except that it measures the performance of the compiler itself

 from testglobals import config, ghc_env, default_testopts, brokens, t, \

                         TestRun, TestResult, TestOptions, PerfMetric

 from testutil import strip_quotes, lndir, link_or_copy_file, passed, \

                      stable_perf_counters, \

                      PassFail, badResult, str_warn, str_removeprefix

 from term_color import Color, colored_if

 # -----

 #

 # collect_compiler_stats is used when the metrics collected are about the compiler.

 # collect_stats is used in the majority case when the metrics to be collected

 # are about the performance of the runtime code generated by the compiler.

     def f(name, opts, m=metric, d=deviation):

         no_lint(name, opts)

         return _collect_stats(name, opts, m, d, None, True)

     return f

     return lambda name, opts, m=metric, d=deviation, s=static_stats_file: _collect_stats(name, opts, m, d, s)

 def statsFile(comp_test: bool, name: str) -> str:

         # This is a bit weird, though.

         return

     if isinstance(metrics, str):

     opts.is_stats_test = True

     if is_compiler_stats_test:

 writeByteArray# _   _   []          s = s

 writeByteArray# mba off (I64# i:is) s =

   case writeInt64Array# mba off i s of

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

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

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

       ],

       compile,

       ['-v0 -O'])

 test('T15630',

       ],

       compile,

       ['-O2'])

 test('T15630a',

       ],

       compile,

       ['-O2'])

       compile,

       [''])

 test('T11545',

      compile, ['-O'])

 test('T15304',

      compile, ['-O'])

 test ('T20049',

       [ collect_compiler_stats('bytes allocated',2) ],

      collect_compiler_runtime(4),

      compile, ['-fdefer-type-errors -fno-max-valid-hole-fits -package ghc'])

 test ('T20261',

       compile,

       [''])

 # does not sensibly handle one test acting as both

 # a compile-time and a run-time performance test

 test('T21839c',

         only_ways(['normal'])],

     compile,

     ['-O'])

      ghci_script,

      ['interpreter_steplocal.script'])

 test ('T26425',

       compile,

       ['-O'])

     return test(

         f'large-project-makedepend-{num}',

         [

             pre_cmd(f'./large-project.sh {num}'),

             extra_files(['large-project.sh']),

             ignore_stderr,

 go !a i !acc

     | i < 1     = return acc

     | otherwise = do

          go a (i-1) (c+acc)

 setTestOpts(js_skip)

 test('space_leak_001',

      [ collect_stats('bytes allocated',5),

       collect_runtime_residency(15),

       omit_ways(['profasm','profthreaded','threaded1','threaded2',

       e' <- markAnnotated e

       return (HsCmdLet (tkLet', tkIn') binds' e')

     debugM $ "HsCmdDo"

     loc' <- printStringAtAA loc "do"

     (an1,es') <- markAnnList' an0 $ do

       return ee

 -- ---------------------------------------------------------------------

       Just (initStmts, ls@(L _ (LastStmt _ _body _ _))) -> do

         debugM $ "LocatedL [ExprLStmt: snocView"

         ls' <- markAnnotated ls

         return (initStmts' ++ [ls'])

       _ -> do

         return stmts'

 instance ExactPrint [Located HsDocStringChunk] where

 -- Max llvm version (exclusive)

 maxLlvmVersionExcl :: Int

 -- Max llvm version (inclusive)

 maxLlvmVersion :: Int