freebsd_jobs :: [JobGroup Job]

 freebsd_jobs =

   ]

 alpine_x86 :: [JobGroup Job]

       "ac_cv_func_utimensat": "no"

     }

   },

     "after_script": [

       ".gitlab/ci.sh save_cache",

       ".gitlab/ci.sh save_test_output",

     "artifacts": {

       "expire_in": "1 year",

       "paths": [

         "junit.xml",

         "unexpected-test-output.tar.gz"

       ],

     ],

     "variables": {

       "BIGNUM_BACKEND": "gmp",

       "CABAL_INSTALL_VERSION": "3.10.3.0",

       "CC": "cc",

       "CONFIGURE_ARGS": "--with-iconv-includes=/usr/local/include --with-iconv-libraries=/usr/local/lib --with-system-libffi --with-ffi-includes=/usr/local/include --with-ffi-libraries=/usr/local/lib --with-gmp-includes=/usr/local/include --with-gmp-libraries=/usr/local/lib --enable-strict-ghc-toolchain-check",

       "IGNORE_PERF_FAILURES": "all",

       "INSTALL_CONFIGURE_ARGS": "--enable-strict-ghc-toolchain-check",

       "RUNTEST_ARGS": "",

       "XZ_OPT": "-9"

     }

   },

 ---------------- Applications might generate a call instance --------------------

 specExpr env expr@(App {})

   = do { let (fun_in, args_in) = collectArgs expr

        ; (args_out, uds_args) <- mapAndCombineSM (specExpr env) args_in

        ; let uds_call = mkCallUDs env fun_out' args_out'

 ---------------- Lambda/case require dumping of usage details --------------------

 specExpr env e@(Lam {})

 -- See Note [Specialisation modulo dictionary selectors]

 --     Note [ClassOp/DFun selection]

 --     Note [Fire rules in the specialiser]

 fireRewriteRules env (Var f) args

   | let rules = getRules (se_rules env) f

   , Just (rule, expr) <- specLookupRule env f args activeInInitialPhase rules

   , let rest_args    = drop (ruleArity rule) args -- See Note [Extra args in the target]

                        -- simplOptExpr needed because lookupRule returns

                        --   (\x y. rhs) arg1 arg2

   , (fun', args') <- collectArgs expr'

 fireRewriteRules _ fun args = (fun, args)

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

            ; let all_rule_bndrs = poly_qvars ++ rule_bndrs

                  env' = env { se_subst = subst'' }

                 [ text "fun:       "  <+> ppr fn

                 , text "call info: "  <+> ppr _ci

                 , text "poly_qvars: " <+> ppr poly_qvars

                 , text "useful:    "  <+> ppr useful

                 , text "all_rule_bndrs:"  <+> ppr all_rule_bndrs

                 , text "dx_binds:"   <+> ppr dx_binds

                 , text "spec_args: "  <+> ppr spec_args

                 , text "rhs_bndrs"    <+> ppr rhs_bndrs

              return ()

 -}

              then return spec_acc

              else

              -- Run the specialiser on the specialised RHS

            ; (rhs_body', rhs_uds) <- specExpr env'' rhs_body

            -- Make the RHS of the specialised function

            ; let spec_rhs_bndrs = spec_bndrs ++ inner_rhs_bndrs'

                  (rhs_uds1, inner_dumped_dbs) = dumpUDs spec_rhs_bndrs rhs_uds

 with ->{Many} and gets an argument with ->{m1} or ->{m2}, and Lint

 complains.

 Note [FunTy vs non-FunTy case in tc_sub_type_deep]

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

                           -- GenSigCtxt: See Note [Setting the argument context]

            ; res_wrap  <- tc_sub_type_deep (Result pos) unify inst_orig ctxt act_res exp_res

                act_af act_mult act_arg act_res

                exp_af exp_mult exp_arg exp_res

                arg_wrap res_wrap

       where

         given_orig = GivenOrigin (SigSkol GenSigCtxt exp_arg [])

 mkWpFun_FRR

   -> FunTyFlag -> Type -> TcType -> Type --   actual FunTy

   -> FunTyFlag -> Type -> TcType -> Type -- expected FunTy

   -> HsWrapper -- ^ exp_arg ~> act_arg

   -> HsWrapper -- ^ act_res ~> exp_res

   -> TcM HsWrapper -- ^ act_funTy ~> exp_funTy

        ; let

             exp_arg_fun_co =

               mkFunCo Nominal exp_af

                  (mkReflCo Nominal exp_res)

             act_arg_fun_co =

               mkFunCo Nominal act_af

                  act_arg_co

                  (mkReflCo Nominal act_res)

             arg_wrap_frr =

                --  arg_wrap :: exp_arg ~> act_arg

                --  arg_wrap_frr :: exp_arg_frr ~> act_arg_frr

        ; return $

             mkWpCastN exp_arg_fun_co

               <.>

               <.>

   where

       not (hole_or_cast arg_wrap)

         ||

       not (hole_or_cast res_wrap)

     hole_or_cast WpHole = True

     hole_or_cast (WpCast {}) = True

     hole_or_cast _ = False

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

 deeplySkolemise :: SkolemInfo -> TcSigmaType

         reverse = self.options.get('reverse')

         if reverse is not None and reverse != '':

             # Make this also addressable via the reverse flag

             self.env.domaindata['std']['objects']['ghc-flag', reverse] = \

 # This class inherits from Sphinx's internal GenericObject, which drives

 # the add_object_type() utility function. We want to keep that tooling,

         TestLLC                   -> "LLC"

         TestTEST_CC               -> "TEST_CC"

         TestTEST_CC_OPTS          -> "TEST_CC_OPTS"

         TestGhcPackageDb          -> "GhcGlobalPackageDb"

         TestGhcLibDir             -> "GhcLibdir"

   * Remove deprecated, unstable heap representation details from `GHC.Exts` ([CLC proposal #212](https://github.com/haskell/core-libraries-committee/issues/212))

   * Add `Data.List.NonEmpty.mapMaybe`. ([CLC proposal #337](https://github.com/haskell/core-libraries-committee/issues/337))

   * Fix issues with toRational for types capable to represent infinite and not-a-number values ([CLC proposal #338](https://github.com/haskell/core-libraries-committee/issues/338))

   * Modify the implementation of `Data.List.sortOn` to use `(>)` instead of `compare`. ([CLC proposal #332](https://github.com/haskell/core-libraries-committee/issues/332))

   * `GHC.Exts.IOPort#` and its related operations have been removed  ([CLC #213](https://github.com/haskell/core-libraries-committee/issues/213))

   * Add `thenA` and `thenM`. ([CLC proposal #351](https://github.com/haskell/core-libraries-committee/issues/351))

     recip x             =  1.0 / x

 rationalToFloat :: Integer -> Integer -> Float

 rationalToFloat n 0

     | n == 0        = 0/0

     | n < 0         = (-1)/0

     recip x             =  1.0 / x

 rationalToDouble :: Integer -> Integer -> Double

 rationalToDouble n 0

     | n == 0        = 0/0

     | n < 0         = (-1)/0

 to allow that rule to fire reliably we should delay inlining rationalToFloat

 until stage 0.  (It may get an inlining from CPR analysis.)

 -}

 -- Utils

 -- base

 import Data.Char

 import Data.Maybe

   ( mapMaybe )

 import Data.List

   ( dropWhileEnd )

 -- bytestring

 import qualified Data.ByteString as ByteString

 -- directory

 import System.Directory

 -- filepath

 import System.FilePath

   do { top <- dropWhileEnd isSpace

           <$> readProcess "git" ["rev-parse", "--show-toplevel"] ""

        -- TODO: would be better to avoid using git entirely.

      ; traverseFilesFrom includeFile diagnosticCodesIn testRoot

      }

            { Left  _   -> mempty

            ; Right txt -> parse_contents txt

            } } } }

 static int64_t decodeAddend(ObjectCode * oc, Section * section,

                      MachORelocationInfo * ri);

 static void encodeAddend(ObjectCode * oc, Section * section,

 /* Global Offset Table logic */

 static bool isGotLoad(MachORelocationInfo * ri);

 static void

 encodeAddend(ObjectCode * oc, Section * section,

     uint32_t * p = (uint32_t*)((uint8_t*)section->start + ri->r_address);

     checkProddableBlock(&oc->proddables, (void*)p, 1 << ri->r_length);

     switch (ri->r_type) {

         case ARM64_RELOC_UNSIGNED: {

             switch (ri->r_length) {

                 case 0: *(uint8_t*)p  = (uint8_t)addend; break;

                 case 1: *(uint16_t*)p = (uint16_t)addend; break;

             return;

         }

         case ARM64_RELOC_SUBTRACTOR: {

             switch (ri->r_length) {

                 case 0: *(uint8_t*)p  = (uint8_t)addend; break;

                 case 1: *(uint16_t*)p = (uint16_t)addend; break;

              * do not need the last two bits of the value. If the value >> 2

              * still exceeds 26bits, we won't be able to reach it.

              */

             *p = (*p & 0xFC000000) | ((uint32_t)(addend >> 2) & 0x03FFFFFF);

             return;

         }

              * with the PAGEOFF12 relocation allows to address a relative range

              * of +-4GB.

              */

             *p = (*p & 0x9F00001F) | (uint32_t)((addend << 17) & 0x60000000)

                                    | (uint32_t)((addend >> 9)  & 0x00FFFFE0);

             return;

             /* Store an offset into a page (4k). Depending on the instruction

              * the bits are stored at slightly different positions.

              */

             int shift = 0;

             if(isLoadStore(p)) {

                 MachOSymbol* symbol = &oc->info->macho_symbols[ri->r_symbolnum];

                 int64_t addend = decodeAddend(oc, section, ri);

                 uint64_t value = symbol_value(oc, symbol);

                 break;

             }

             case ARM64_RELOC_SUBTRACTOR:

                 // combine with addend and store

                 int64_t addend = decodeAddend(oc, section, ri);

                 // skip next relocation: we've already handled it

                 i += 1;

                         }

                     }

                 }

                 break;

             }

             case ARM64_RELOC_PAGE21:

                 uint64_t pc = (uint64_t)section->start + ri->r_address;

                 uint64_t value = (uint64_t)(isGotLoad(ri) ? symbol->got_addr : symbol->addr);

                 ASSERT(!isGotLoad(ri) || (symbol->got_addr != 0));

                 // reset, just in case.

                 explicit_addend = 0;

                     barf("explicit_addend and addend can't be set at the same time.");

                 uint64_t value = (uint64_t)(isGotLoad(ri) ? symbol->got_addr : symbol->addr);

                 ASSERT(!isGotLoad(ri) || (symbol->got_addr != 0));

                 // reset, just in case.

                 explicit_addend = 0;

   getGhcFieldOrDefault fields "TargetRTSLinkerOnlySupportsSharedLibs" "target RTS linker only supports shared libraries" "NO"

   getGhcFieldOrDefault fields "GhcDynamic" "GHC Dynamic" "NO"

   getGhcFieldOrDefault fields "GhcProfiled" "GHC Profiled" "NO"

   getGhcFieldOrDefault fields "GhcTablesNextToCode" "Tables next to code" "NO"

   getGhcFieldProgWithDefault fields "AR" "ar command" "ar"

   getGhcFieldProgWithDefault fields "LLC" "LLVM llc command" "llc"

 test('T7130', normal, compile_fail, ['-fflul-laziness'])

 test('T7563', when(unregisterised(), skip), makefile_test, [])

 test('T6037',

      [when(opsys('mingw32'), expect_fail),

      ],

      makefile_test, [])

 test('T2507',

      [when(opsys('mingw32'), expect_fail),

      ],

      makefile_test, [])

 test('T8959a',

      [when(opsys('mingw32'), expect_fail),

      ],

      makefile_test, [])

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

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

 test('T23025', normal, compile, ['-dlinear-core-lint'])

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

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

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

 test('T15108', [test_opts], compile, ['-O -prof -fprof-auto'])

 test('T19894', [test_opts, extra_files(['T19894'])], multimod_compile, ['Main', '-v0 -O2 -prof -fprof-auto -iT19894'])

 test('T20938', [test_opts], compile, ['-O -prof'])

 #include <stdio.h>

 #include <errno.h>

 {

     int open = 0, i;

     sigset_t blockedsigs;

     printf("ChildInfo { masked = [");

     sigprocmask(SIG_BLOCK, NULL, &blockedsigs);

     {

         int ret = sigismember(&blockedsigs, i);

         if(ret >= 0)

     printf("], handlers = [");

     open = 0;

     {

         struct sigaction old;

         if(sigaction(i, NULL, &old) >= 0)

 test('T11223_simple_duplicate_lib',

      [extra_files(['bar.c', 'foo.c', 'foo.hs']),

       req_c],

      makefile_test, ['t_11223_simple_duplicate_lib'])

 test('T11223_link_order_a_b_2_fail',

      [extra_files(['bar.c', 'foo.c', 'foo3.hs']),

       req_c],

      makefile_test, ['t_11223_link_order_a_b_2_fail'])