( \dst ->

                   code

                     `appOL` code_x

               )

         MO_SF_Round from to ->

           pure

               (floatFormat to)

               ( \dst ->

                   code

               )

         -- TODO: Can this case happen?

         MO_FS_Truncate from to

                       code

                         `snocOL`

                         -- W32 is the smallest width to convert to. Decrease width afterwards.

                         `appOL` signExtendAdjustPrecission W32 to dst dst -- (float convert (-> zero) signed)

                   )

         MO_FS_Truncate from to ->

               (intFormat to)

               ( \dst ->

                   code

                     `appOL` truncateReg from to dst -- (float convert (-> zero) signed)

               )

         MO_UU_Conv from to

                     `appOL` truncateReg from to dst

               )

         MO_SS_Conv from to -> ss_conv from to reg code

         MO_WF_Bitcast w    -> return $ Any (floatFormat w)  (\dst -> code `snocOL` MOV (OpReg w dst) (OpReg w reg))

         -- Conversions

         -- TODO: Duplication with MO_UU_Conv

   LDR _ dst src -> usage (regOp src, regOp dst)

   LDRU _ dst src -> usage (regOp src, regOp dst)

   FENCE _ _ -> usage ([], [])

   FABS dst src -> usage (regOp src, regOp dst)

   FMIN dst src1 src2 -> usage (regOp src1 ++ regOp src2, regOp dst)

   FMAX dst src1 src2 -> usage (regOp src1 ++ regOp src2, regOp dst)

     ++ map regSingle [t3RegNo .. t6RegNo]

     ++ map regSingle [ft0RegNo .. ft7RegNo]

     ++ map regSingle [fa0RegNo .. fa7RegNo]

 -- | Apply a given mapping to all the register references in this instruction.

 patchRegsOfInstr :: Instr -> (Reg -> Reg) -> Instr

   LDR f o1 o2 -> LDR f (patchOp o1) (patchOp o2)

   LDRU f o1 o2 -> LDRU f (patchOp o1) (patchOp o2)

   FENCE o1 o2 -> FENCE o1 o2

   FABS o1 o2 -> FABS (patchOp o1) (patchOp o2)

   FMIN o1 o2 o3 -> FMIN (patchOp o1) (patchOp o2) (patchOp o3)

   FMAX o1 o2 o3 -> FMAX (patchOp o1) (patchOp o2) (patchOp o3)

     -- Memory barrier.

     FENCE FenceType FenceType

   | -- | Floating point conversion

   | -- | Floating point ABSolute value

     FABS Operand Operand

 -- | Variant of a floating point conversion instruction

 data FcvtVariant = FloatToFloat | IntToFloat | FloatToInt

 instrCon :: Instr -> String

 instrCon i =

   case i of

       -- no support for widths > W64.

       | otherwise = pprPanic "Unsupported width in register (max is 64)" (ppr w <+> int i)

 -- | Single precission `Operand` (floating-point)

 isSingleOp :: Operand -> Bool

 isSingleOp (OpReg W32 _) = True

   LDRU FF64 o1 o2@(OpAddr (AddrRegImm _ _)) -> op2 (text "\tfld") o1 o2

   LDRU f o1 o2 -> pprPanic "Unsupported unsigned load" ((text . show) f <+> pprOp platform o1 <+> pprOp platform o2)

   FENCE r w -> line $ text "\tfence" <+> pprFenceType r <> char ',' <+> pprFenceType w

     pprPanic "RV64.pprInstr - impossible float to float conversion"

     pprPanic "RV64.pprInstr - impossible integer to float conversion"

     pprPanic "RV64.pprInstr - impossible float to integer conversion"

   FABS o1 o2 | isSingleOp o2 -> op2 (text "\tfabs.s") o1 o2

   FABS o1 o2 | isDoubleOp o2 -> op2 (text "\tfabs.d") o1 o2

   FMIN o1 o2 o3 | isSingleOp o1 -> op3 (text "\tfmin.s") o1 o2 o3

   instr -> panic $ "RV64.pprInstr - Unknown instruction: " ++ instrCon instr

   where

     op2 op o1 o2 = line $ op <+> pprOp platform o1 <> comma <+> pprOp platform o2

     op3 op o1 o2 o3 = line $ op <+> pprOp platform o1 <> comma <+> pprOp platform o2 <> comma <+> pprOp platform o3

     op4 op o1 o2 o3 o4 = line $ op <+> pprOp platform o1 <> comma <+> pprOp platform o2 <> comma <+> pprOp platform o3 <> comma <+> pprOp platform o4

     pprFenceType FenceRead = text "r"

 d7RegNo = 39

 ft7RegNo = d7RegNo

 -- | Last floating point register.

 d31RegNo = 63

 a0RegNo, x10RegNo :: RegNo

 x10RegNo = 10

 module GHC.Data.List.NonEmpty (module Data.List.NonEmpty, module GHC.Data.List.NonEmpty, toList) where

 import Prelude (Bool, (.))

 import Control.Applicative

 import qualified Control.Monad as List (zipWithM)

 import Data.Foldable (Foldable (toList))

 import qualified Data.List as List

 import qualified GHC.Data.List as List

             -- Synthesize the flags

             , packageFlags = packageFlags dflags ++ map (\(uid0, rn) ->

               let uid = unwireUnit unit_state

                         $ renameHoleUnit unit_state (listToUFM insts) uid0

               in ExposePackage

                 (showSDoc dflags

     -- The compilation dependencies are just the appropriately filled

     -- in unit IDs which must be compiled before we can compile.

     let hsubst = listToUFM insts

     -- Build dependencies OR make sure they make sense. BUT NOTE,

     -- we can only check the ones that are fully filled; the rest

     -- we have to defer until we've typechecked our local signature.

     -- TODO: work this into GHC.Driver.Make!!

         case session of

             TcSession -> return ()

     mb_old_eps <- case session of

                     TcSession -> fmap Just getEpsGhc

               && not (isOneShot (ghcMode dflags))

             then return (Failed (HomeModError mod loc))

             else do

                 case r of

                   Failed err

                     -> return (Failed $ BadIfaceFile err)

                   Succeeded (iface,_fp)

                     -> do

                                                  (setDynamicNow dflags) wanted_mod

                                                  iface loc

                         case r2 of

                               err

 -- | Check if we need to try the dynamic interface for -dynamic-too

                        -> Module -> ModIface -> ModLocation

                        -> IO (MaybeErr MissingInterfaceError ())

   -- Indefinite interfaces are ALWAYS non-dynamic.

   | not (moduleIsDefinite (mi_module iface)) = return (Succeeded ())

   | otherwise = return (Succeeded ())

                  -> Module -> ModIface -> ModLocation

                  -> IO (MaybeErr MissingInterfaceError ())

     Succeeded (dynIface, _)

      | mi_mod_hash iface == mi_mod_hash dynIface

      -> return (Succeeded ())

           -> Module -> FilePath

           -> IO (MaybeErr ReadInterfaceError (ModIface, FilePath))

   -- Figure out what is recorded in mi_module.  If this is

   -- a fully definite interface, it'll match exactly, but

         case getModuleInstantiation wanted_mod of

             (_, Nothing) -> wanted_mod

             (_, Just indef_mod) ->

                 (uninstantiateInstantiatedModule indef_mod)

   read_result <- readIface hooks logger dflags name_cache wanted_mod' file_path

   case read_result of

         new_merged = case lookupUniqMap (requirementContext unit_state)

                           (ms_mod_name mod_summary) of

                         Nothing -> []

     if old_merged == new_merged

         then up_to_date logger (text "signatures to merge in unchanged" $$ ppr new_merged)

         else return $ needsRecompileBecause SigsMergeChanged

 A 'VirtUnit' may be indefinite or definite, it depends on whether some holes

 remain in the instantiated unit OR in the instantiating units (recursively).

 Having a fully instantiated (i.e. definite) virtual unit can lead to some issues

 Unit database and indefinite units

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

       (i.e. GHC doesn't correctly call `pprWithUnitState` before pretty-printing a

       UnitId), that's what will be shown to the user so it's no big deal.

 Note [VirtUnit to RealUnit improvement]

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

 As we want them to match we just replace the virtual unit with the installed

 one: for some reason this is called "improvement".

 There is one last niggle: improvement based on the unit database means

 that we might end up developing on a unit that is not transitively

 depended upon by the units the user specified directly via command line

 unit id if the new unit id is part of the 'preloadClosure'; i.e., the

 closure of all the units which were explicitly specified.

 Note [Representation of module/name variables]

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

 In our ICFP'16, we use <A> to represent module holes, and {A.T} to represent

         -- * Reading the package config, and processing cmdline args

         UnitState(..),

         UnitDatabase (..),

         UnitErr (..),

         emptyUnitState,

         lookupPackageName,

         resolvePackageImport,

         searchPackageId,

         listVisibleModuleNames,

         lookupModuleInAllUnits,

 import GHC.Types.Unique.FM

 import GHC.Types.Unique.DFM

 import GHC.Types.Unique.DSet

 import GHC.Types.Unique.Map

 import GHC.Types.Unique

 originEmpty (ModOrigin Nothing [] [] False) = True

 originEmpty _ = False

 -- | 'UniqFM' map from 'Unit' to a 'UnitVisibility'.

 type VisibilityMap = UniqMap Unit UnitVisibility

   -- may have the 'exposed' flag be 'False'.)

   unitInfoMap :: UnitInfoMap,

   -- | A mapping of 'PackageName' to 'UnitId'. If several units have the same

   -- package name (e.g. different instantiations), then we return one of them...

   -- This is used when users refer to packages in Backpack includes.

 emptyUnitState :: UnitState

 emptyUnitState = UnitState {

     unitInfoMap    = emptyUniqMap,

     packageNameMap = emptyUFM,

     wireMap        = emptyUniqMap,

     unwireMap      = emptyUniqMap,

 -- | Find the unit we know about with the given unit, if any

 lookupUnit :: UnitState -> Unit -> Maybe UnitInfo

 -- | A more specialized interface, which doesn't require a 'UnitState' (so it

 -- can be used while we're initializing 'DynFlags')

 -- Parameters:

 --    * a boolean specifying whether or not to look for on-the-fly renamed interfaces

 --    * a 'UnitInfoMap'

    HoleUnit   -> error "Hole unit"

    RealUnit i -> lookupUniqMap pkg_map (unDefinite i)

    VirtUnit i

       | allowOnTheFlyInst

       -> -- lookup UnitInfo of the indefinite unit to be instantiated and

          -- instantiate it on-the-fly

            (lookupUniqMap pkg_map (instUnitInstanceOf i))

       | otherwise

 applyPackageFlag

    :: UnitPrecedenceMap

    -> UnitInfoMap

    -> UnusableUnits

    -> Bool -- if False, if you expose a package, it implicitly hides

            -- any previously exposed packages with the same name

    -> PackageFlag             -- flag to apply

    -> MaybeErr UnitErr VisibilityMap -- Now exposed

   case flag of

     ExposePackage _ arg (ModRenaming b rns) ->

          Left ps     -> Failed (PackageFlagErr flag ps)

          Right (p:_) -> Succeeded vm'

           where

          _ -> panic "applyPackageFlag"

     HidePackage str ->

          Left ps  -> Failed (PackageFlagErr flag ps)

          Right ps -> Succeeded $ foldl' delFromUniqMap vm (map mkUnit ps)

 -- if the 'UnitArg' has a renaming associated with it.

 findPackages :: UnitPrecedenceMap

              -> UnitInfoMap

              -> PackageArg -> [UnitInfo]

              -> UnusableUnits

              -> Either [(UnitInfo, UnusableUnitReason)]

                 [UnitInfo]

   = let ps = mapMaybe (finder arg) pkgs

     in if null ps

         then Left (mapMaybe (\(x,y) -> finder arg x >>= \x' -> return (x',y))

             -> Just p

           VirtUnit inst

             | instUnitInstanceOf inst == unitId p

           _ -> Nothing

 selectPackages :: UnitPrecedenceMap -> PackageArg -> [UnitInfo]

         else Right (sortByPreference prec_map ps, rest)

 -- | Rename a 'UnitInfo' according to some module instantiation.

     let hsubst = listToUFM insts

         new_insts = map (\(k,v) -> (k,smod v)) (unitInstantiations conf)

     in conf {

         unitInstantiations = new_insts,

   -- user tries to enable an unusable package, we should let them know.

   --

   vis_map2 <- mayThrowUnitErr

                         (unitConfigHideAll cfg) pkgs1)

                             vis_map1 other_flags

                         | otherwise = vis_map2

                 plugin_vis_map2

                     <- mayThrowUnitErr

                                 hide_plugin_pkgs pkgs1)

                              plugin_vis_map1

                              (reverse (unitConfigFlagsPlugins cfg))

                     $ closeUnitDeps pkg_db

                     $ zip (map toUnitId preload3) (repeat Nothing)

       mod_map2 = mkUnusableModuleNameProvidersMap unusable

       mod_map = mod_map2 `plusUniqMap` mod_map1

          , explicitUnits                = explicit_pkgs

          , homeUnitDepends              = home_unit_deps

          , unitInfoMap                  = pkg_db

          , moduleNameProvidersMap       = mod_map

          , packageNameMap               = pkgname_map

          , wireMap                      = wired_map

          , unwireMap                    = listToUniqMap [ (v,k) | (k,v) <- nonDetUniqMapToList wired_map ]

   :: Logger

   -> UnitConfig

   -> UnitInfoMap

   -> VisibilityMap

   -> ModuleNameProvidersMap

     -- What should we fold on?  Both situations are awkward:

     --

     --    * Folding on the visibility map means that we won't create

     hiddens = [(m, mkModMap pk m ModHidden) | m <- hidden_mods]

     pk = mkUnit pkg

                         `orElse` pprPanic "unit_lookup" (ppr uid)

     exposed_mods = unitExposedModules pkg

    where

       PackageName fs = unitPackageName info

     -- NB: suppose that we want to compare the instantiated

     -- unit p[H=impl:H] against p+abcd (where p+abcd

     -- happens to be the existing, installed version of

     -- p[H=impl:H].  If we *only* wrap in p[H=impl:H]

     -- VirtUnit, they won't compare equal; only

     -- after improvement will the equality hold.

 -- | Substitution on module variables, mapping module names to module

 -- @p[A=\<A>]:B@ maps to @p[A=q():A]:B@ with @A=q():A@;

 -- similarly, @\<A>@ maps to @q():A@.

 renameHoleModule :: UnitState -> ShHoleSubst -> Module -> Module

 -- | Substitutes holes in a 'Unit', suitable for renaming when

 -- an include occurs; see Note [Representation of module/name variables].

 --

 -- @p[A=\<A>]@ maps to @p[A=\<B>]@ with @A=\<B>@.

 renameHoleUnit :: UnitState -> ShHoleSubst -> Unit -> Unit

 -- so it can be used by "GHC.Unit.State".

   | not (isHoleModule m) =

         in mkModule uid (moduleName m)

   | Just m' <- lookupUFM env (moduleName m) = m'

   -- NB m = <Blah>, that's what's in scope.

   | otherwise = m

 -- so it can be used by "GHC.Unit.State".

     case uid of

       (VirtUnit

         InstantiatedUnit{ instUnitInstanceOf = cid

                         , instUnitHoles      = fh })

           -> if isNullUFM (intersectUFM_C const (udfmToUfm (getUniqDSet fh)) env)

                 then uid