{-# LANGUAGE MultiWayIf #-}

 {-# LANGUAGE ParallelListComp #-}

 {-# LANGUAGE NondecreasingIndentation #-}

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

 --

 import GHC.Types.Tickish ( GenTickish(..) )

 import GHC.Types.SrcLoc  ( srcSpanFile, srcSpanStartLine, srcSpanStartCol )

 -- The rest:

 import GHC.Data.Maybe ( expectJust )

 import GHC.Types.ForeignCall ( CCallConv(..) )

 getRegisterReg platform  (CmmGlobal mid)

   = case globalRegMaybe platform $ globalRegUse_reg mid of

         Nothing  -> pprPanic "getRegisterReg-memory" (ppr $ CmmGlobal mid)

         -- By this stage, the only MagicIds remaining should be the

         -- ones which map to a real machine register on this

   -- | The code to assign arguments to registers used for argument passing.

   , assignArgsCode :: InstrBlock

   }

 -- | An argument passed on the stack, either directly or by reference.

 --

 {-# LANGUAGE CPP #-}

 {-# LANGUAGE MultiWayIf #-}

 {-# OPTIONS_GHC -fno-warn-type-defaults #-}

 -- | Handle conversion of CmmProc to LLVM code.

 module GHC.CmmToLlvm.CodeGen ( genLlvmProc ) where

 import GHC.Data.Maybe (expectJust)

 import GHC.Data.OrdList

 import GHC.Types.ForeignCall

 import GHC.Types.Unique.DSM

 import GHC.Types.Unique

 -- | A more convenient way of accumulating LLVM statements and declarations.

 data LlvmAccum = LlvmAccum LlvmStatements [LlvmCmmDecl]

 liftExprData :: LlvmM ExprData -> WriterT LlvmAccum LlvmM LlvmVar

 liftExprData action = do

 {-

 A simple homogeneous pair type with useful Functor, Applicative, and

 Traversable instances.

 import GHC.Utils.Outputable

 import qualified Data.Semigroup as Semi

 data Pair a = Pair { pFst :: a, pSnd :: a }

 -- Note that Pair is a *unary* type constructor

 -- whereas (,) is binary

   pure x = Pair x x

   (Pair f g) <*> (Pair x y) = Pair (f x) (g y)

 instance Outputable a => Outputable (Pair a) where

   ppr (Pair a b) = ppr a <+> char '~' <+> ppr b

 {-# LANGUAGE TypeFamilies #-}

 {-# LANGUAGE UndecidableInstances #-} -- Wrinkle in Note [Trees That Grow]

                                        -- in module Language.Haskell.Syntax.Extension

 {-# OPTIONS_GHC -Wno-orphans #-} -- NamedThing, Outputable, OutputableBndrId

 {-

 import GHC.Core.Type

 import GHC.Core.Multiplicity( pprArrowWithMultiplicity )

 import GHC.Hs.Doc

 import GHC.Types.Basic

 import GHC.Types.SrcLoc

 import GHC.Utils.Outputable

     hstpb_imp_tvs :: Bag Name,

     hstpb_exp_tvs :: Bag Name

   }

 tpBuilderExplicitTV :: Name -> HsTyPatRnBuilder

 tpBuilderExplicitTV name = mempty {hstpb_exp_tvs = unitBag name}

     hstpb_imp_tvs = listToBag hsps_imp_tvs

   }

 buildHsTyPatRn :: HsTyPatRnBuilder -> HsTyPatRn

 buildHsTyPatRn HsTPRnB {hstpb_nwcs, hstpb_imp_tvs, hstpb_exp_tvs} =

   HsTPRn {

 -- | This module coverage checks pattern matches. It finds

 --

 --     * Uncovered patterns, certifying non-exhaustivity

 import GHC.HsToCore.Monad

 import GHC.Data.Bag

 import GHC.Data.OrdList

 import Control.Monad (when, unless, forM_)

 import qualified Data.Semigroup as Semi

   , cirb_red   :: !(OrdList SrcInfo) -- ^ Redundant clauses

   , cirb_bangs :: !(OrdList SrcInfo) -- ^ Redundant bang patterns

   }

 -- See Note [Determining inaccessible clauses]

 ensureOneNotRedundant :: CIRB -> CIRB

 {-# LANGUAGE ViewPatterns        #-}

 {-# LANGUAGE MultiWayIf          #-}

 {-# LANGUAGE TypeFamilies        #-}

 -- | Domain types used in "GHC.HsToCore.Pmc.Solver".

 -- The ultimate goal is to define 'Nabla', which models normalised refinement

 import GHC.Types.SourceText (SourceText(..), mkFractionalLit, FractionalLit

                             , fractionalLitFromRational

                             , FractionalExponentBase(..))

 import Numeric (fromRat)

 import Data.Ratio

 -- | A disjunctive bag of 'Nabla's, representing a refinement type.

 newtype Nablas = MkNablas (Bag Nabla)

 initNablas :: Nablas

 initNablas = MkNablas (unitBag initNabla)

 -- | The type oracle state. An 'GHC.Tc.Solver.Monad.InertSet' that we

 -- incrementally add local type constraints to, together with a sequence

 -- number that counts the number of times we extended it with new facts.

 import GHC.Runtime.Interpreter

 import GHC.Utils.Exception

 import GHC.Utils.Logger

 import Data.List (isPrefixOf, nub, sort, intersperse, intercalate)

 import Data.Char

 {-# LANGUAGE ApplicativeDo              #-}

 {-# LANGUAGE DerivingVia                #-}

 {-# LANGUAGE TypeFamilies               #-}

 import GHC.Parser.Lexer

 import GHC.Parser.HaddockLex

 import GHC.Parser.Errors.Types

 import GHC.Utils.Misc (mergeListsBy, filterOut, (<&&>))

 import qualified GHC.Data.Strict as Strict

     { loc_range_from :: !LowerLocBound,

       loc_range_to   :: !UpperLocBound,

       loc_range_col  :: !ColumnBound }

 -- The location range from the specified position to the end of the file.

 locRangeFrom :: Strict.Maybe BufPos -> LocRange

 {-# LANGUAGE DuplicateRecordFields #-}

 {-# LANGUAGE MultiWayIf            #-}

 {-# LANGUAGE RecursiveDo           #-}

 {-# OPTIONS_GHC -Wno-incomplete-record-updates #-}

 {-

 import GHC.Utils.Panic

 import GHC.Utils.Constants (debugIsOn)

 import Control.Monad

 import Data.IORef

 import GHC.Data.Maybe

          -- These are covars. Included only so that we don't repeatedly

          -- look at covars' kinds in accumulator. Not used by quantifyTyVars.

     }

 instance Outputable CandidatesQTvs where

   ppr (DV {dv_kvs = kvs, dv_tvs = tvs, dv_cvs = cvs })

 import Data.Coerce

 import Data.Data

 -- See Note [UniqSet invariant] in GHC.Types.Unique.Set for why we want a newtype here.

 -- Beyond preserving invariants, we may also want to 'override' typeclass

 pprUniqDSet :: (a -> SDoc) -> UniqDSet a -> SDoc

 pprUniqDSet f = braces . pprWithCommas f . uniqDSetToList

 import qualified Data.ByteString.Internal as BS

 import qualified Data.ByteString.Unsafe   as BS

 import qualified Data.ByteString.Short.Internal as SBS

 import Data.IORef

 import Data.Char                ( ord, chr )

 import Data.List.NonEmpty       ( NonEmpty(..))

 putSBS bh sbs = do

   let l = SBS.length sbs

   put_ bh l

 getSBS :: ReadBinHandle -> IO SBS.ShortByteString

 getSBS bh = do

   l <- get bh :: IO Int

 putBS :: WriteBinHandle -> ByteString -> IO ()

 putBS bh bs =

   get bh = LBS.fromStrict <$> get bh

 instance Binary FastString where

   put_ bh f =

     case findUserDataWriter (Proxy :: Proxy FastString) bh of

 module GHC.Utils.Ppr.Colour where

 import GHC.Prelude.Basic

 import Data.Maybe (fromMaybe)

 import GHC.Data.Bool

 -- | A colour\/style for use with 'coloured'.

 newtype PprColour = PprColour { renderColour :: String }

 renderColourAfresh :: PprColour -> String

 renderColourAfresh c = renderColour (colReset `mappend` c)

                    process    >= 1   && < 1.7,

                    bytestring >= 0.11 && < 0.13,

                    binary     == 0.8.*,

                    time       >= 1.4 && < 1.16,

                    containers >= 0.6.2.1 && < 0.9,

                    array      >= 0.1 && < 0.6,

 # CPP, CPPFLAGS

 # --with-cpp/-with-cpp-flags

 FP_CPP_CMD_WITH_ARGS([$CC_STAGE0],[CPPCmd_STAGE0],[CONF_CPP_OPTS_STAGE0])

 FP_CPP_CMD_WITH_ARGS([$CC],[CPPCmd],[CONF_CPP_OPTS_STAGE1])

 FP_CPP_CMD_WITH_ARGS([$CC],[CPPCmd],[CONF_CPP_OPTS_STAGE2])

 # CPP, CPPFLAGS

 # --with-cpp/-with-cpp-flags

 FP_CPP_CMD_WITH_ARGS([$CC_STAGE0],[CPPCmd_STAGE0],[CONF_CPP_OPTS_STAGE0])

 FP_CPP_CMD_WITH_ARGS([$CC],[CPPCmd],[CONF_CPP_OPTS_STAGE1])

 FP_CPP_CMD_WITH_ARGS([$CC],[CPPCmd],[CONF_CPP_OPTS_STAGE2])

 import           GHC.Types.SrcLoc

 import           GHC.Types.Var

 import qualified GHC.Data.Strict as Strict

 import           GHCi.UI.Exception

 getModInfo :: (GhcMonad m) => Module -> m ModInfo

 getModInfo m = do

     mod_summary <- getModSummary m

     p <- parseModule mod_summary

     typechecked <- typecheckModule p

     let allTypes = processAllTypeCheckedModule typechecked

   AC_MSG_RESULT([no])

 fi

 $2="$CMM_CPP_CMD"

 $3="$$3 $CMM_CPP_ARGS"

 #define __STDC_VERSION__ 0

 #endif

 #endif

 /*

 #if !defined(IN_STG_CODE)

 # define IN_STG_CODE 1

 // We need _BSD_SOURCE so that math.h defines things like gamma

 // on Linux

 # define _BSD_SOURCE

                      pre_cmd('$MAKE -s --no-print-directory T2276_ghci_setup ghciWayFlags=' + config.ghci_way_flags) ],

                    compile_and_run, ['-fobject-code T2276_ghci_c.o'])

 test('T2594', [req_c], compile_and_run, ['T2594_c.c'])

      compile_fail,

      ['-package-db T20803-plugin/pkg.T20803b/local.package.conf -fplugin AddErrorPlugin -package T20803-plugin ' + config.plugin_way_flags])

 test('test-echo-in-turn',

      [extra_files(['echo-plugin/']),

       pre_cmd('$MAKE -s --no-print-directory -C echo-plugin package.test-echo-in-turn TOP={top}')],

     , compileC

     , compileAsm

     , addPlatformDepCcFlags

     ) where

 import Control.Monad

     cc1 <- ignoreUnusedArgs cc0

     cc2 <- ccSupportsTarget archOs llvmTarget cc1

     checking "whether Cc works" $ checkCcWorks cc2

 checkCcWorks :: Cc -> M ()

 checkCcWorks cc = withTempDir $ \dir -> do

     checking "whether Cc supports --target" $

     supportsTarget archOs _ccProgram checkCcWorks target cc

 checkCcSupportsExtraViaCFlags :: Cc -> M ()

 checkCcSupportsExtraViaCFlags cc = checking "whether cc supports extra via-c flags" $ withTempDir $ \dir -> do

   let test_o = dir </> "test.o"

 import GHC.Toolchain.Program

 import GHC.Toolchain.Tools.Cc

 newtype Cpp = Cpp { cppProgram :: Program

                     }

 findCmmCpp :: ProgOpt -> Cc -> M CmmCpp

 findCmmCpp progOpt cc = checking "for a Cmm preprocessor" $ do

   -- Use the specified CPP or try to use the c compiler

   cmmCppSupportsG0 <- withTempDir $ \dir -> do

     let conftest = dir </> "conftest.c"

     writeFile conftest "int main(void) {}"

 findCpp :: ProgOpt -> Cc -> M Cpp

 findCpp progOpt cc = checking "for C preprocessor" $ do

   -- Use the specified CPP or try to use the c compiler

   -- Always add the -E flag to the CPP, regardless of the user options

   return Cpp{cppProgram}

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