ghc-lib 0.20220801 → 0.20220901
raw patch · 106 files changed
+2878/−2263 lines, 106 filesdep ~basedep ~ghc-lib-parser
Dependency ranges changed: base, ghc-lib-parser
Files
- compiler/CodeGen.Platform.h +8/−0
- compiler/GHC/Cmm/CommonBlockElim.hs +9/−10
- compiler/GHC/Cmm/DebugBlock.hs +8/−8
- compiler/GHC/Cmm/Info/Build.hs +2/−2
- compiler/GHC/Cmm/Lint.hs +2/−1
- compiler/GHC/Cmm/Parser.y +1/−1
- compiler/GHC/Cmm/Sink.hs +1/−1
- compiler/GHC/CmmToAsm.hs +3/−3
- compiler/GHC/CmmToAsm/AArch64.hs +1/−1
- compiler/GHC/CmmToAsm/AArch64/CodeGen.hs +4/−2
- compiler/GHC/CmmToAsm/AArch64/Ppr.hs +50/−53
- compiler/GHC/CmmToAsm/AArch64/Regs.hs +2/−8
- compiler/GHC/CmmToAsm/Dwarf.hs +5/−5
- compiler/GHC/CmmToAsm/Dwarf/Types.hs +27/−27
- compiler/GHC/CmmToAsm/PIC.hs +1/−1
- compiler/GHC/CmmToAsm/PPC/CodeGen.hs +1/−1
- compiler/GHC/CmmToAsm/PPC/Ppr.hs +27/−28
- compiler/GHC/CmmToAsm/PPC/Regs.hs +2/−2
- compiler/GHC/CmmToAsm/Ppr.hs +1/−6
- compiler/GHC/CmmToAsm/X86/CodeGen.hs +39/−2
- compiler/GHC/CmmToAsm/X86/Ppr.hs +16/−20
- compiler/GHC/CmmToAsm/X86/Regs.hs +2/−3
- compiler/GHC/CmmToLlvm/Base.hs +16/−4
- compiler/GHC/CmmToLlvm/CodeGen.hs +1/−8
- compiler/GHC/CmmToLlvm/Data.hs +0/−3
- compiler/GHC/Core/LateCC.hs +119/−23
- compiler/GHC/Core/Opt/CSE.hs +2/−2
- compiler/GHC/Core/Opt/DmdAnal.hs +44/−25
- compiler/GHC/Core/Opt/FloatOut.hs +4/−10
- compiler/GHC/Core/Opt/Pipeline.hs +3/−4
- compiler/GHC/Core/Opt/SetLevels.hs +24/−34
- compiler/GHC/Core/Opt/SpecConstr.hs +92/−20
- compiler/GHC/Core/Opt/Specialise.hs +5/−7
- compiler/GHC/Core/Opt/WorkWrap.hs +5/−6
- compiler/GHC/Core/Opt/WorkWrap/Utils.hs +61/−15
- compiler/GHC/CoreToStg/Prep.hs +3/−1
- compiler/GHC/Driver/Backpack.hs +2/−2
- compiler/GHC/Driver/CodeOutput.hs +10/−8
- compiler/GHC/Driver/Config/CmmToAsm.hs +1/−1
- compiler/GHC/Driver/Config/CmmToLlvm.hs +1/−1
- compiler/GHC/Driver/Main.hs +20/−4
- compiler/GHC/Driver/Make.hs +309/−162
- compiler/GHC/Driver/Pipeline.hs +33/−41
- compiler/GHC/Driver/Pipeline/Execute.hs +2/−9
- compiler/GHC/HsToCore/Expr.hs +1/−1
- compiler/GHC/HsToCore/Foreign/C.hs +1/−1
- compiler/GHC/HsToCore/Pmc/Solver.hs +110/−11
- compiler/GHC/HsToCore/Quote.hs +4/−2
- compiler/GHC/HsToCore/Utils.hs +1/−1
- compiler/GHC/Iface/Ext/Utils.hs +1/−1
- compiler/GHC/Iface/Tidy.hs +106/−69
- compiler/GHC/Iface/Tidy/StaticPtrTable.hs +2/−2
- compiler/GHC/Rename/Bind.hs +3/−1
- compiler/GHC/Rename/Env.hs +2/−1
- compiler/GHC/Rename/Expr.hs +5/−3
- compiler/GHC/Rename/HsType.hs +3/−1
- compiler/GHC/Rename/Names.hs +4/−2
- compiler/GHC/Rename/Pat.hs +3/−2
- compiler/GHC/Runtime/Debugger.hs +3/−3
- compiler/GHC/Runtime/Eval.hs +3/−3
- compiler/GHC/Runtime/Heap/Inspect.hs +2/−2
- compiler/GHC/Runtime/Loader.hs +32/−5
- compiler/GHC/Settings/IO.hs +0/−2
- compiler/GHC/Stg/InferTags/Rewrite.hs +18/−0
- compiler/GHC/Stg/Pipeline.hs +1/−1
- compiler/GHC/StgToCmm/Closure.hs +6/−18
- compiler/GHC/StgToCmm/Expr.hs +26/−20
- compiler/GHC/StgToCmm/Layout.hs +1/−1
- compiler/GHC/StgToCmm/Prim.hs +2/−0
- compiler/GHC/StgToCmm/Ticky.hs +1/−1
- compiler/GHC/Tc/Deriv.hs +7/−7
- compiler/GHC/Tc/Deriv/Generate.hs +7/−4
- compiler/GHC/Tc/Deriv/Generics.hs +3/−1
- compiler/GHC/Tc/Deriv/Infer.hs +6/−6
- compiler/GHC/Tc/Deriv/Utils.hs +1/−1
- compiler/GHC/Tc/Gen/Bind.hs +45/−24
- compiler/GHC/Tc/Gen/Expr.hs +7/−4
- compiler/GHC/Tc/Gen/HsType.hs +13/−14
- compiler/GHC/Tc/Gen/Pat.hs +6/−4
- compiler/GHC/Tc/Gen/Splice.hs +2/−7
- compiler/GHC/Tc/Instance/Class.hs +4/−1
- compiler/GHC/Tc/Instance/FunDeps.hs +2/−2
- compiler/GHC/Tc/Module.hs +13/−6
- compiler/GHC/Tc/Solver/Canonical.hs +4/−4
- compiler/GHC/Tc/Solver/Interact.hs +5/−7
- compiler/GHC/Tc/Solver/Monad.hs +3/−3
- compiler/GHC/Tc/TyCl.hs +19/−11
- compiler/GHC/Tc/TyCl/Class.hs +14/−43
- compiler/GHC/Tc/TyCl/Instance.hs +3/−3
- compiler/GHC/Tc/TyCl/PatSyn.hs +10/−11
- compiler/GHC/Tc/TyCl/Utils.hs +4/−2
- compiler/GHC/Tc/Utils/Instantiate.hs +35/−36
- compiler/GHC/Tc/Utils/TcMType.hs +8/−9
- compiler/GHC/Tc/Utils/Unify.hs +2/−2
- compiler/GHC/Tc/Validity.hs +4/−3
- compiler/GHC/ThToHs.hs +6/−2
- ghc-lib.cabal +5/−4
- ghc-lib/stage0/compiler/build/primop-data-decl.hs-incl +2/−0
- ghc-lib/stage0/compiler/build/primop-docs.hs-incl +4/−0
- ghc-lib/stage0/compiler/build/primop-has-side-effects.hs-incl +1/−0
- ghc-lib/stage0/compiler/build/primop-list.hs-incl +2/−0
- ghc-lib/stage0/compiler/build/primop-out-of-line.hs-incl +2/−0
- ghc-lib/stage0/compiler/build/primop-primop-info.hs-incl +3/−1
- ghc-lib/stage0/compiler/build/primop-tag.hs-incl +1308/−1306
- ghc-lib/stage0/lib/settings +0/−1
- ghc-lib/stage0/rts/build/include/GhclibDerivedConstants.h +8/−5
compiler/CodeGen.Platform.h view
@@ -926,6 +926,14 @@ -- ip0 -- used for spill offset computations freeReg 16 = False +#if defined(darwin_HOST_OS) || defined(ios_HOST_OS)+-- x18 is reserved by the platform on Darwin/iOS, and can not be used+-- More about ARM64 ABI that Apple platforms support:+-- https://developer.apple.com/documentation/xcode/writing-arm64-code-for-apple-platforms+-- https://github.com/Siguza/ios-resources/blob/master/bits/arm64.md+freeReg 18 = False+#endif+ # if defined(REG_Base) freeReg REG_Base = False # endif
compiler/GHC/Cmm/CommonBlockElim.hs view
@@ -22,12 +22,12 @@ import qualified Data.List as List import Data.Word import qualified Data.Map as M-import GHC.Utils.Outputable-import GHC.Utils.Panic import qualified GHC.Data.TrieMap as TM import GHC.Types.Unique.FM import GHC.Types.Unique import Control.Arrow (first, second)+import Data.List.NonEmpty (NonEmpty (..))+import qualified Data.List.NonEmpty as NE -- ----------------------------------------------------------------------------- -- Eliminate common blocks@@ -81,7 +81,7 @@ | mapNull new_substs = subst | otherwise = iterate subst' updated_blocks where- grouped_blocks :: [[(Key, [DistinctBlocks])]]+ grouped_blocks :: [[(Key, NonEmpty DistinctBlocks)]] grouped_blocks = map groupByLabel blocks merged_blocks :: [[(Key, DistinctBlocks)]]@@ -106,9 +106,8 @@ -- This block is not a duplicate, keep it. Nothing -> second (b:) $ go bs -mergeBlockList :: Subst -> [DistinctBlocks] -> (Subst, DistinctBlocks)-mergeBlockList _ [] = pprPanic "mergeBlockList" empty-mergeBlockList subst (b:bs) = go mapEmpty b bs+mergeBlockList :: Subst -> NonEmpty DistinctBlocks -> (Subst, DistinctBlocks)+mergeBlockList subst (b:|bs) = go mapEmpty b bs where go !new_subst1 b [] = (new_subst1, b) go !new_subst1 b1 (b2:bs) = go new_subst b bs@@ -301,15 +300,15 @@ -- Group by [Label] -- See Note [Compressed TrieMap] in GHC.Core.Map.Expr about the usage of GenMap.-groupByLabel :: [(Key, DistinctBlocks)] -> [(Key, [DistinctBlocks])]+groupByLabel :: [(Key, DistinctBlocks)] -> [(Key, NonEmpty DistinctBlocks)] groupByLabel =- go (TM.emptyTM :: TM.ListMap (TM.GenMap LabelMap) (Key, [DistinctBlocks]))+ go (TM.emptyTM :: TM.ListMap (TM.GenMap LabelMap) (Key, NonEmpty DistinctBlocks)) where go !m [] = TM.foldTM (:) m [] go !m ((k,v) : entries) = go (TM.alterTM k adjust m) entries where --k' = map (getKey . getUnique) k- adjust Nothing = Just (k,[v])- adjust (Just (_,vs)) = Just (k,v:vs)+ adjust Nothing = Just (k, pure v)+ adjust (Just (_,vs)) = Just (k, v NE.<| vs) groupByInt :: (a -> Int) -> [a] -> [[a]] groupByInt f xs = nonDetEltsUFM $ List.foldl' go emptyUFM xs
compiler/GHC/Cmm/DebugBlock.hs view
@@ -77,7 +77,7 @@ , dblBlocks :: ![DebugBlock] -- ^ Nested blocks } -instance OutputableP env CLabel => OutputableP env DebugBlock where+instance OutputableP Platform DebugBlock where pdoc env blk = (if | dblProcedure blk == dblLabel blk -> text "proc"@@ -85,7 +85,7 @@ -> text "pp-blk" | otherwise -> text "blk") <+>- ppr (dblLabel blk) <+> parens (pdoc env (dblCLabel blk)) <+>+ ppr (dblLabel blk) <+> parens (pprAsmLabel env (dblCLabel blk)) <+> (maybe empty ppr (dblSourceTick blk)) <+> (maybe (text "removed") ((text "pos " <>) . ppr) (dblPosition blk)) <+>@@ -121,7 +121,7 @@ | otherwise = panic "findP impossible" #endif - scopeMap = foldr (uncurry insertMulti) Map.empty childScopes+ scopeMap = foldl' (\acc (key, scope) -> insertMulti key scope acc) Map.empty childScopes -- This allows us to recover ticks that we lost by flattening -- the graph. Basically, if the parent is A but the child is@@ -495,9 +495,9 @@ -- | A label associated with an 'UnwindTable' data UnwindPoint = UnwindPoint !CLabel !UnwindTable -instance OutputableP env CLabel => OutputableP env UnwindPoint where+instance OutputableP Platform UnwindPoint where pdoc env (UnwindPoint lbl uws) =- braces $ pdoc env lbl <> colon+ braces $ pprAsmLabel env lbl <> colon <+> hsep (punctuate comma $ map pprUw $ Map.toList uws) where pprUw (g, expr) = ppr g <> char '=' <> pdoc env expr@@ -519,16 +519,16 @@ | UwTimes UnwindExpr UnwindExpr deriving (Eq) -instance OutputableP env CLabel => OutputableP env UnwindExpr where+instance OutputableP Platform UnwindExpr where pdoc = pprUnwindExpr 0 -pprUnwindExpr :: OutputableP env CLabel => Rational -> env -> UnwindExpr -> SDoc+pprUnwindExpr :: Rational -> Platform -> UnwindExpr -> SDoc pprUnwindExpr p env = \case UwConst i -> ppr i UwReg g 0 -> ppr g UwReg g x -> pprUnwindExpr p env (UwPlus (UwReg g 0) (UwConst x)) UwDeref e -> char '*' <> pprUnwindExpr 3 env e- UwLabel l -> pdoc env l+ UwLabel l -> pprAsmLabel env l UwPlus e0 e1 | p <= 0 -> pprUnwindExpr 0 env e0 <> char '+' <> pprUnwindExpr 0 env e1 UwMinus e0 e1
compiler/GHC/Cmm/Info/Build.hs view
@@ -56,8 +56,8 @@ {- Note [SRTs] ~~~~~~~~~~~ Static Reference Tables (SRTs) are the mechanism by which the garbage collector-can determine the live CAFs in the program. An SRT is a static tables associated-with a CAFfy static closure which record which CAFfy objects are reachable from+can determine the live CAFs in the program. An SRT is a static table associated+with a CAFfy closure which record which CAFfy objects are reachable from the closure's code. Representation
compiler/GHC/Cmm/Lint.hs view
@@ -23,6 +23,7 @@ import GHC.Cmm import GHC.Cmm.Liveness import GHC.Cmm.Switch (switchTargetsToList)+import GHC.Cmm.CLabel (pprDebugCLabel) import GHC.Utils.Outputable import Control.Monad (ap, unless)@@ -55,7 +56,7 @@ lintCmmDecl (CmmProc _ lbl _ g) = do platform <- getPlatform- addLintInfo (text "in proc " <> pdoc platform lbl) $ lintCmmGraph g+ addLintInfo (text "in proc " <> pprDebugCLabel platform lbl) $ lintCmmGraph g lintCmmDecl (CmmData {}) = return ()
compiler/GHC/Cmm/Parser.y view
@@ -449,7 +449,7 @@ platform <- getPlatform; ctx <- getContext; formals <- sequence (fromMaybe [] $3);- withName (renderWithContext ctx (pdoc platform entry_ret_label))+ withName (renderWithContext ctx (pprCLabel platform CStyle entry_ret_label)) $4; return (entry_ret_label, info, stk_formals, formals) } let do_layout = isJust $3
compiler/GHC/Cmm/Sink.hs view
@@ -268,7 +268,7 @@ all_succs = concatMap successors blocks succ_counts :: LabelMap Int- succ_counts = foldr (\l -> mapInsertWith (+) l 1) mapEmpty all_succs+ succ_counts = foldl' (\acc l -> mapInsertWith (+) l 1 acc) mapEmpty all_succs -- -- filter the list of assignments to remove any assignments that
compiler/GHC/CmmToAsm.hs view
@@ -396,7 +396,7 @@ -- force evaluation all this stuff to avoid space leaks let platform = ncgPlatform config- {-# SCC "seqString" #-} evaluate $ seqList (showSDocUnsafe $ vcat $ map (pdoc platform) imports) ()+ {-# SCC "seqString" #-} evaluate $ seqList (showSDocUnsafe $ vcat $ map (pprAsmLabel platform) imports) () let !labels' = if ncgDwarfEnabled config then cmmDebugLabels isMetaInstr native else []@@ -455,7 +455,7 @@ let weights = ncgCfgWeights config let proc_name = case cmm of- (CmmProc _ entry_label _ _) -> pdoc platform entry_label+ (CmmProc _ entry_label _ _) -> pprAsmLabel platform entry_label _ -> text "DataChunk" -- rewrite assignments to global regs@@ -789,7 +789,7 @@ doPpr lbl = (lbl, renderWithContext (ncgAsmContext config)- (pprCLabel platform AsmStyle lbl))+ (pprAsmLabel platform lbl)) -- ----------------------------------------------------------------------------- -- Generate jump tables
compiler/GHC/CmmToAsm/AArch64.hs view
@@ -1,6 +1,6 @@ {-# OPTIONS_GHC -fno-warn-orphans #-} --- | Native code generator for x86 and x86-64 architectures+-- | Native code generator for AArch64 architectures module GHC.CmmToAsm.AArch64 ( ncgAArch64 ) where
compiler/GHC/CmmToAsm/AArch64/CodeGen.hs view
@@ -60,6 +60,7 @@ import GHC.Data.FastString import GHC.Utils.Misc import GHC.Utils.Panic+import GHC.Utils.Constants (debugIsOn) -- Note [General layout of an NCG] -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@@ -135,10 +136,11 @@ id = entryLabel block stmts = blockToList nodes - header_comment_instr = unitOL $ MULTILINE_COMMENT (+ header_comment_instr | debugIsOn = unitOL $ MULTILINE_COMMENT ( text "-- --------------------------- basicBlockCodeGen --------------------------- --\n"- $+$ pdoc (ncgPlatform config) block+ $+$ withPprStyle defaultDumpStyle (pdoc (ncgPlatform config) block) )+ | otherwise = nilOL -- Generate location directive dbg <- getDebugBlock (entryLabel block) loc_instrs <- case dblSourceTick =<< dbg of
compiler/GHC/CmmToAsm/AArch64/Ppr.hs view
@@ -50,14 +50,14 @@ pprLabel platform lbl $$ -- blocks guaranteed not null, so label needed vcat (map (pprBasicBlock config top_info) blocks) $$ (if ncgDwarfEnabled config- then ppr (mkAsmTempEndLabel lbl) <> char ':' else empty) $$+ then pprAsmLabel platform (mkAsmTempEndLabel lbl) <> char ':' else empty) $$ pprSizeDecl platform lbl Just (CmmStaticsRaw info_lbl _) -> pprSectionAlign config (Section Text info_lbl) $$ -- pprProcAlignment config $$ (if platformHasSubsectionsViaSymbols platform- then ppr (mkDeadStripPreventer info_lbl) <> char ':'+ then pprAsmLabel platform (mkDeadStripPreventer info_lbl) <> char ':' else empty) $$ vcat (map (pprBasicBlock config top_info) blocks) $$ -- above: Even the first block gets a label, because with branch-chain@@ -65,9 +65,9 @@ (if platformHasSubsectionsViaSymbols platform then -- See Note [Subsections Via Symbols] text "\t.long "- <+> ppr info_lbl+ <+> pprAsmLabel platform info_lbl <+> char '-'- <+> ppr (mkDeadStripPreventer info_lbl)+ <+> pprAsmLabel platform (mkDeadStripPreventer info_lbl) else empty) $$ pprSizeDecl platform info_lbl @@ -75,7 +75,7 @@ pprLabel platform lbl = pprGloblDecl platform lbl $$ pprTypeDecl platform lbl- $$ (pdoc platform lbl <> char ':')+ $$ (pprAsmLabel platform lbl <> char ':') pprAlign :: Platform -> Alignment -> SDoc pprAlign _platform alignment@@ -87,9 +87,6 @@ -- .balign is stable, whereas .align is platform dependent. = text "\t.balign 8" -- always 8 -instance Outputable Instr where- ppr = pprInstr genericPlatform- -- | Print section header and appropriate alignment for that section. -- -- This one will emit the header:@@ -108,7 +105,7 @@ pprSizeDecl :: Platform -> CLabel -> SDoc pprSizeDecl platform lbl = if osElfTarget (platformOS platform)- then text "\t.size" <+> pdoc platform lbl <> text ", .-" <> pdoc platform lbl+ then text "\t.size" <+> pprAsmLabel platform lbl <> text ", .-" <> pprAsmLabel platform lbl else empty pprBasicBlock :: NCGConfig -> LabelMap RawCmmStatics -> NatBasicBlock Instr@@ -118,7 +115,7 @@ pprLabel platform asmLbl $$ vcat (map (pprInstr platform) (id {-detectTrivialDeadlock-} optInstrs)) $$ (if ncgDwarfEnabled config- then ppr (mkAsmTempEndLabel asmLbl) <> char ':'+ then pprAsmLabel platform (mkAsmTempEndLabel asmLbl) <> char ':' else empty ) where@@ -138,7 +135,7 @@ pprLabel platform info_lbl $$ c $$ (if ncgDwarfEnabled config- then ppr (mkAsmTempEndLabel info_lbl) <> char ':'+ then pprAsmLabel platform (mkAsmTempEndLabel info_lbl) <> char ':' else empty) -- Make sure the info table has the right .loc for the block -- coming right after it. See Note [Info Offset]@@ -156,7 +153,7 @@ , Just ind' <- labelInd ind , alias `mayRedirectTo` ind' = pprGloblDecl (ncgPlatform config) alias- $$ text ".equiv" <+> pdoc (ncgPlatform config) alias <> comma <> pdoc (ncgPlatform config) (CmmLabel ind')+ $$ text ".equiv" <+> pprAsmLabel (ncgPlatform config) alias <> comma <> pprAsmLabel (ncgPlatform config) ind' pprDatas config (CmmStaticsRaw lbl dats) = vcat (pprLabel platform lbl : map (pprData config) dats)@@ -178,7 +175,7 @@ pprGloblDecl :: Platform -> CLabel -> SDoc pprGloblDecl platform lbl | not (externallyVisibleCLabel lbl) = empty- | otherwise = text "\t.globl " <> pdoc platform lbl+ | otherwise = text "\t.globl " <> pprAsmLabel platform lbl -- Note [Always use objects for info tables] -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@@ -204,7 +201,7 @@ pprTypeDecl :: Platform -> CLabel -> SDoc pprTypeDecl platform lbl = if osElfTarget (platformOS platform) && externallyVisibleCLabel lbl- then text ".type " <> pdoc platform lbl <> text ", " <> pprLabelType' platform lbl+ then text ".type " <> pprAsmLabel platform lbl <> text ", " <> pprLabelType' platform lbl else empty pprDataItem :: NCGConfig -> CmmLit -> SDoc@@ -233,9 +230,9 @@ pprImm :: Platform -> Imm -> SDoc pprImm _ (ImmInt i) = int i pprImm _ (ImmInteger i) = integer i-pprImm p (ImmCLbl l) = pdoc p l-pprImm p (ImmIndex l i) = pdoc p l <> char '+' <> int i-pprImm _ (ImmLit s) = s+pprImm p (ImmCLbl l) = pprAsmLabel p l+pprImm p (ImmIndex l i) = pprAsmLabel p l <> char '+' <> int i+pprImm _ (ImmLit s) = text s -- TODO: See pprIm below for why this is a bad idea! pprImm _ (ImmFloat f)@@ -282,8 +279,8 @@ ImmDouble d | d == 0 -> text "xzr" ImmDouble d -> char '#' <> double (fromRational d) -- =<lbl> pseudo instruction!- ImmCLbl l -> char '=' <> pdoc platform l- ImmIndex l o -> text "[=" <> pdoc platform l <> comma <+> char '#' <> int o <> char ']'+ ImmCLbl l -> char '=' <> pprAsmLabel platform l+ ImmIndex l o -> text "[=" <> pprAsmLabel platform l <> comma <+> char '#' <> int o <> char ']' _ -> panic "AArch64.pprIm" pprExt :: ExtMode -> SDoc@@ -433,28 +430,28 @@ -- 4. Branch Instructions ---------------------------------------------------- J t -> pprInstr platform (B t)- B (TBlock bid) -> text "\tb" <+> pdoc platform (mkLocalBlockLabel (getUnique bid))- B (TLabel lbl) -> text "\tb" <+> pdoc platform lbl+ B (TBlock bid) -> text "\tb" <+> pprAsmLabel platform (mkLocalBlockLabel (getUnique bid))+ B (TLabel lbl) -> text "\tb" <+> pprAsmLabel platform lbl B (TReg r) -> text "\tbr" <+> pprReg W64 r - BL (TBlock bid) _ _ -> text "\tbl" <+> pdoc platform (mkLocalBlockLabel (getUnique bid))- BL (TLabel lbl) _ _ -> text "\tbl" <+> pdoc platform lbl+ BL (TBlock bid) _ _ -> text "\tbl" <+> pprAsmLabel platform (mkLocalBlockLabel (getUnique bid))+ BL (TLabel lbl) _ _ -> text "\tbl" <+> pprAsmLabel platform lbl BL (TReg r) _ _ -> text "\tblr" <+> pprReg W64 r - BCOND c (TBlock bid) -> text "\t" <> pprBcond c <+> pdoc platform (mkLocalBlockLabel (getUnique bid))- BCOND c (TLabel lbl) -> text "\t" <> pprBcond c <+> pdoc platform lbl+ BCOND c (TBlock bid) -> text "\t" <> pprBcond c <+> pprAsmLabel platform (mkLocalBlockLabel (getUnique bid))+ BCOND c (TLabel lbl) -> text "\t" <> pprBcond c <+> pprAsmLabel platform lbl BCOND _ (TReg _) -> panic "AArch64.ppr: No conditional branching to registers!" -- 5. Atomic Instructions ---------------------------------------------------- -- 6. Conditional Instructions ----------------------------------------------- CSET o c -> text "\tcset" <+> pprOp platform o <> comma <+> pprCond c - CBZ o (TBlock bid) -> text "\tcbz" <+> pprOp platform o <> comma <+> pdoc platform (mkLocalBlockLabel (getUnique bid))- CBZ o (TLabel lbl) -> text "\tcbz" <+> pprOp platform o <> comma <+> pdoc platform lbl+ CBZ o (TBlock bid) -> text "\tcbz" <+> pprOp platform o <> comma <+> pprAsmLabel platform (mkLocalBlockLabel (getUnique bid))+ CBZ o (TLabel lbl) -> text "\tcbz" <+> pprOp platform o <> comma <+> pprAsmLabel platform lbl CBZ _ (TReg _) -> panic "AArch64.ppr: No conditional (cbz) branching to registers!" - CBNZ o (TBlock bid) -> text "\tcbnz" <+> pprOp platform o <> comma <+> pdoc platform (mkLocalBlockLabel (getUnique bid))- CBNZ o (TLabel lbl) -> text "\tcbnz" <+> pprOp platform o <> comma <+> pdoc platform lbl+ CBNZ o (TBlock bid) -> text "\tcbnz" <+> pprOp platform o <> comma <+> pprAsmLabel platform (mkLocalBlockLabel (getUnique bid))+ CBNZ o (TLabel lbl) -> text "\tcbnz" <+> pprOp platform o <> comma <+> pprAsmLabel platform lbl CBNZ _ (TReg _) -> panic "AArch64.ppr: No conditional (cbnz) branching to registers!" -- 7. Load and Store Instructions --------------------------------------------@@ -469,58 +466,58 @@ #if defined(darwin_HOST_OS) LDR _f o1 (OpImm (ImmIndex lbl' off)) | Just (_info, lbl) <- dynamicLinkerLabelInfo lbl' ->- text "\tadrp" <+> pprOp platform o1 <> comma <+> pdoc platform lbl <> text "@gotpage" $$- text "\tldr" <+> pprOp platform o1 <> comma <+> text "[" <> pprOp platform o1 <> comma <+> pdoc platform lbl <> text "@gotpageoff" <> text "]" $$+ text "\tadrp" <+> pprOp platform o1 <> comma <+> pprAsmLabel platform lbl <> text "@gotpage" $$+ text "\tldr" <+> pprOp platform o1 <> comma <+> text "[" <> pprOp platform o1 <> comma <+> pprAsmLabel platform lbl <> text "@gotpageoff" <> text "]" $$ text "\tadd" <+> pprOp platform o1 <> comma <+> pprOp platform o1 <> comma <+> char '#' <> int off -- TODO: check that off is in 12bits. LDR _f o1 (OpImm (ImmIndex lbl off)) | isForeignLabel lbl ->- text "\tadrp" <+> pprOp platform o1 <> comma <+> pdoc platform lbl <> text "@gotpage" $$- text "\tldr" <+> pprOp platform o1 <> comma <+> text "[" <> pprOp platform o1 <> comma <+> pdoc platform lbl <> text "@gotpageoff" <> text "]" $$+ text "\tadrp" <+> pprOp platform o1 <> comma <+> pprAsmLabel platform lbl <> text "@gotpage" $$+ text "\tldr" <+> pprOp platform o1 <> comma <+> text "[" <> pprOp platform o1 <> comma <+> pprAsmLabel platform lbl <> text "@gotpageoff" <> text "]" $$ text "\tadd" <+> pprOp platform o1 <> comma <+> pprOp platform o1 <> comma <+> char '#' <> int off -- TODO: check that off is in 12bits. LDR _f o1 (OpImm (ImmIndex lbl off)) ->- text "\tadrp" <+> pprOp platform o1 <> comma <+> pdoc platform lbl <> text "@page" $$- text "\tadd" <+> pprOp platform o1 <> comma <+> pprOp platform o1 <> comma <+> pdoc platform lbl <> text "@pageoff" $$+ text "\tadrp" <+> pprOp platform o1 <> comma <+> pprAsmLabel platform lbl <> text "@page" $$+ text "\tadd" <+> pprOp platform o1 <> comma <+> pprOp platform o1 <> comma <+> pprAsmLabel platform lbl <> text "@pageoff" $$ text "\tadd" <+> pprOp platform o1 <> comma <+> pprOp platform o1 <> comma <+> char '#' <> int off -- TODO: check that off is in 12bits. LDR _f o1 (OpImm (ImmCLbl lbl')) | Just (_info, lbl) <- dynamicLinkerLabelInfo lbl' ->- text "\tadrp" <+> pprOp platform o1 <> comma <+> pdoc platform lbl <> text "@gotpage" $$- text "\tldr" <+> pprOp platform o1 <> comma <+> text "[" <> pprOp platform o1 <> comma <+> pdoc platform lbl <> text "@gotpageoff" <> text "]"+ text "\tadrp" <+> pprOp platform o1 <> comma <+> pprAsmLabel platform lbl <> text "@gotpage" $$+ text "\tldr" <+> pprOp platform o1 <> comma <+> text "[" <> pprOp platform o1 <> comma <+> pprAsmLabel platform lbl <> text "@gotpageoff" <> text "]" LDR _f o1 (OpImm (ImmCLbl lbl)) | isForeignLabel lbl ->- text "\tadrp" <+> pprOp platform o1 <> comma <+> pdoc platform lbl <> text "@gotpage" $$- text "\tldr" <+> pprOp platform o1 <> comma <+> text "[" <> pprOp platform o1 <> comma <+> pdoc platform lbl <> text "@gotpageoff" <> text "]"+ text "\tadrp" <+> pprOp platform o1 <> comma <+> pprAsmLabel platform lbl <> text "@gotpage" $$+ text "\tldr" <+> pprOp platform o1 <> comma <+> text "[" <> pprOp platform o1 <> comma <+> pprAsmLabel platform lbl <> text "@gotpageoff" <> text "]" LDR _f o1 (OpImm (ImmCLbl lbl)) ->- text "\tadrp" <+> pprOp platform o1 <> comma <+> pdoc platform lbl <> text "@page" $$- text "\tadd" <+> pprOp platform o1 <> comma <+> pprOp platform o1 <> comma <+> pdoc platform lbl <> text "@pageoff"+ text "\tadrp" <+> pprOp platform o1 <> comma <+> pprAsmLabel platform lbl <> text "@page" $$+ text "\tadd" <+> pprOp platform o1 <> comma <+> pprOp platform o1 <> comma <+> pprAsmLabel platform lbl <> text "@pageoff" #else LDR _f o1 (OpImm (ImmIndex lbl' off)) | Just (_info, lbl) <- dynamicLinkerLabelInfo lbl' ->- text "\tadrp" <+> pprOp platform o1 <> comma <+> text ":got:" <> pdoc platform lbl $$- text "\tldr" <+> pprOp platform o1 <> comma <+> text "[" <> pprOp platform o1 <> comma <+> text ":got_lo12:" <> pdoc platform lbl <> text "]" $$+ text "\tadrp" <+> pprOp platform o1 <> comma <+> text ":got:" <> pprAsmLabel platform lbl $$+ text "\tldr" <+> pprOp platform o1 <> comma <+> text "[" <> pprOp platform o1 <> comma <+> text ":got_lo12:" <> pprAsmLabel platform lbl <> text "]" $$ text "\tadd" <+> pprOp platform o1 <> comma <+> pprOp platform o1 <> comma <+> char '#' <> int off -- TODO: check that off is in 12bits. LDR _f o1 (OpImm (ImmIndex lbl off)) | isForeignLabel lbl ->- text "\tadrp" <+> pprOp platform o1 <> comma <+> text ":got:" <> pdoc platform lbl $$- text "\tldr" <+> pprOp platform o1 <> comma <+> text "[" <> pprOp platform o1 <> comma <+> text ":got_lo12:" <> pdoc platform lbl <> text "]" $$+ text "\tadrp" <+> pprOp platform o1 <> comma <+> text ":got:" <> pprAsmLabel platform lbl $$+ text "\tldr" <+> pprOp platform o1 <> comma <+> text "[" <> pprOp platform o1 <> comma <+> text ":got_lo12:" <> pprAsmLabel platform lbl <> text "]" $$ text "\tadd" <+> pprOp platform o1 <> comma <+> pprOp platform o1 <> comma <+> char '#' <> int off -- TODO: check that off is in 12bits. LDR _f o1 (OpImm (ImmIndex lbl off)) ->- text "\tadrp" <+> pprOp platform o1 <> comma <+> pdoc platform lbl $$- text "\tadd" <+> pprOp platform o1 <> comma <+> pprOp platform o1 <> comma <+> text ":lo12:" <> pdoc platform lbl $$+ text "\tadrp" <+> pprOp platform o1 <> comma <+> pprAsmLabel platform lbl $$+ text "\tadd" <+> pprOp platform o1 <> comma <+> pprOp platform o1 <> comma <+> text ":lo12:" <> pprAsmLabel platform lbl $$ text "\tadd" <+> pprOp platform o1 <> comma <+> pprOp platform o1 <> comma <+> char '#' <> int off -- TODO: check that off is in 12bits. LDR _f o1 (OpImm (ImmCLbl lbl')) | Just (_info, lbl) <- dynamicLinkerLabelInfo lbl' ->- text "\tadrp" <+> pprOp platform o1 <> comma <+> text ":got:" <> pdoc platform lbl $$- text "\tldr" <+> pprOp platform o1 <> comma <+> text "[" <> pprOp platform o1 <> comma <+> text ":got_lo12:" <> pdoc platform lbl <> text "]"+ text "\tadrp" <+> pprOp platform o1 <> comma <+> text ":got:" <> pprAsmLabel platform lbl $$+ text "\tldr" <+> pprOp platform o1 <> comma <+> text "[" <> pprOp platform o1 <> comma <+> text ":got_lo12:" <> pprAsmLabel platform lbl <> text "]" LDR _f o1 (OpImm (ImmCLbl lbl)) | isForeignLabel lbl ->- text "\tadrp" <+> pprOp platform o1 <> comma <+> text ":got:" <> pdoc platform lbl $$- text "\tldr" <+> pprOp platform o1 <> comma <+> text "[" <> pprOp platform o1 <> comma <+> text ":got_lo12:" <> pdoc platform lbl <> text "]"+ text "\tadrp" <+> pprOp platform o1 <> comma <+> text ":got:" <> pprAsmLabel platform lbl $$+ text "\tldr" <+> pprOp platform o1 <> comma <+> text "[" <> pprOp platform o1 <> comma <+> text ":got_lo12:" <> pprAsmLabel platform lbl <> text "]" LDR _f o1 (OpImm (ImmCLbl lbl)) ->- text "\tadrp" <+> pprOp platform o1 <> comma <+> pdoc platform lbl $$- text "\tadd" <+> pprOp platform o1 <> comma <+> pprOp platform o1 <> comma <+> text ":lo12:" <> pdoc platform lbl+ text "\tadrp" <+> pprOp platform o1 <> comma <+> pprAsmLabel platform lbl $$+ text "\tadd" <+> pprOp platform o1 <> comma <+> pprOp platform o1 <> comma <+> text ":lo12:" <> pprAsmLabel platform lbl #endif LDR _f o1@(OpReg W8 (RegReal (RealRegSingle i))) o2 | i < 32 ->
compiler/GHC/CmmToAsm/AArch64/Regs.hs view
@@ -59,7 +59,7 @@ = ImmInt Int | ImmInteger Integer -- Sigh. | ImmCLbl CLabel -- AbstractC Label (with baggage)- | ImmLit SDoc -- Simple string+ | ImmLit String | ImmIndex CLabel Int | ImmFloat Rational | ImmDouble Rational@@ -67,14 +67,8 @@ | ImmConstantDiff Imm Imm deriving (Eq, Show) -instance Show SDoc where- show = showPprUnsafe . ppr--instance Eq SDoc where- lhs == rhs = show lhs == show rhs- strImmLit :: String -> Imm-strImmLit s = ImmLit (text s)+strImmLit s = ImmLit s litToImm :: CmmLit -> Imm
compiler/GHC/CmmToAsm/Dwarf.hs view
@@ -51,8 +51,8 @@ , dwName = fromMaybe "" (ml_hs_file modLoc) , dwCompDir = addTrailingPathSeparator compPath , dwProducer = cProjectName ++ " " ++ cProjectVersion- , dwLowLabel = pdoc platform lowLabel- , dwHighLabel = pdoc platform highLabel+ , dwLowLabel = pprAsmLabel platform lowLabel+ , dwHighLabel = pprAsmLabel platform highLabel , dwLineLabel = dwarfLineLabel } @@ -109,9 +109,9 @@ compileUnitHeader :: Platform -> Unique -> SDoc compileUnitHeader platform unitU = let cuLabel = mkAsmTempLabel unitU -- sits right before initialLength field- length = pdoc platform (mkAsmTempEndLabel cuLabel) <> char '-' <> pdoc platform cuLabel+ length = pprAsmLabel platform (mkAsmTempEndLabel cuLabel) <> char '-' <> pprAsmLabel platform cuLabel <> text "-4" -- length of initialLength field- in vcat [ pdoc platform cuLabel <> colon+ in vcat [ pprAsmLabel platform cuLabel <> colon , text "\t.long " <> length -- compilation unit size , pprHalf 3 -- DWARF version , sectionOffset platform dwarfAbbrevLabel dwarfAbbrevLabel@@ -123,7 +123,7 @@ compileUnitFooter :: Platform -> Unique -> SDoc compileUnitFooter platform unitU = let cuEndLabel = mkAsmTempEndLabel $ mkAsmTempLabel unitU- in pdoc platform cuEndLabel <> colon+ in pprAsmLabel platform cuEndLabel <> colon -- | Splits the blocks by procedures. In the result all nested blocks -- will come from the same procedure as the top-level block. See
compiler/GHC/CmmToAsm/Dwarf/Types.hs view
@@ -184,14 +184,14 @@ then sectionOffset platform lineLbl dwarfLineLabel else empty pprDwarfInfoOpen platform _ (DwarfSubprogram _ name label parent) =- pdoc platform (mkAsmTempDieLabel label) <> colon+ pprAsmLabel platform (mkAsmTempDieLabel label) <> colon $$ pprAbbrev abbrev $$ pprString name $$ pprLabelString platform label $$ pprFlag (externallyVisibleCLabel label) -- Offset due to Note [Info Offset]- $$ pprWord platform (pdoc platform label <> text "-1")- $$ pprWord platform (pdoc platform $ mkAsmTempProcEndLabel label)+ $$ pprWord platform (pprAsmLabel platform label <> text "-1")+ $$ pprWord platform (pprAsmLabel platform $ mkAsmTempProcEndLabel label) $$ pprByte 1 $$ pprByte dW_OP_call_frame_cfa $$ parentValue@@ -199,17 +199,17 @@ abbrev = case parent of Nothing -> DwAbbrSubprogram Just _ -> DwAbbrSubprogramWithParent parentValue = maybe empty pprParentDie parent- pprParentDie sym = sectionOffset platform (pdoc platform sym) dwarfInfoLabel+ pprParentDie sym = sectionOffset platform (pprAsmLabel platform sym) dwarfInfoLabel pprDwarfInfoOpen platform _ (DwarfBlock _ label Nothing) =- pdoc platform (mkAsmTempDieLabel label) <> colon+ pprAsmLabel platform (mkAsmTempDieLabel label) <> colon $$ pprAbbrev DwAbbrBlockWithoutCode $$ pprLabelString platform label pprDwarfInfoOpen platform _ (DwarfBlock _ label (Just marker)) =- pdoc platform (mkAsmTempDieLabel label) <> colon+ pprAsmLabel platform (mkAsmTempDieLabel label) <> colon $$ pprAbbrev DwAbbrBlock $$ pprLabelString platform label- $$ pprWord platform (pdoc platform marker)- $$ pprWord platform (pdoc platform $ mkAsmTempEndLabel marker)+ $$ pprWord platform (pprAsmLabel platform marker)+ $$ pprWord platform (pprAsmLabel platform $ mkAsmTempEndLabel marker) pprDwarfInfoOpen _ _ (DwarfSrcNote ss) = pprAbbrev DwAbbrGhcSrcNote $$ pprString' (ftext $ srcSpanFile ss)@@ -245,7 +245,7 @@ initialLength = 8 + paddingSize + (1 + length arngs) * 2 * wordSize in pprDwWord (ppr initialLength) $$ pprHalf 2- $$ sectionOffset platform (pdoc platform $ mkAsmTempLabel $ unitU) dwarfInfoLabel+ $$ sectionOffset platform (pprAsmLabel platform $ mkAsmTempLabel $ unitU) dwarfInfoLabel $$ pprByte (fromIntegral wordSize) $$ pprByte 0 $$ pad paddingSize@@ -258,11 +258,11 @@ pprDwarfARange :: Platform -> DwarfARange -> SDoc pprDwarfARange platform arng = -- Offset due to Note [Info Offset].- pprWord platform (pdoc platform (dwArngStartLabel arng) <> text "-1")+ pprWord platform (pprAsmLabel platform (dwArngStartLabel arng) <> text "-1") $$ pprWord platform length where- length = pdoc platform (dwArngEndLabel arng)- <> char '-' <> pdoc platform (dwArngStartLabel arng)+ length = pprAsmLabel platform (dwArngEndLabel arng)+ <> char '-' <> pprAsmLabel platform (dwArngStartLabel arng) -- | Information about unwind instructions for a procedure. This -- corresponds to a "Common Information Entry" (CIE) in DWARF.@@ -293,7 +293,7 @@ -- in the block } -instance OutputableP env CLabel => OutputableP env DwarfFrameBlock where+instance OutputableP Platform DwarfFrameBlock where pdoc env (DwarfFrameBlock hasInfo unwinds) = braces $ ppr hasInfo <+> pdoc env unwinds -- | Header for the @.debug_frame@ section. Here we emit the "Common@@ -303,7 +303,7 @@ pprDwarfFrame platform DwarfFrame{dwCieLabel=cieLabel,dwCieInit=cieInit,dwCieProcs=procs} = let cieStartLabel= mkAsmTempDerivedLabel cieLabel (fsLit "_start") cieEndLabel = mkAsmTempEndLabel cieLabel- length = pdoc platform cieEndLabel <> char '-' <> pdoc platform cieStartLabel+ length = pprAsmLabel platform cieEndLabel <> char '-' <> pprAsmLabel platform cieStartLabel spReg = dwarfGlobalRegNo platform Sp retReg = dwarfReturnRegNo platform wordSize = platformWordSizeInBytes platform@@ -316,9 +316,9 @@ ArchX86 -> pprByte dW_CFA_same_value $$ pprLEBWord 4 ArchX86_64 -> pprByte dW_CFA_same_value $$ pprLEBWord 7 _ -> empty- in vcat [ pdoc platform cieLabel <> colon+ in vcat [ pprAsmLabel platform cieLabel <> colon , pprData4' length -- Length of CIE- , pdoc platform cieStartLabel <> colon+ , pprAsmLabel platform cieStartLabel <> colon , pprData4' (text "-1") -- Common Information Entry marker (-1 = 0xf..f) , pprByte 3 -- CIE version (we require DWARF 3)@@ -346,7 +346,7 @@ , pprLEBWord 0 ] $$ wordAlign platform $$- pdoc platform cieEndLabel <> colon $$+ pprAsmLabel platform cieEndLabel <> colon $$ -- Procedure unwind tables vcat (map (pprFrameProc platform cieLabel cieInit) procs) @@ -360,17 +360,17 @@ procEnd = mkAsmTempProcEndLabel procLbl ifInfo str = if hasInfo then text str else empty -- see Note [Info Offset]- in vcat [ whenPprDebug $ text "# Unwinding for" <+> pdoc platform procLbl <> colon- , pprData4' (pdoc platform fdeEndLabel <> char '-' <> pdoc platform fdeLabel)- , pdoc platform fdeLabel <> colon- , pprData4' (pdoc platform frameLbl <> char '-' <> dwarfFrameLabel) -- Reference to CIE- , pprWord platform (pdoc platform procLbl <> ifInfo "-1") -- Code pointer- , pprWord platform (pdoc platform procEnd <> char '-' <>- pdoc platform procLbl <> ifInfo "+1") -- Block byte length+ in vcat [ whenPprDebug $ text "# Unwinding for" <+> pprAsmLabel platform procLbl <> colon+ , pprData4' (pprAsmLabel platform fdeEndLabel <> char '-' <> pprAsmLabel platform fdeLabel)+ , pprAsmLabel platform fdeLabel <> colon+ , pprData4' (pprAsmLabel platform frameLbl <> char '-' <> dwarfFrameLabel) -- Reference to CIE+ , pprWord platform (pprAsmLabel platform procLbl <> ifInfo "-1") -- Code pointer+ , pprWord platform (pprAsmLabel platform procEnd <> char '-' <>+ pprAsmLabel platform procLbl <> ifInfo "+1") -- Block byte length ] $$ vcat (S.evalState (mapM (pprFrameBlock platform) blocks) initUw) $$ wordAlign platform $$- pdoc platform fdeEndLabel <> colon+ pprAsmLabel platform fdeEndLabel <> colon -- | Generates unwind information for a block. We only generate -- instructions where unwind information actually changes. This small@@ -402,7 +402,7 @@ then (empty, oldUws) else let -- see Note [Info Offset] needsOffset = firstDecl && hasInfo- lblDoc = pdoc platform lbl <>+ lblDoc = pprAsmLabel platform lbl <> if needsOffset then text "-1" else empty doc = pprByte dW_CFA_set_loc $$ pprWord platform lblDoc $$ vcat (map (uncurry $ pprSetUnwind platform) changed)@@ -513,7 +513,7 @@ pprE (UwReg g i) = pprByte (dW_OP_breg0+dwarfGlobalRegNo platform g) $$ pprLEBInt i pprE (UwDeref u) = pprE u $$ pprByte dW_OP_deref- pprE (UwLabel l) = pprByte dW_OP_addr $$ pprWord platform (pdoc platform l)+ pprE (UwLabel l) = pprByte dW_OP_addr $$ pprWord platform (pprAsmLabel platform l) pprE (UwPlus u1 u2) = pprE u1 $$ pprE u2 $$ pprByte dW_OP_plus pprE (UwMinus u1 u2) = pprE u1 $$ pprE u2 $$ pprByte dW_OP_minus pprE (UwTimes u1 u2) = pprE u1 $$ pprE u2 $$ pprByte dW_OP_mul
compiler/GHC/CmmToAsm/PIC.hs view
@@ -729,7 +729,7 @@ _ -> panic "PIC.pprImportedSymbol: no match" where platform = ncgPlatform config- ppr_lbl = pprCLabel platform AsmStyle+ ppr_lbl = pprAsmLabel platform arch = platformArch platform os = platformOS platform pic = ncgPIC config
compiler/GHC/CmmToAsm/PPC/CodeGen.hs view
@@ -407,7 +407,7 @@ getRegister' _ platform (CmmReg (CmmGlobal PicBaseReg)) | OSAIX <- platformOS platform = do let code dst = toOL [ LD II32 dst tocAddr ]- tocAddr = AddrRegImm toc (ImmLit (text "ghc_toc_table[TC]"))+ tocAddr = AddrRegImm toc (ImmLit "ghc_toc_table[TC]") return (Any II32 code) | target32Bit platform = do reg <- getPicBaseNat $ archWordFormat (target32Bit platform)
compiler/GHC/CmmToAsm/PPC/Ppr.hs view
@@ -63,7 +63,7 @@ _ -> pprLabel platform lbl) $$ -- blocks guaranteed not null, -- so label needed vcat (map (pprBasicBlock config top_info) blocks) $$- ppWhen (ncgDwarfEnabled config) (pdoc platform (mkAsmTempEndLabel lbl)+ ppWhen (ncgDwarfEnabled config) (pprAsmLabel platform (mkAsmTempEndLabel lbl) <> char ':' $$ pprProcEndLabel platform lbl) $$ pprSizeDecl platform lbl@@ -71,7 +71,7 @@ Just (CmmStaticsRaw info_lbl _) -> pprSectionAlign config (Section Text info_lbl) $$ (if platformHasSubsectionsViaSymbols platform- then pdoc platform (mkDeadStripPreventer info_lbl) <> char ':'+ then pprAsmLabel platform (mkDeadStripPreventer info_lbl) <> char ':' else empty) $$ vcat (map (pprBasicBlock config top_info) blocks) $$ -- above: Even the first block gets a label, because with branch-chain@@ -80,9 +80,9 @@ then -- See Note [Subsections Via Symbols] in X86/Ppr.hs text "\t.long "- <+> pdoc platform info_lbl+ <+> pprAsmLabel platform info_lbl <+> char '-'- <+> pdoc platform (mkDeadStripPreventer info_lbl)+ <+> pprAsmLabel platform (mkDeadStripPreventer info_lbl) else empty) $$ pprSizeDecl platform info_lbl @@ -93,7 +93,7 @@ then text "\t.size" <+> prettyLbl <> text ", .-" <> codeLbl else empty where- prettyLbl = pdoc platform lbl+ prettyLbl = pprAsmLabel platform lbl codeLbl | platformArch platform == ArchPPC_64 ELF_V1 = char '.' <> prettyLbl | otherwise = prettyLbl@@ -102,33 +102,33 @@ pprFunctionDescriptor platform lab = pprGloblDecl platform lab $$ text "\t.section \".opd\", \"aw\"" $$ text "\t.align 3"- $$ pdoc platform lab <> char ':'+ $$ pprAsmLabel platform lab <> char ':' $$ text "\t.quad ."- <> pdoc platform lab+ <> pprAsmLabel platform lab <> text ",.TOC.@tocbase,0" $$ text "\t.previous" $$ text "\t.type"- <+> pdoc platform lab+ <+> pprAsmLabel platform lab <> text ", @function"- $$ char '.' <> pdoc platform lab <> char ':'+ $$ char '.' <> pprAsmLabel platform lab <> char ':' pprFunctionPrologue :: Platform -> CLabel ->SDoc pprFunctionPrologue platform lab = pprGloblDecl platform lab $$ text ".type "- <> pdoc platform lab+ <> pprAsmLabel platform lab <> text ", @function"- $$ pdoc platform lab <> char ':'+ $$ pprAsmLabel platform lab <> char ':' $$ text "0:\taddis\t" <> pprReg toc <> text ",12,.TOC.-0b@ha" $$ text "\taddi\t" <> pprReg toc <> char ',' <> pprReg toc <> text ",.TOC.-0b@l"- $$ text "\t.localentry\t" <> pdoc platform lab- <> text ",.-" <> pdoc platform lab+ $$ text "\t.localentry\t" <> pprAsmLabel platform lab+ <> text ",.-" <> pprAsmLabel platform lab pprProcEndLabel :: Platform -> CLabel -- ^ Procedure name -> SDoc pprProcEndLabel platform lbl =- pdoc platform (mkAsmTempProcEndLabel lbl) <> char ':'+ pprAsmLabel platform (mkAsmTempProcEndLabel lbl) <> char ':' pprBasicBlock :: NCGConfig -> LabelMap RawCmmStatics -> NatBasicBlock Instr -> SDoc@@ -137,7 +137,7 @@ pprLabel platform asmLbl $$ vcat (map (pprInstr platform) instrs) $$ ppWhen (ncgDwarfEnabled config) (- pdoc platform (mkAsmTempEndLabel asmLbl) <> char ':'+ pprAsmLabel platform (mkAsmTempEndLabel asmLbl) <> char ':' <> pprProcEndLabel platform asmLbl ) where@@ -162,7 +162,7 @@ , Just ind' <- labelInd ind , alias `mayRedirectTo` ind' = pprGloblDecl platform alias- $$ text ".equiv" <+> pdoc platform alias <> comma <> pdoc platform (CmmLabel ind')+ $$ text ".equiv" <+> pprAsmLabel platform alias <> comma <> pprAsmLabel platform ind' pprDatas platform (CmmStaticsRaw lbl dats) = vcat (pprLabel platform lbl : map (pprData platform) dats) pprData :: Platform -> CmmStatic -> SDoc@@ -175,20 +175,20 @@ pprGloblDecl :: Platform -> CLabel -> SDoc pprGloblDecl platform lbl | not (externallyVisibleCLabel lbl) = empty- | otherwise = text ".globl " <> pdoc platform lbl+ | otherwise = text ".globl " <> pprAsmLabel platform lbl pprTypeAndSizeDecl :: Platform -> CLabel -> SDoc pprTypeAndSizeDecl platform lbl = if platformOS platform == OSLinux && externallyVisibleCLabel lbl then text ".type " <>- pdoc platform lbl <> text ", @object"+ pprAsmLabel platform lbl <> text ", @object" else empty pprLabel :: Platform -> CLabel -> SDoc pprLabel platform lbl = pprGloblDecl platform lbl $$ pprTypeAndSizeDecl platform lbl- $$ (pdoc platform lbl <> char ':')+ $$ (pprAsmLabel platform lbl <> char ':') -- ----------------------------------------------------------------------------- -- pprInstr: print an 'Instr'@@ -238,9 +238,9 @@ pprImm platform = \case ImmInt i -> int i ImmInteger i -> integer i- ImmCLbl l -> pdoc platform l- ImmIndex l i -> pdoc platform l <> char '+' <> int i- ImmLit s -> s+ ImmCLbl l -> pprAsmLabel platform l+ ImmIndex l i -> pprAsmLabel platform l <> char '+' <> int i+ ImmLit s -> text s ImmFloat f -> float $ fromRational f ImmDouble d -> double $ fromRational d ImmConstantSum a b -> pprImm platform a <> char '+' <> pprImm platform b@@ -295,7 +295,6 @@ UninitialisedData | ppc64 -> text ".align 3" | otherwise -> text ".align 2"- ReadOnlyData16 -> text ".align 4" -- TODO: This is copied from the ReadOnlyData case, but it can likely be -- made more efficient. InitArray -> text ".align 3"@@ -560,7 +559,7 @@ pprCond cond, pprPrediction prediction, char '\t',- pdoc platform lbl+ pprAsmLabel platform lbl ] where lbl = mkLocalBlockLabel (getUnique blockid) pprPrediction p = case p of@@ -578,7 +577,7 @@ ], hcat [ text "\tb\t",- pdoc platform lbl+ pprAsmLabel platform lbl ] ] where lbl = mkLocalBlockLabel (getUnique blockid)@@ -595,7 +594,7 @@ char '\t', text "b", char '\t',- pdoc platform lbl+ pprAsmLabel platform lbl ] MTCTR reg@@ -626,12 +625,12 @@ -- they'd technically be more like 'ForeignLabel's. hcat [ text "\tbl\t.",- pdoc platform lbl+ pprAsmLabel platform lbl ] _ -> hcat [ text "\tbl\t",- pdoc platform lbl+ pprAsmLabel platform lbl ] BCTRL _
compiler/GHC/CmmToAsm/PPC/Regs.hs view
@@ -133,7 +133,7 @@ = ImmInt Int | ImmInteger Integer -- Sigh. | ImmCLbl CLabel -- AbstractC Label (with baggage)- | ImmLit SDoc -- Simple string+ | ImmLit String | ImmIndex CLabel Int | ImmFloat Rational | ImmDouble Rational@@ -147,7 +147,7 @@ strImmLit :: String -> Imm-strImmLit s = ImmLit (text s)+strImmLit s = ImmLit s litToImm :: CmmLit -> Imm
compiler/GHC/CmmToAsm/Ppr.hs view
@@ -210,7 +210,7 @@ platform = ncgPlatform config splitSections = ncgSplitSections config subsection- | splitSections = sep <> pdoc platform suffix+ | splitSections = sep <> pprAsmLabel platform suffix | otherwise = empty header = case t of Text -> text ".text"@@ -224,9 +224,6 @@ -> text ".rdata$rel.ro" | otherwise -> text ".data.rel.ro" UninitialisedData -> text ".bss"- ReadOnlyData16 | OSMinGW32 <- platformOS platform- -> text ".rdata$cst16"- | otherwise -> text ".rodata.cst16" InitArray | OSMinGW32 <- platformOS platform -> text ".ctors"@@ -256,7 +253,6 @@ Data -> text ".csect .data[RW]" ReadOnlyData -> text ".csect .text[PR] # ReadOnlyData" RelocatableReadOnlyData -> text ".csect .text[PR] # RelocatableReadOnlyData"- ReadOnlyData16 -> text ".csect .text[PR] # ReadOnlyData16" CString -> text ".csect .text[PR] # CString" UninitialisedData -> text ".csect .data[BS]" _ -> panic "pprXcoffSectionHeader: unknown section type"@@ -268,7 +264,6 @@ ReadOnlyData -> text ".const" RelocatableReadOnlyData -> text ".const_data" UninitialisedData -> text ".data"- ReadOnlyData16 -> text ".const" InitArray -> text ".section\t__DATA,__mod_init_func,mod_init_funcs" FiniArray -> panic "pprDarwinSectionHeader: fini not supported" CString -> text ".section\t__TEXT,__cstring,cstring_literals"
compiler/GHC/CmmToAsm/X86/CodeGen.hs view
@@ -1048,10 +1048,29 @@ -------------------- add_code :: Width -> CmmExpr -> CmmExpr -> NatM Register+ -- x + imm add_code rep x (CmmLit (CmmInt y _)) | is32BitInteger y , rep /= W8 -- LEA doesn't support byte size (#18614) = add_int rep x y+ -- x + (y << imm)+ add_code rep x y+ -- Byte size is not supported and 16bit size is slow when computed via LEA+ | rep /= W8 && rep /= W16+ -- 2^3 = 8 is the highest multiplicator supported by LEA.+ , Just (x,y,shift_bits) <- get_shift x y+ = add_shiftL rep x y (fromIntegral shift_bits)+ where+ -- x + (y << imm)+ get_shift x (CmmMachOp (MO_Shl _w) [y, CmmLit (CmmInt shift_bits _)])+ | shift_bits <= 3+ = Just (x, y, shift_bits)+ -- (y << imm) + x+ get_shift (CmmMachOp (MO_Shl _w) [y, CmmLit (CmmInt shift_bits _)]) x+ | shift_bits <= 3+ = Just (x, y, shift_bits)+ get_shift _ _+ = Nothing add_code rep x y = trivialCode rep (ADD format) (Just (ADD format)) x y where format = intFormat rep -- TODO: There are other interesting patterns we want to replace@@ -1066,6 +1085,7 @@ sub_code rep x y = trivialCode rep (SUB (intFormat rep)) Nothing x y -- our three-operand add instruction:+ add_int :: (Width -> CmmExpr -> Integer -> NatM Register) add_int width x y = do (x_reg, x_code) <- getSomeReg x let@@ -1079,6 +1099,22 @@ -- return (Any format code) + -- x + (y << shift_bits) using LEA+ add_shiftL :: (Width -> CmmExpr -> CmmExpr -> Int -> NatM Register)+ add_shiftL width x y shift_bits = do+ (x_reg, x_code) <- getSomeReg x+ (y_reg, y_code) <- getSomeReg y+ let+ format = intFormat width+ imm = ImmInt 0+ code dst+ = (x_code `appOL` y_code) `snocOL`+ LEA format+ (OpAddr (AddrBaseIndex (EABaseReg x_reg) (EAIndex y_reg (2 ^ shift_bits)) imm))+ (OpReg dst)+ --+ return (Any format code)+ ---------------------- -- See Note [DIV/IDIV for bytes]@@ -2922,11 +2958,12 @@ else do -- See Note [%rip-relative addressing on x86-64]. tableReg <- getNewRegNat (intFormat (platformWordWidth platform))+ targetReg <- getNewRegNat (intFormat (platformWordWidth platform)) let op = OpAddr (AddrBaseIndex (EABaseReg tableReg) (EAIndex reg (platformWordSizeInBytes platform)) (ImmInt 0)) code = e_code `appOL` toOL [ LEA (archWordFormat is32bit) (OpAddr (AddrBaseIndex EABaseRip EAIndexNone (ImmCLbl lbl))) (OpReg tableReg)- , MOV (archWordFormat is32bit) op (OpReg reg)- , JMP_TBL (OpReg reg) ids (Section ReadOnlyData lbl) lbl+ , MOV (archWordFormat is32bit) op (OpReg targetReg)+ , JMP_TBL (OpReg targetReg) ids (Section ReadOnlyData lbl) lbl ] return code where
compiler/GHC/CmmToAsm/X86/Ppr.hs view
@@ -93,7 +93,7 @@ pprProcAlignment config $$ pprProcLabel config lbl $$ (if platformHasSubsectionsViaSymbols platform- then pdoc platform (mkDeadStripPreventer info_lbl) <> colon+ then pprAsmLabel platform (mkDeadStripPreventer info_lbl) <> colon else empty) $$ vcat (map (pprBasicBlock config top_info) blocks) $$ ppWhen (ncgDwarfEnabled config) (pprProcEndLabel platform info_lbl) $$@@ -102,9 +102,9 @@ (if platformHasSubsectionsViaSymbols platform then -- See Note [Subsections Via Symbols] text "\t.long "- <+> pdoc platform info_lbl+ <+> pprAsmLabel platform info_lbl <+> char '-'- <+> pdoc platform (mkDeadStripPreventer info_lbl)+ <+> pprAsmLabel platform (mkDeadStripPreventer info_lbl) else empty) $$ pprSizeDecl platform info_lbl @@ -120,18 +120,18 @@ pprProcEndLabel :: Platform -> CLabel -- ^ Procedure name -> SDoc pprProcEndLabel platform lbl =- pdoc platform (mkAsmTempProcEndLabel lbl) <> colon+ pprAsmLabel platform (mkAsmTempProcEndLabel lbl) <> colon pprBlockEndLabel :: Platform -> CLabel -- ^ Block name -> SDoc pprBlockEndLabel platform lbl =- pdoc platform (mkAsmTempEndLabel lbl) <> colon+ pprAsmLabel platform (mkAsmTempEndLabel lbl) <> colon -- | Output the ELF .size directive. pprSizeDecl :: Platform -> CLabel -> SDoc pprSizeDecl platform lbl = if osElfTarget (platformOS platform)- then text "\t.size" <+> pdoc platform lbl <> text ", .-" <> pdoc platform lbl+ then text "\t.size" <+> pprAsmLabel platform lbl <> text ", .-" <> pprAsmLabel platform lbl else empty pprBasicBlock :: NCGConfig -> LabelMap RawCmmStatics -> NatBasicBlock Instr -> SDoc@@ -156,7 +156,7 @@ vcat (map (pprData config) info) $$ pprLabel platform infoLbl $$ c $$- ppWhen (ncgDwarfEnabled config) (pdoc platform (mkAsmTempEndLabel infoLbl) <> colon)+ ppWhen (ncgDwarfEnabled config) (pprAsmLabel platform (mkAsmTempEndLabel infoLbl) <> colon) -- Make sure the info table has the right .loc for the block -- coming right after it. See Note [Info Offset]@@ -175,7 +175,7 @@ , Just ind' <- labelInd ind , alias `mayRedirectTo` ind' = pprGloblDecl (ncgPlatform config) alias- $$ text ".equiv" <+> pdoc (ncgPlatform config) alias <> comma <> pdoc (ncgPlatform config) (CmmLabel ind')+ $$ text ".equiv" <+> pprAsmLabel (ncgPlatform config) alias <> comma <> pprAsmLabel (ncgPlatform config) ind' pprDatas config (align, (CmmStaticsRaw lbl dats)) = vcat (pprAlign platform align : pprLabel platform lbl : map (pprData config) dats)@@ -197,7 +197,7 @@ pprGloblDecl :: Platform -> CLabel -> SDoc pprGloblDecl platform lbl | not (externallyVisibleCLabel lbl) = empty- | otherwise = text ".globl " <> pdoc platform lbl+ | otherwise = text ".globl " <> pprAsmLabel platform lbl pprLabelType' :: Platform -> CLabel -> SDoc pprLabelType' platform lbl =@@ -260,14 +260,14 @@ pprTypeDecl :: Platform -> CLabel -> SDoc pprTypeDecl platform lbl = if osElfTarget (platformOS platform) && externallyVisibleCLabel lbl- then text ".type " <> pdoc platform lbl <> text ", " <> pprLabelType' platform lbl+ then text ".type " <> pprAsmLabel platform lbl <> text ", " <> pprLabelType' platform lbl else empty pprLabel :: Platform -> CLabel -> SDoc pprLabel platform lbl = pprGloblDecl platform lbl $$ pprTypeDecl platform lbl- $$ (pdoc platform lbl <> colon)+ $$ (pprAsmLabel platform lbl <> colon) pprAlign :: Platform -> Alignment -> SDoc pprAlign platform alignment@@ -430,9 +430,9 @@ pprImm platform = \case ImmInt i -> int i ImmInteger i -> integer i- ImmCLbl l -> pdoc platform l- ImmIndex l i -> pdoc platform l <> char '+' <> int i- ImmLit s -> s+ ImmCLbl l -> pprAsmLabel platform l+ ImmIndex l i -> pprAsmLabel platform l <> char '+' <> int i+ ImmLit s -> text s ImmFloat f -> float $ fromRational f ImmDouble d -> double $ fromRational d ImmConstantSum a b -> pprImm platform a <> char '+' <> pprImm platform b@@ -487,12 +487,10 @@ OSDarwin | target32Bit platform -> case seg of- ReadOnlyData16 -> int 4 CString -> int 1 _ -> int 2 | otherwise -> case seg of- ReadOnlyData16 -> int 4 CString -> int 1 _ -> int 3 -- Other: alignments are given as bytes.@@ -500,12 +498,10 @@ | target32Bit platform -> case seg of Text -> text "4,0x90"- ReadOnlyData16 -> int 16 CString -> int 1 _ -> int 4 | otherwise -> case seg of- ReadOnlyData16 -> int 16 CString -> int 1 _ -> int 8 @@ -580,7 +576,7 @@ UNWIND lbl d -> asmComment (text "\tunwind = " <> pdoc platform d)- $$ pdoc platform lbl <> colon+ $$ pprAsmLabel platform lbl <> colon LDATA _ _ -> panic "pprInstr: LDATA"@@ -822,7 +818,7 @@ -> pprFormatOpReg (text "xchg") format src val JXX cond blockid- -> pprCondInstr (text "j") cond (pdoc platform lab)+ -> pprCondInstr (text "j") cond (pprAsmLabel platform lab) where lab = blockLbl blockid JXX_GBL cond imm
compiler/GHC/CmmToAsm/X86/Regs.hs view
@@ -55,7 +55,6 @@ import GHC.Cmm import GHC.Cmm.CLabel ( CLabel )-import GHC.Utils.Outputable import GHC.Utils.Panic import GHC.Platform @@ -111,7 +110,7 @@ = ImmInt Int | ImmInteger Integer -- Sigh. | ImmCLbl CLabel -- AbstractC Label (with baggage)- | ImmLit SDoc -- Simple string+ | ImmLit String | ImmIndex CLabel Int | ImmFloat Rational | ImmDouble Rational@@ -119,7 +118,7 @@ | ImmConstantDiff Imm Imm strImmLit :: String -> Imm-strImmLit s = ImmLit (text s)+strImmLit s = ImmLit s litToImm :: CmmLit -> Imm
compiler/GHC/CmmToLlvm/Base.hs view
@@ -58,7 +58,7 @@ import Data.Maybe (fromJust) import Control.Monad (ap)-import Data.List (sortBy, groupBy)+import Data.List (sortBy, groupBy, isPrefixOf) import Data.Ord (comparing) -- ----------------------------------------------------------------------------@@ -504,6 +504,12 @@ modifyEnv $ \env -> env { envAliases = emptyUniqSet } return (concat defss, []) +-- | Is a variable one of the special @$llvm@ globals?+isBuiltinLlvmVar :: LlvmVar -> Bool+isBuiltinLlvmVar (LMGlobalVar lbl _ _ _ _ _) =+ "$llvm" `isPrefixOf` unpackFS lbl+isBuiltinLlvmVar _ = False+ -- | Here we take a global variable definition, rename it with a -- @$def@ suffix, and generate the appropriate alias. aliasify :: LMGlobal -> LlvmM [LMGlobal]@@ -511,8 +517,9 @@ -- Here we obtain the indirectee's precise type and introduce -- fresh aliases to both the precise typed label (lbl$def) and the i8* -- typed (regular) label of it with the matching new names.-aliasify (LMGlobal (LMGlobalVar lbl ty@LMAlias{} link sect align Alias)- (Just orig)) = do+aliasify (LMGlobal var@(LMGlobalVar lbl ty@LMAlias{} link sect align Alias)+ (Just orig))+ | not $ isBuiltinLlvmVar var = do let defLbl = llvmDefLabel lbl LMStaticPointer (LMGlobalVar origLbl _ oLnk Nothing Nothing Alias) = orig defOrigLbl = llvmDefLabel origLbl@@ -525,7 +532,8 @@ pure [ LMGlobal (LMGlobalVar defLbl ty link sect align Alias) (Just defOrig) , LMGlobal (LMGlobalVar lbl i8Ptr link sect align Alias) (Just orig') ]-aliasify (LMGlobal var val) = do+aliasify (LMGlobal var val)+ | not $ isBuiltinLlvmVar var = do let LMGlobalVar lbl ty link sect align const = var defLbl = llvmDefLabel lbl@@ -543,6 +551,7 @@ return [ LMGlobal defVar val , LMGlobal aliasVar (Just aliasVal) ]+aliasify global = pure [global] -- Note [Llvm Forward References] -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@@ -601,3 +610,6 @@ -- away with casting the alias to the desired type in @getSymbolPtr@ -- and instead just emit a reference to the definition symbol directly. -- This is the @Just@ case in @getSymbolPtr@.+--+-- Note that we must take care not to turn LLVM's builtin variables into+-- aliases (e.g. $llvm.global_ctors) since this confuses LLVM.
compiler/GHC/CmmToLlvm/CodeGen.hs view
@@ -1705,7 +1705,6 @@ where binLlvmOp ty binOp allow_y_cast = do- cfg <- getConfig platform <- getPlatform runExprData $ do vx <- exprToVarW x@@ -1721,13 +1720,7 @@ doExprW (ty vx) $ binOp vx vy' | otherwise- -> do- -- Error. Continue anyway so we can debug the generated ll file.- let render = renderWithContext (llvmCgContext cfg)- cmmToStr = (lines . render . pdoc platform)- statement $ Comment $ map fsLit $ cmmToStr x- statement $ Comment $ map fsLit $ cmmToStr y- doExprW (ty vx) $ binOp vx vy+ -> pprPanic "binLlvmOp types" (pdoc platform x $$ pdoc platform y) binCastLlvmOp ty binOp = runExprData $ do vx <- exprToVarW x
compiler/GHC/CmmToLlvm/Data.hs view
@@ -138,9 +138,6 @@ RelocatableReadOnlyData -> case platformOS p of OSMinGW32 -> fsLit ".rdata$rel.ro" _ -> fsLit ".data.rel.ro"- ReadOnlyData16 -> case platformOS p of- OSMinGW32 -> fsLit ".rdata$cst16"- _ -> fsLit ".rodata.cst16" Data -> fsLit ".data" UninitialisedData -> fsLit ".bss" CString -> case platformOS p of
compiler/GHC/Core/LateCC.hs view
@@ -3,12 +3,15 @@ -- | Adds cost-centers after the core piple has run. module GHC.Core.LateCC- ( addLateCostCentres+ ( addLateCostCentresMG+ , addLateCostCentresPgm+ , addLateCostCentres -- Might be useful for API users+ , Env(..) ) where import Control.Applicative-import GHC.Utils.Monad.State.Strict import Control.Monad+import qualified Data.Set as S import GHC.Prelude import GHC.Types.CostCentre@@ -20,22 +23,84 @@ import GHC.Unit.Types import GHC.Data.FastString import GHC.Core-import GHC.Types.Id+import GHC.Core.Opt.Monad import GHC.Core.Utils (mkTick)+import GHC.Types.Id+import GHC.Driver.Session -addLateCostCentres :: Bool -> ModGuts -> ModGuts-addLateCostCentres prof_count_entries guts = let- env = Env- { thisModule = mg_module guts- , ccState = newCostCentreState- , countEntries = prof_count_entries- }- in guts { mg_binds = doCoreProgram env (mg_binds guts) }+import GHC.Utils.Logger+import GHC.Utils.Outputable+import GHC.Utils.Misc+import GHC.Utils.Error (withTiming)+import GHC.Utils.Monad.State.Strict -doCoreProgram :: Env -> CoreProgram -> CoreProgram-doCoreProgram env binds = flip evalState newCostCentreState $ do- mapM (doBind env) binds +{- Note [Collecting late cost centres]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Usually cost centres defined by a module are collected+during tidy by collectCostCentres. However with `-fprof-late`+we insert cost centres after inlining. So we keep a list of+all the cost centres we inserted and combine that with the list+of cost centres found during tidy.++To avoid overhead when using -fprof-inline there is a flag to stop+us from collecting them here when we run this pass before tidy.++Note [Adding late cost centres]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+The basic idea is very simple. For every top level binder+`f = rhs` we compile it as if the user had written+`f = {-# SCC f #-} rhs`.++If we do this after unfoldings for `f` have been created this+doesn't impact core-level optimizations at all. If we do it+before the cost centre will be included in the unfolding and+might inhibit optimizations at the call site. For this reason+we provide flags for both approaches as they have different+tradeoffs.++We also don't add a cost centre for any binder that is a constructor+worker or wrapper. These will never meaningfully enrich the resulting+profile so we improve efficiency by omitting those.++-}++addLateCostCentresMG :: ModGuts -> CoreM ModGuts+addLateCostCentresMG guts = do+ dflags <- getDynFlags+ let env :: Env+ env = Env+ { thisModule = mg_module guts+ , ccState = newCostCentreState+ , countEntries = gopt Opt_ProfCountEntries dflags+ , collectCCs = False -- See Note [Collecting late cost centres]+ }+ let guts' = guts { mg_binds = fst (addLateCostCentres env (mg_binds guts))+ }+ return guts'++addLateCostCentresPgm :: DynFlags -> Logger -> Module -> CoreProgram -> IO (CoreProgram, S.Set CostCentre)+addLateCostCentresPgm dflags logger mod binds =+ withTiming logger+ (text "LateCC"<+>brackets (ppr mod))+ (\(a,b) -> a `seqList` (b `seq` ())) $ do+ let env = Env+ { thisModule = mod+ , ccState = newCostCentreState+ , countEntries = gopt Opt_ProfCountEntries dflags+ , collectCCs = True -- See Note [Collecting late cost centres]+ }+ (binds', ccs) = addLateCostCentres env binds+ when (dopt Opt_D_dump_late_cc dflags || dopt Opt_D_verbose_core2core dflags) $+ putDumpFileMaybe logger Opt_D_dump_late_cc "LateCC" FormatCore (vcat (map ppr binds'))+ return (binds', ccs)++addLateCostCentres :: Env -> CoreProgram -> (CoreProgram,S.Set CostCentre)+addLateCostCentres env binds =+ let (binds', state) = runState (mapM (doBind env) binds) initLateCCState+ in (binds',lcs_ccs state)++ doBind :: Env -> CoreBind -> M CoreBind doBind env (NonRec b rhs) = NonRec b <$> doBndr env b rhs doBind env (Rec bs) = Rec <$> mapM doPair bs@@ -44,28 +109,59 @@ doPair (b,rhs) = (b,) <$> doBndr env b rhs doBndr :: Env -> Id -> CoreExpr -> M CoreExpr-doBndr env bndr rhs = do+doBndr env bndr rhs+ -- Cost centres on constructor workers are pretty much useless+ -- so we don't emit them if we are looking at the rhs of a constructor+ -- binding.+ | Just _ <- isDataConId_maybe bndr = pure rhs+ | otherwise = doBndr' env bndr rhs+++-- We want to put the cost centra below the lambda as we only care about executions of the RHS.+doBndr' :: Env -> Id -> CoreExpr -> State LateCCState CoreExpr+doBndr' env bndr (Lam b rhs) = Lam b <$> doBndr' env bndr rhs+doBndr' env bndr rhs = do let name = idName bndr name_loc = nameSrcSpan name cc_name = getOccFS name count = countEntries env- cc_flavour <- getCCExprFlavour cc_name+ cc_flavour <- getCCFlavour cc_name let cc_mod = thisModule env bndrCC = NormalCC cc_flavour cc_name cc_mod name_loc note = ProfNote bndrCC count True+ addCC env bndrCC return $ mkTick note rhs -type M = State CostCentreState+data LateCCState = LateCCState+ { lcs_state :: !CostCentreState+ , lcs_ccs :: S.Set CostCentre+ }+type M = State LateCCState -getCCExprFlavour :: FastString -> M CCFlavour-getCCExprFlavour name = ExprCC <$> getCCIndex' name+initLateCCState :: LateCCState+initLateCCState = LateCCState newCostCentreState mempty +getCCFlavour :: FastString -> M CCFlavour+getCCFlavour name = LateCC <$> getCCIndex' name+ getCCIndex' :: FastString -> M CostCentreIndex-getCCIndex' name = state (getCCIndex name)+getCCIndex' name = do+ state <- get+ let (index,cc_state') = getCCIndex name (lcs_state state)+ put (state { lcs_state = cc_state'})+ return index +addCC :: Env -> CostCentre -> M ()+addCC !env cc = do+ state <- get+ when (collectCCs env) $ do+ let ccs' = S.insert cc (lcs_ccs state)+ put (state { lcs_ccs = ccs'})+ data Env = Env- { thisModule :: Module- , countEntries :: Bool- , ccState :: CostCentreState+ { thisModule :: !Module+ , countEntries:: !Bool+ , ccState :: !CostCentreState+ , collectCCs :: !Bool }
compiler/GHC/Core/Opt/CSE.hs view
@@ -696,7 +696,7 @@ where env = emptyCSEnv {cs_subst = mkEmptySubst (mkInScopeSet (exprFreeVars e)) } cseExpr :: CSEnv -> InExpr -> OutExpr-cseExpr env (Type t) = Type (substTy (csEnvSubst env) t)+cseExpr env (Type t) = Type (substTyUnchecked (csEnvSubst env) t) cseExpr env (Coercion c) = Coercion (substCo (csEnvSubst env) c) cseExpr _ (Lit lit) = Lit lit cseExpr env (Var v) = lookupSubst env v@@ -714,7 +714,7 @@ = Case scrut1 bndr3 ty' $ combineAlts (map cse_alt alts) where- ty' = substTy (csEnvSubst env) ty+ ty' = substTyUnchecked (csEnvSubst env) ty (cse_done, scrut1) = try_for_cse env scrut bndr1 = zapIdOccInfo bndr
compiler/GHC/Core/Opt/DmdAnal.hs view
@@ -956,16 +956,15 @@ = -- pprTrace "dmdAnalRhsSig" (ppr id $$ ppr let_dmd $$ ppr rhs_dmds $$ ppr sig $$ ppr lazy_fv) $ (final_env, lazy_fv, final_id, final_rhs) where- rhs_arity = idArity id- -- See Note [Demand signatures are computed for a threshold demand based on idArity]+ threshold_arity = thresholdArity id rhs - rhs_dmd = mkCalledOnceDmds rhs_arity body_dmd+ rhs_dmd = mkCalledOnceDmds threshold_arity body_dmd body_dmd | isJoinId id -- See Note [Demand analysis for join points] -- See Note [Invariants on join points] invariant 2b, in GHC.Core- -- rhs_arity matches the join arity of the join point+ -- threshold_arity matches the join arity of the join point -- See Note [Unboxed demand on function bodies returning small products] = unboxedWhenSmall env rec_flag (resultType_maybe id) let_dmd | otherwise@@ -975,10 +974,10 @@ WithDmdType rhs_dmd_ty rhs' = dmdAnal env rhs_dmd rhs DmdType rhs_fv rhs_dmds rhs_div = rhs_dmd_ty -- See Note [Boxity for bottoming functions]- (final_rhs_dmds, final_rhs) = finaliseArgBoxities env id rhs_arity rhs' rhs_div+ (final_rhs_dmds, final_rhs) = finaliseArgBoxities env id threshold_arity rhs' rhs_div `orElse` (rhs_dmds, rhs') - sig = mkDmdSigForArity rhs_arity (DmdType sig_fv final_rhs_dmds rhs_div)+ sig = mkDmdSigForArity threshold_arity (DmdType sig_fv final_rhs_dmds rhs_div) final_id = id `setIdDmdSig` sig !final_env = extendAnalEnv top_lvl env final_id sig@@ -1005,6 +1004,13 @@ -- See Note [Lazy and unleashable free variables] !(!lazy_fv, !sig_fv) = partitionVarEnv isWeakDmd rhs_fv2 +thresholdArity :: Id -> CoreExpr -> Arity+-- See Note [Demand signatures are computed for a threshold arity based on idArity]+thresholdArity fn rhs+ = case isJoinId_maybe fn of+ Just join_arity -> count isId $ fst $ collectNBinders join_arity rhs+ Nothing -> idArity fn+ -- | The result type after applying 'idArity' many arguments. Returns 'Nothing' -- when the type doesn't have exactly 'idArity' many arrows. resultType_maybe :: Id -> Maybe Type@@ -1137,29 +1143,41 @@ there's a \y inside. But it's right because when consumed in a C1(L) context the RHS of the join point is indeed bottom. -Note [Demand signatures are computed for a threshold demand based on idArity]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-We compute demand signatures assuming idArity incoming arguments to approximate-behavior for when we have a call site with at least that many arguments. idArity-is /at least/ the number of manifest lambdas, but might be higher for PAPs and-trivial RHS (see Note [Demand analysis for trivial right-hand sides]).+Note [Demand signatures are computed for a threshold arity based on idArity]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Given a binding { f = rhs }, we compute a "theshold arity", and do demand+analysis based on a call with that many value arguments. -Because idArity of a function varies independently of its cardinality-properties (cf. Note [idArity varies independently of dmdTypeDepth]), we-implicitly encode the arity for when a demand signature is sound to unleash-in its 'dmdTypeDepth' (cf. Note [Understanding DmdType and DmdSig] in-GHC.Types.Demand). It is unsound to unleash a demand signature when the-incoming number of arguments is less than that.-See Note [What are demand signatures?] in GHC.Types.Demand for more details-on soundness.+The threshold we use is -Why idArity arguments? Because that's a conservative estimate of how many-arguments we must feed a function before it does anything interesting with them.-Also it elegantly subsumes the trivial RHS and PAP case.+* Ordinary bindings: idArity f.+ Why idArity arguments? Because that's a conservative estimate of how many+ arguments we must feed a function before it does anything interesting with+ them. Also it elegantly subsumes the trivial RHS and PAP case. -There might be functions for which we might want to analyse for more incoming-arguments than idArity. Example:+ idArity is /at least/ the number of manifest lambdas, but might be higher for+ PAPs and trivial RHS (see Note [Demand analysis for trivial right-hand sides]). +* Join points: the value-binder subset of the JoinArity. This can+ be less than the number of visible lambdas; e.g.+ join j x = \y. blah+ in ...(jump j 2)....(jump j 3)....+ We know that j will never be applied to more than 1 arg (its join+ arity, and we don't eta-expand join points, so here a threshold+ of 1 is the best we can do.++Note that the idArity of a function varies independently of its cardinality+properties (cf. Note [idArity varies independently of dmdTypeDepth]), so we+implicitly encode the arity for when a demand signature is sound to unleash+in its 'dmdTypeDepth', not in its idArity (cf. Note [Understanding DmdType+and DmdSig] in GHC.Types.Demand). It is unsound to unleash a demand+signature when the incoming number of arguments is less than that. See+GHC.Types.Demand Note [What are demand signatures?] for more details on+soundness.++Note that there might, in principle, be functions for which we might want to+analyse for more incoming arguments than idArity. Example:+ f x = if expensive then \y -> ... y ...@@ -1175,6 +1193,7 @@ information, but * We would no longer be able to unleash the signature at unary call sites+ * Performing the worker/wrapper split based on this information would be implicitly eta-expanding `f`, playing fast and loose with divergence and even being unsound in the presence of newtypes, so we refrain from doing so.
compiler/GHC/Core/Opt/FloatOut.hs view
@@ -15,12 +15,13 @@ import GHC.Core import GHC.Core.Utils import GHC.Core.Make-import GHC.Core.Opt.Arity ( exprArity, etaExpand )+-- import GHC.Core.Opt.Arity ( exprArity, etaExpand ) import GHC.Core.Opt.Monad ( FloatOutSwitches(..) ) import GHC.Driver.Flags ( DumpFlag (..) ) import GHC.Utils.Logger-import GHC.Types.Id ( Id, idArity, idType, isDeadEndId,+import GHC.Types.Id ( Id, idType,+-- idArity, isDeadEndId, isJoinId, isJoinId_maybe ) import GHC.Types.Tickish import GHC.Core.Opt.SetLevels@@ -218,14 +219,7 @@ -- See Note [Floating out of Rec rhss] for why things get arranged this way. floatBind (NonRec (TB var _) rhs) = case (floatRhs var rhs) of { (fs, rhs_floats, rhs') ->-- -- A tiresome hack:- -- see Note [Bottoming floats: eta expansion] in GHC.Core.Opt.SetLevels- let rhs'' | isDeadEndId var- , exprArity rhs' < idArity var = etaExpand (idArity var) rhs'- | otherwise = rhs'-- in (fs, rhs_floats, [NonRec var rhs'']) }+ (fs, rhs_floats, [NonRec var rhs']) } floatBind (Rec pairs) = case floatList do_pair pairs of { (fs, rhs_floats, new_pairs) ->
compiler/GHC/Core/Opt/Pipeline.hs view
@@ -43,7 +43,7 @@ import GHC.Core.Opt.Exitify ( exitifyProgram ) import GHC.Core.Opt.WorkWrap ( wwTopBinds ) import GHC.Core.Opt.CallerCC ( addCallerCostCentres )-import GHC.Core.LateCC (addLateCostCentres)+import GHC.Core.LateCC (addLateCostCentresMG) import GHC.Core.Seq (seqBinds) import GHC.Core.FamInstEnv @@ -198,7 +198,7 @@ runWhen (profiling && not (null $ callerCcFilters dflags)) CoreAddCallerCcs add_late_ccs =- runWhen (profiling && gopt Opt_ProfLateCcs dflags) $ CoreAddLateCcs+ runWhen (profiling && gopt Opt_ProfLateInlineCcs dflags) $ CoreAddLateCcs core_todo = [@@ -463,7 +463,6 @@ p_fam_env <- getPackageFamInstEnv let platform = targetPlatform dflags let fam_envs = (p_fam_env, mg_fam_inst_env guts)- let prof_count_entries = gopt Opt_ProfCountEntries dflags let updateBinds f = return $ guts { mg_binds = f (mg_binds guts) } let updateBindsM f = f (mg_binds guts) >>= \b' -> return $ guts { mg_binds = b' } @@ -513,7 +512,7 @@ addCallerCostCentres guts CoreAddLateCcs -> {-# SCC "AddLateCcs" #-}- return (addLateCostCentres prof_count_entries guts)+ addLateCostCentresMG guts CoreDoPrintCore -> {-# SCC "PrintCore" #-} liftIO $ printCore logger (mg_binds guts) >> return guts
compiler/GHC/Core/Opt/SetLevels.hs view
@@ -1,4 +1,3 @@- {-# LANGUAGE PatternSynonyms #-} {-# OPTIONS_GHC -Wno-incomplete-uni-patterns #-}@@ -105,7 +104,7 @@ import GHC.Types.Var.Env import GHC.Types.Literal ( litIsTrivial ) import GHC.Types.Demand ( DmdSig, prependArgsDmdSig )-import GHC.Types.Cpr ( mkCprSig, botCpr )+import GHC.Types.Cpr ( CprSig, prependArgsCprSig ) import GHC.Types.Name ( getOccName, mkSystemVarName ) import GHC.Types.Name.Occurrence ( occNameString ) import GHC.Types.Unique ( hasKey )@@ -363,7 +362,7 @@ If there were another lambda in @r@'s rhs, it would get level-2 as well. -} -lvlExpr env (_, AnnType ty) = return (Type (GHC.Core.Subst.substTy (le_subst env) ty))+lvlExpr env (_, AnnType ty) = return (Type (substTyUnchecked (le_subst env) ty)) lvlExpr env (_, AnnCoercion co) = return (Coercion (substCo (le_subst env) co)) lvlExpr env (_, AnnVar v) = return (lookupVar env v) lvlExpr _ (_, AnnLit lit) = return (Lit lit)@@ -492,7 +491,7 @@ ; alts' <- mapM (lvl_alt alts_env) alts ; return (Case scrut' case_bndr' ty' alts') } where- ty' = substTy (le_subst env) ty+ ty' = substTyUnchecked (le_subst env) ty incd_lvl = incMinorLvl (le_ctxt_lvl env) dest_lvl = maxFvLevel (const True) env scrut_fvs@@ -623,7 +622,7 @@ -- the expression, so that it can itself be floated. lvlMFE env _ (_, AnnType ty)- = return (Type (GHC.Core.Subst.substTy (le_subst env) ty))+ = return (Type (substTyUnchecked (le_subst env) ty)) -- No point in floating out an expression wrapped in a coercion or note -- If we do we'll transform lvl = e |> co@@ -660,9 +659,7 @@ -- No wrapping needed if the type is lifted, or is a literal string -- or if we are wrapping it in one or more value lambdas = do { expr1 <- lvlFloatRhs abs_vars dest_lvl rhs_env NonRecursive- (isJust mb_bot_str)- join_arity_maybe- ann_expr+ is_bot_lam join_arity_maybe ann_expr -- Treat the expr just like a right-hand side ; var <- newLvlVar expr1 join_arity_maybe is_mk_static ; let var2 = annotateBotStr var float_n_lams mb_bot_str@@ -703,6 +700,7 @@ fvs = freeVarsOf ann_expr fvs_ty = tyCoVarsOfType expr_ty is_bot = isBottomThunk mb_bot_str+ is_bot_lam = isJust mb_bot_str is_function = isFunction ann_expr mb_bot_str = exprBotStrictness_maybe expr -- See Note [Bottoming floats]@@ -751,10 +749,10 @@ hasFreeJoin env fvs = not (maxFvLevel isJoinId env fvs == tOP_LEVEL) -isBottomThunk :: Maybe (Arity, s) -> Bool+isBottomThunk :: Maybe (Arity, DmdSig, CprSig) -> Bool -- See Note [Bottoming floats] (2)-isBottomThunk (Just (0, _)) = True -- Zero arity-isBottomThunk _ = False+isBottomThunk (Just (0, _, _)) = True -- Zero arity+isBottomThunk _ = False {- Note [Floating to the top] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@@ -978,16 +976,6 @@ thing is based on the cheap-and-cheerful exprIsDeadEnd, I'm not sure that it'll nail all such cases. -Note [Bottoming floats: eta expansion] c.f Note [Bottoming floats]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Tiresomely, though, the simplifier has an invariant that the manifest-arity of the RHS should be the same as the arity; but we can't call-etaExpand during GHC.Core.Opt.SetLevels because it works over a decorated form of-CoreExpr. So we do the eta expansion later, in GHC.Core.Opt.FloatOut.-But we should only eta-expand if the RHS doesn't already have the right-exprArity, otherwise we get unnecessary top-level bindings if the RHS was-trivial after the next run of the Simplifier.- Note [Case MFEs] ~~~~~~~~~~~~~~~~ We don't float a case expression as an MFE from a strict context. Why not?@@ -1009,17 +997,18 @@ -} -annotateBotStr :: Id -> Arity -> Maybe (Arity, DmdSig) -> Id+annotateBotStr :: Id -> Arity -> Maybe (Arity, DmdSig, CprSig) -> Id -- See Note [Bottoming floats] for why we want to add -- bottoming information right now -- -- n_extra are the number of extra value arguments added during floating-annotateBotStr id n_extra mb_str- = case mb_str of- Nothing -> id- Just (arity, sig) -> id `setIdArity` (arity + n_extra)- `setIdDmdSig` prependArgsDmdSig n_extra sig- `setIdCprSig` mkCprSig (arity + n_extra) botCpr+annotateBotStr id n_extra mb_bot_str+ | Just (arity, str_sig, cpr_sig) <- mb_bot_str+ = id `setIdArity` (arity + n_extra)+ `setIdDmdSig` prependArgsDmdSig n_extra str_sig+ `setIdCprSig` prependArgsCprSig n_extra cpr_sig+ | otherwise+ = id notWorthFloating :: CoreExpr -> [Var] -> Bool -- Returns True if the expression would be replaced by@@ -1128,7 +1117,7 @@ -- bit brutal, but unlifted bindings aren't expensive either = -- No float- do { rhs' <- lvlRhs env NonRecursive is_bot mb_join_arity rhs+ do { rhs' <- lvlRhs env NonRecursive is_bot_lam mb_join_arity rhs ; let bind_lvl = incMinorLvl (le_ctxt_lvl env) (env', [bndr']) = substAndLvlBndrs NonRecursive env bind_lvl [bndr] ; return (NonRec bndr' rhs', env') }@@ -1137,7 +1126,7 @@ | null abs_vars = do { -- No type abstraction; clone existing binder rhs' <- lvlFloatRhs [] dest_lvl env NonRecursive- is_bot mb_join_arity rhs+ is_bot_lam mb_join_arity rhs ; (env', [bndr']) <- cloneLetVars NonRecursive env dest_lvl [bndr] ; let bndr2 = annotateBotStr bndr' 0 mb_bot_str ; return (NonRec (TB bndr2 (FloatMe dest_lvl)) rhs', env') }@@ -1145,7 +1134,7 @@ | otherwise = do { -- Yes, type abstraction; create a new binder, extend substitution, etc rhs' <- lvlFloatRhs abs_vars dest_lvl env NonRecursive- is_bot mb_join_arity rhs+ is_bot_lam mb_join_arity rhs ; (env', [bndr']) <- newPolyBndrs dest_lvl env abs_vars [bndr] ; let bndr2 = annotateBotStr bndr' n_extra mb_bot_str ; return (NonRec (TB bndr2 (FloatMe dest_lvl)) rhs', env') }@@ -1156,11 +1145,12 @@ rhs_fvs = freeVarsOf rhs bind_fvs = rhs_fvs `unionDVarSet` dIdFreeVars bndr abs_vars = abstractVars dest_lvl env bind_fvs- dest_lvl = destLevel env bind_fvs ty_fvs (isFunction rhs) is_bot is_join+ dest_lvl = destLevel env bind_fvs ty_fvs (isFunction rhs) is_bot_lam is_join deann_rhs = deAnnotate rhs mb_bot_str = exprBotStrictness_maybe deann_rhs- is_bot = isJust mb_bot_str+ is_bot_lam = isJust mb_bot_str+ -- is_bot_lam: looks like (\xy. bot), maybe zero lams -- NB: not isBottomThunk! See Note [Bottoming floats] point (3) n_extra = count isId abs_vars@@ -1719,7 +1709,7 @@ mkSysLocal (mkFastString str) uniq (idMult bndr) poly_ty where str = "poly_" ++ occNameString (getOccName bndr)- poly_ty = mkLamTypes abs_vars (GHC.Core.Subst.substTy subst (idType bndr))+ poly_ty = mkLamTypes abs_vars (substTyUnchecked subst (idType bndr)) -- If we are floating a join point to top level, it stops being -- a join point. Otherwise it continues to be a join point,
compiler/GHC/Core/Opt/SpecConstr.hs view
@@ -79,6 +79,7 @@ import Data.List (nubBy, sortBy, partition, dropWhileEnd, mapAccumL ) import Data.Maybe( mapMaybe ) import Data.Ord( comparing )+import Data.Tuple {- -----------------------------------------------------@@ -665,14 +666,16 @@ well as constructor applications. Wrinkles:+ * This should all work perfectly fine for newtype classes. Mind you, currently newtype classes are inlined fairly agressively, but we may change that. And it would take extra code to exclude them, as well as being unnecessary. -* We (mis-) use LambdaVal for this purpose, because ConVal- requires us to list the data constructor and fields, and that- is (a) inconvenient and (b) unnecessary for class methods.+* In isValue, we (mis-) use LambdaVal for this ($fblah d1 .. dn)+ because ConVal requires us to list the data constructor and+ fields, and that is (a) inconvenient and (b) unnecessary for+ class methods. ----------------------------------------------------- Stuff not yet handled@@ -971,14 +974,24 @@ scSubstId :: ScEnv -> InId -> OutExpr scSubstId env v = lookupIdSubst (sc_subst env) v -scSubstTy :: ScEnv -> InType -> OutType-scSubstTy env ty = substTy (sc_subst env) ty+-- The !subst ensures that we force the selection `(sc_subst env)`, which avoids+-- retaining all of `env` when we only need `subst`. The `Solo` means that the+-- substitution itself is lazy, because that type is often discarded.+-- The callers of `scSubstTy` always force the result (to unpack the `Solo`)+-- so we get the desired effect: we leave a thunk, but retain only the subst,+-- not the whole env.+--+-- Fully forcing the result of `scSubstTy` regresses performance (#22102)+scSubstTy :: ScEnv -> InType -> Solo OutType+scSubstTy env ty =+ let !subst = sc_subst env+ in Solo (substTyUnchecked subst ty) scSubstCo :: ScEnv -> Coercion -> Coercion scSubstCo env co = substCo (sc_subst env) co zapScSubst :: ScEnv -> ScEnv-zapScSubst env = env { sc_subst = zapSubstEnv (sc_subst env) }+zapScSubst env = env { sc_subst = zapSubst (sc_subst env) } extendScInScope :: ScEnv -> [Var] -> ScEnv -- Bring the quantified variables into scope@@ -1217,8 +1230,21 @@ | UnkOcc -- Used in some unknown way | ScrutOcc -- See Note [ScrutOcc]- (DataConEnv [ArgOcc]) -- How the sub-components are used+ (DataConEnv [ArgOcc])+ -- [ArgOcc]: how the sub-components are used +deadArgOcc :: ArgOcc -> Bool+deadArgOcc (ScrutOcc {}) = False+deadArgOcc UnkOcc = False+deadArgOcc NoOcc = True++specialisableArgOcc :: ArgOcc -> Bool+-- | Does this occurence represent one worth specializing for.+specialisableArgOcc UnkOcc = False+specialisableArgOcc NoOcc = False+specialisableArgOcc (ScrutOcc {}) = True++ {- Note [ScrutOcc] ~~~~~~~~~~~~~~~~~~ An occurrence of ScrutOcc indicates that the thing, or a `cast` version of the thing,@@ -1243,6 +1269,9 @@ ppr NoOcc = text "no-occ" evalScrutOcc :: ArgOcc+-- We use evalScrutOcc for+-- - mkVarUsage: applied functions+-- - scApp: dicts that are the arugment of a classop evalScrutOcc = ScrutOcc emptyUFM -- Experimentally, this version of combineOcc makes ScrutOcc "win", so@@ -1407,7 +1436,9 @@ Var v' -> return (mkVarUsage env v' [], Var v') e' -> scExpr (zapScSubst env) e' -scExpr' env (Type t) = return (nullUsage, Type (scSubstTy env t))+scExpr' env (Type t) =+ let !(Solo ty') = scSubstTy env t+ in return (nullUsage, Type ty') scExpr' env (Coercion c) = return (nullUsage, Coercion (scSubstCo env c)) scExpr' _ e@(Lit {}) = return (nullUsage, e) scExpr' env (Tick t e) = do (usg, e') <- scExpr env e@@ -1443,30 +1474,74 @@ = do { let (alt_env,b') = extendBndrWith RecArg env b -- Record RecArg for the components - ; (alt_usgs, alt_occs, alts')- <- mapAndUnzip3M (sc_alt alt_env scrut' b') alts+ ; (alt_usgs, alt_occs, alts') <- mapAndUnzip3M (sc_alt alt_env scrut' b') alts ; let scrut_occ = foldr combineOcc NoOcc alt_occs scrut_usg' = setScrutOcc env scrut_usg scrut' scrut_occ -- The combined usage of the scrutinee is given- -- by scrut_occ, which is passed to scScrut, which+ -- by scrut_occ, which is passed to setScrutOcc, which -- in turn treats a bare-variable scrutinee specially+ ; let !(Solo ty') = scSubstTy env ty ; return (foldr combineUsage scrut_usg' alt_usgs,- Case scrut' b' (scSubstTy env ty) alts') }+ Case scrut' b' ty' alts') } + single_alt = isSingleton alts+ sc_alt env scrut' b' (Alt con bs rhs) = do { let (env1, bs1) = extendBndrsWith RecArg env bs (env2, bs2) = extendCaseBndrs env1 scrut' b' con bs1 ; (usg, rhs') <- scExpr env2 rhs ; let (usg', b_occ:arg_occs) = lookupOccs usg (b':bs2) scrut_occ = case con of- DataAlt dc -> ScrutOcc (unitUFM dc arg_occs)- _ -> evalScrutOcc+ DataAlt dc -- See Note [Do not specialise evals]+ | not (single_alt && all deadArgOcc arg_occs)+ -> ScrutOcc (unitUFM dc arg_occs)+ _ -> UnkOcc ; return (usg', b_occ `combineOcc` scrut_occ, Alt con bs2 rhs') } +{- Note [Do not specialise evals]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Consider+ f x y = case x of I# _ ->+ if y>1 then f x (y-1) else x++Here `x` is scrutinised by a case, but only in an eval-like way; the+/component/ of the I# is unused. We don't want to specialise this+function, even if we find a call (f (I# z)), because nothing is gained+ * No case branches are discarded+ * No allocation in removed+The specialised version would take an unboxed Int#, pass it along,+and rebox it at the end.++In fact this can cause significant regression. In #21763 we had:+like+ f = ... case x of x' { I# n ->+ join j y = rhs+ in ...jump j x'...++Now if we specialise `j` for the argument `I# n`, we'll end up reboxing+it in `j`, without even removing an allocation from the call site.++Reboxing is always a worry. But here we can ameliorate the problem as+follows.++* In scExpr (Case ...), for a /single-alternative/ case expression, in+ which the pattern binders are all unused, we build a UnkOcc for+ the scrutinee, not one that maps the data constructor; we don't treat+ this occurrence as a reason for specialisation.++* Conveniently, SpecConstr is doing its own occurrence analysis, so+ the "unused" bit is just looking for NoOcc++* Note that if we have+ f x = case x of { True -> e1; False -> e2 }+ then even though the pattern binders are unused (there are none), it is+ still worth specialising on x. Hence the /single-alternative/ guard.+-}+ scApp :: ScEnv -> (InExpr, [InExpr]) -> UniqSM (ScUsage, CoreExpr) scApp env (Var fn, args) -- Function is a variable@@ -1516,7 +1591,6 @@ , scu_occs = unitVarEnv fn arg_occ } Nothing -> nullUsage where- -- I rather think we could use UnkOcc all the time arg_occ | null args = UnkOcc | otherwise = evalScrutOcc @@ -2345,7 +2419,7 @@ -- over the following term variables -- The [CoreExpr] are the argument patterns for the rule callToPats env bndr_occs call@(Call fn args con_env)- = do { let in_scope = substInScope (sc_subst env)+ = do { let in_scope = getSubstInScope (sc_subst env) ; arg_tripples <- zipWith3M (argToPat env in_scope con_env) args bndr_occs (map (const NotMarkedStrict) args) -- This zip trims the args to be no longer than@@ -2554,10 +2628,8 @@ -- (b) we know what its value is -- In that case it counts as "interesting" argToPat1 env in_scope val_env (Var v) arg_occ arg_str- | sc_force env || case arg_occ of { ScrutOcc {} -> True- ; UnkOcc -> False- ; NoOcc -> False } -- (a)- , is_value -- (b)+ | sc_force env || specialisableArgOcc arg_occ -- (a)+ , is_value -- (b) -- Ignoring sc_keen here to avoid gratuitously incurring Note [Reboxing] -- So sc_keen focused just on f (I# x), where we have freshly-allocated -- box that we can eliminate in the caller
compiler/GHC/Core/Opt/Specialise.hs view
@@ -1,5 +1,3 @@-- {-# OPTIONS_GHC -Wno-incomplete-uni-patterns #-} {-@@ -19,7 +17,7 @@ import GHC.Tc.Utils.TcType hiding( substTy ) -import GHC.Core.Type hiding( substTy, extendTvSubstList )+import GHC.Core.Type hiding( substTy, extendTvSubstList, zapSubst ) import GHC.Core.Multiplicity import GHC.Core.Predicate import GHC.Core.Coercion( Coercion )@@ -1650,7 +1648,7 @@ = lookupRule ropts (in_scope, realIdUnfolding) (const True) fn args rules where dflags = se_dflags env- in_scope = Core.substInScope (se_subst env)+ in_scope = getSubstInScope (se_subst env) ropts = initRuleOpts dflags {- Note [Specialising DFuns]@@ -3063,10 +3061,10 @@ zapSubst :: SpecEnv -> SpecEnv zapSubst env@(SE { se_subst = subst })- = env { se_subst = Core.zapSubstEnv subst }+ = env { se_subst = Core.zapSubst subst } substTy :: SpecEnv -> Type -> Type-substTy env ty = Core.substTy (se_subst env) ty+substTy env ty = substTyUnchecked (se_subst env) ty substCo :: SpecEnv -> Coercion -> Coercion substCo env co = Core.substCo (se_subst env) co@@ -3101,7 +3099,7 @@ newDictBndr env@(SE { se_subst = subst }) b = do { uniq <- getUniqueM ; let n = idName b- ty' = Core.substTy subst (idType b)+ ty' = substTyUnchecked subst (idType b) b' = mkUserLocal (nameOccName n) uniq Many ty' (getSrcSpan n) env' = env { se_subst = subst `Core.extendSubstInScope` b' } ; pure (env', b') }
compiler/GHC/Core/Opt/WorkWrap.hs view
@@ -745,11 +745,7 @@ --------------------- splitFun :: WwOpts -> Id -> CoreExpr -> UniqSM [(Id, CoreExpr)] splitFun ww_opts fn_id rhs- | not (wrap_dmds `lengthIs` count isId arg_vars)- -- See Note [Don't eta expand in w/w]- = return [(fn_id, rhs)]-- | otherwise+ | Just (arg_vars, body) <- collectNValBinders_maybe (length wrap_dmds) rhs = warnPprTrace (not (wrap_dmds `lengthIs` (arityInfo fn_info))) "splitFun" (ppr fn_id <+> (ppr wrap_dmds $$ ppr cpr)) $@@ -772,10 +768,13 @@ -> do { work_uniq <- getUniqueM ; return (mkWWBindPair ww_opts fn_id fn_info arg_vars body work_uniq div stuff) } }++ | otherwise -- See Note [Don't eta expand in w/w]+ = return [(fn_id, rhs)]+ where uf_opts = so_uf_opts (wo_simple_opts ww_opts) fn_info = idInfo fn_id- (arg_vars, body) = collectBinders rhs (wrap_dmds, div) = splitDmdSig (dmdSigInfo fn_info)
compiler/GHC/Core/Opt/WorkWrap/Utils.hs view
@@ -136,19 +136,18 @@ data WwOpts = MkWwOpts- -- | Environment of type/data family instances- { wo_fam_envs :: !FamInstEnvs- -- | Options for the "Simple optimiser"- , wo_simple_opts :: !SimpleOpts- -- | Whether to enable "Constructed Product Result" analysis.- -- (Originally from DOI: 10.1017/S0956796803004751)- , wo_cpr_anal :: !Bool- -- | Used for absent argument error message- , wo_module :: !Module- -- | Generate workers even if the only effect is some args get passed- -- unlifted. See Note [WW for calling convention]- , wo_unlift_strict :: !Bool- }+ { -- | Environment of type/data family instances+ wo_fam_envs :: !FamInstEnvs+ , -- | Options for the "Simple optimiser"+ wo_simple_opts :: !SimpleOpts+ , -- | Whether to enable "Constructed Product Result" analysis.+ -- (Originally from DOI: 10.1017/S0956796803004751)+ wo_cpr_anal :: !Bool+ , -- | Used for absent argument error message+ wo_module :: !Module+ , -- | Generate workers even if the only effect is some args get passed+ -- unlifted. See Note [WW for calling convention]+ wo_unlift_strict :: !Bool } type WwResult = ([Demand], -- Demands for worker (value) args@@ -220,7 +219,7 @@ empty_subst = mkEmptySubst (mkInScopeSet args_free_tcvs) zapped_arg_vars = map zap_var arg_vars (subst, cloned_arg_vars) = cloneBndrs empty_subst uniq_supply zapped_arg_vars- res_ty' = GHC.Core.Subst.substTy subst res_ty+ res_ty' = substTyUnchecked subst res_ty init_str_marks = map (const NotMarkedStrict) cloned_arg_vars ; (useful1, work_args_str, wrap_fn_str, fn_args)@@ -784,6 +783,53 @@ stick with A) and a flag for B) for now. See also Note [Tag Inference] and Note [CBV Function Ids]++Note [Worker/wrapper for strict arguments]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Consider+ f x = case x of+ [] -> blah+ (y:ys) -> f ys++Clearly `f` is strict, but its argument is not a product type, so by default+we don't worker/wrapper it. But it is arguably valuable to do so. We could+do this:++ f x = case x of xx { DEFAULT -> $wf xx }+ $wf xx = case xx of+ [] -> blah+ (y:ys) -> f ys++Now the worker `$wf` knows that its argument `xx` will be evaluated+and properly tagged, so the code for the `case xx` does not need to do+an "eval" (see `GHC.StgToCmm.Expr.cgCase`). A call (f (a:as)) will+have the wrapper inlined, and will drop the `case x`, so no eval+happens at all.++The worker `$wf` is a CBV function (see `Note [CBV Function Ids]`+in GHC.Types.Id.Info) and the code generator guarantees that every+call to `$wf` has a properly tagged argument (see `GHC.Stg.InferTags.Rewrite`).++Is this a win? Not always:+* It can cause slight codesize increases. This is since we push evals to every+ call sites which there might be many. And the evals will only disappear at+ call sites where we already known that the argument is evaluated.++* It will also cause many more functions to get a worker/wrapper split+ which can play badly with rules (see Ticket #20364). In particular+ if you depend on rules firing on functions marked as NOINLINE+ without marking use sites of these functions as INLINE or INLINEABLE+ then things will break.+ But if you want a function to match in a RULE, it is /in any case/ good practice to+ have a `INLINE[1]` or `NOINLNE[1]` pragma, to ensure that it doesn't inline until+ the rule has had a chance to fire.++So there is a flag, `-fworker-wrapper-cbv`, to control whether we do+w/w on strict arguments (internally `Opt_WorkerWrapperUnlift`). The+flag is off by default. The choice is made in+GHC.Core.Opt.WorkWrape.Utils.wwForUnlifting++See also `Note [WW for calling convention]` in GHC.Core.Opt.WorkWrap.Utils -} {-@@ -1166,7 +1212,7 @@ where univ_tvs = dataConUnivTyVars dc ex_tvs = dataConExTyCoVars dc- subst = extendTCvInScopeList (zipTvSubst univ_tvs tc_args) ex_tvs+ subst = extendSubstInScopeList (zipTvSubst univ_tvs tc_args) ex_tvs arg_tys = map (GHC.Core.Type.substTy subst . scaledThing) (dataConRepArgTys dc) findTypeShape :: FamInstEnvs -> Type -> TypeShape
compiler/GHC/CoreToStg/Prep.hs view
@@ -2153,7 +2153,9 @@ -- Drop (now-useless) rules/unfoldings -- See Note [Drop unfoldings and rules] -- and Note [Preserve evaluatedness] in GHC.Core.Tidy- ; let unfolding' = trimUnfolding (realIdUnfolding bndr)+ -- And force it.. otherwise the old unfolding is just retained.+ -- See #22071+ ; let !unfolding' = trimUnfolding (realIdUnfolding bndr) -- Simplifier will set the Id's unfolding bndr'' = bndr' `setIdUnfolding` unfolding'
compiler/GHC/Driver/Backpack.hs view
@@ -328,7 +328,7 @@ mod_graph <- hsunitModuleGraph False (unLoc lunit) msg <- mkBackpackMsg- ok <- load' noHomeCache LoadAllTargets (Just msg) mod_graph+ ok <- load' noIfaceCache LoadAllTargets (Just msg) mod_graph when (failed ok) (liftIO $ exitWith (ExitFailure 1)) let hi_dir = expectJust (panic "hiDir Backpack") $ hiDir dflags@@ -417,7 +417,7 @@ withBkpExeSession deps_w_rns $ do mod_graph <- hsunitModuleGraph True (unLoc lunit) msg <- mkBackpackMsg- ok <- load' noHomeCache LoadAllTargets (Just msg) mod_graph+ ok <- load' noIfaceCache LoadAllTargets (Just msg) mod_graph when (failed ok) (liftIO $ exitWith (ExitFailure 1)) -- | Register a new virtual unit database containing a single unit
compiler/GHC/Driver/CodeOutput.hs view
@@ -173,7 +173,7 @@ "C backend output" FormatC doc- let ctx = initSDocContext dflags (PprCode CStyle)+ let ctx = initSDocContext dflags PprCode printSDocLn ctx LeftMode h doc Stream.consume cmm_stream id writeC @@ -253,11 +253,11 @@ ForeignStubs (CHeader h_code) (CStub c_code _ _) -> do let- stub_c_output_d = pprCode CStyle c_code+ stub_c_output_d = pprCode c_code stub_c_output_w = showSDoc dflags stub_c_output_d -- Header file protos for "foreign export"ed functions.- stub_h_output_d = pprCode CStyle h_code+ stub_h_output_d = pprCode h_code stub_h_output_w = showSDoc dflags stub_h_output_d createDirectoryIfMissing True (takeDirectory stub_h)@@ -327,8 +327,10 @@ -- | Generate code to initialise cost centres profilingInitCode :: Platform -> Module -> CollectedCCs -> CStub profilingInitCode platform this_mod (local_CCs, singleton_CCSs)- = initializerCStub platform fn_name decls body+ = {-# SCC profilingInitCode #-}+ initializerCStub platform fn_name decls body where+ pdocC = pprCLabel platform CStyle fn_name = mkInitializerStubLabel this_mod "prof_init" decls = vcat $ map emit_cc_decl local_CCs@@ -341,22 +343,22 @@ ] emit_cc_decl cc = text "extern CostCentre" <+> cc_lbl <> text "[];"- where cc_lbl = pdoc platform (mkCCLabel cc)+ where cc_lbl = pdocC (mkCCLabel cc) local_cc_list_label = text "local_cc_" <> ppr this_mod emit_cc_list ccs = text "static CostCentre *" <> local_cc_list_label <> text "[] ="- <+> braces (vcat $ [ pdoc platform (mkCCLabel cc) <> comma+ <+> braces (vcat $ [ pdocC (mkCCLabel cc) <> comma | cc <- ccs ] ++ [text "NULL"]) <> semi emit_ccs_decl ccs = text "extern CostCentreStack" <+> ccs_lbl <> text "[];"- where ccs_lbl = pdoc platform (mkCCSLabel ccs)+ where ccs_lbl = pdocC (mkCCSLabel ccs) singleton_cc_list_label = text "singleton_cc_" <> ppr this_mod emit_ccs_list ccs = text "static CostCentreStack *" <> singleton_cc_list_label <> text "[] ="- <+> braces (vcat $ [ pdoc platform (mkCCSLabel cc) <> comma+ <+> braces (vcat $ [ pdocC (mkCCSLabel cc) <> comma | cc <- ccs ] ++ [text "NULL"]) <> semi
compiler/GHC/Driver/Config/CmmToAsm.hs view
@@ -18,7 +18,7 @@ initNCGConfig dflags this_mod = NCGConfig { ncgPlatform = targetPlatform dflags , ncgThisModule = this_mod- , ncgAsmContext = initSDocContext dflags (PprCode AsmStyle)+ , ncgAsmContext = initSDocContext dflags PprCode , ncgProcAlignment = cmmProcAlignment dflags , ncgExternalDynamicRefs = gopt Opt_ExternalDynamicRefs dflags , ncgPIC = positionIndependent dflags
compiler/GHC/Driver/Config/CmmToLlvm.hs view
@@ -20,7 +20,7 @@ llvm_config <- readLlvmConfigCache config_cache pure $! LlvmCgConfig { llvmCgPlatform = targetPlatform dflags- , llvmCgContext = initSDocContext dflags (PprCode CStyle)+ , llvmCgContext = initSDocContext dflags PprCode , llvmCgFillUndefWithGarbage = gopt Opt_LlvmFillUndefWithGarbage dflags , llvmCgSplitSection = gopt Opt_SplitSections dflags , llvmCgBmiVersion = case platformArch (targetPlatform dflags) of
compiler/GHC/Driver/Main.hs view
@@ -171,7 +171,9 @@ import GHC.Core.FamInstEnv import GHC.Core.Rules import GHC.Core.Stats+import GHC.Core.LateCC (addLateCostCentresPgm) + import GHC.CoreToStg.Prep import GHC.CoreToStg ( coreToStg ) @@ -268,7 +270,6 @@ import Data.List.NonEmpty (NonEmpty ((:|))) - {- ********************************************************************** %* * Initialisation@@ -911,7 +912,7 @@ fixIO $ \details' -> do let act hpt = addToHpt hpt (ms_mod_name mod_summary) (HomeModInfo iface details' Nothing)- let hsc_env' = hscUpdateHPT act hsc_env+ let !hsc_env' = hscUpdateHPT act hsc_env -- NB: This result is actually not that useful -- in one-shot mode, since we're not going to do -- any further typechecking. It's much more useful@@ -1692,6 +1693,21 @@ -- but we don't generate any code for newtypes -------------------+ -- Insert late cost centres if enabled.+ -- If `-fprof-late-inline` is enabled we can skip this, as it will have added+ -- a superset of cost centres we would add here already.++ (late_cc_binds, late_local_ccs) <-+ if gopt Opt_ProfLateCcs dflags && not (gopt Opt_ProfLateInlineCcs dflags)+ then {-# SCC lateCC #-} do+ (binds,late_ccs) <- addLateCostCentresPgm dflags logger this_mod core_binds+ return ( binds, (S.toList late_ccs `mappend` local_ccs ))+ else+ return (core_binds, local_ccs)++++ ------------------- -- PREPARE FOR CODE GENERATION -- Do saturation and convert to A-normal form (prepd_binds) <- {-# SCC "CorePrep" #-} do@@ -1700,7 +1716,7 @@ (hsc_logger hsc_env) cp_cfg (initCorePrepPgmConfig (hsc_dflags hsc_env) (interactiveInScope $ hsc_IC hsc_env))- this_mod location core_binds data_tycons+ this_mod location late_cc_binds data_tycons ----------------- Convert to STG ------------------ (stg_binds, denv, (caf_ccs, caf_cc_stacks))@@ -1711,7 +1727,7 @@ (myCoreToStg logger dflags (hsc_IC hsc_env) False this_mod location prepd_binds) let cost_centre_info =- (local_ccs ++ caf_ccs, caf_cc_stacks)+ (late_local_ccs ++ caf_ccs, caf_cc_stacks) platform = targetPlatform dflags prof_init | sccProfilingEnabled dflags = profilingInitCode platform this_mod cost_centre_info
compiler/GHC/Driver/Make.hs view
@@ -27,7 +27,7 @@ -- ----------------------------------------------------------------------------- module GHC.Driver.Make ( depanal, depanalE, depanalPartial, checkHomeUnitsClosed,- load, loadWithCache, load', LoadHowMuch(..), HomeModInfoCache(..), noHomeCache, newHomeModInfoCache,+ load, loadWithCache, load', LoadHowMuch(..), ModIfaceCache(..), noIfaceCache, newIfaceCache, instantiationNodes, downsweep,@@ -55,7 +55,7 @@ import GHC.Platform import GHC.Tc.Utils.Backpack-import GHC.Tc.Utils.Monad ( initIfaceCheck )+import GHC.Tc.Utils.Monad ( initIfaceCheck, concatMapM ) import GHC.Runtime.Interpreter import qualified GHC.Linker.Loader as Linker@@ -121,7 +121,7 @@ import qualified Data.Map as Map import qualified Data.Set as Set -import Control.Concurrent ( newQSem, waitQSem, signalQSem, ThreadId, killThread, forkIOWithUnmask , forkIO )+import Control.Concurrent ( newQSem, waitQSem, signalQSem, ThreadId, killThread, forkIOWithUnmask ) import qualified GHC.Conc as CC import Control.Concurrent.MVar import Control.Monad@@ -149,7 +149,11 @@ import GHC.Runtime.Loader import GHC.Rename.Names import GHC.Utils.Constants+import GHC.Types.Unique.DFM (udfmRestrictKeysSet)+import qualified Data.IntSet as I+import GHC.Types.Unique + -- ----------------------------------------------------------------------------- -- Loading the program @@ -420,48 +424,41 @@ end of load, and supplied at the start of load, however, this was not sufficient because it didn't account for the possibility of exceptions such as SIGINT (#20780). -So now, in the current day, we have this HomeModInfoCache abstraction which-can incrementally be updated during the process of upsweep. This alllows us+So now, in the current day, we have this ModIfaceCache abstraction which+can incrementally be updated during the process of upsweep. This allows us to store interface files for boot modules in an exception-safe way. When the final version of an interface file is completed then it is placed into-the cache. The contents of the cache is retrieved, and the cache cleared, by hmi_clearCache.--If a module is in a loop then the final version is the retypechecked version of-the inteface file which is created after the loop has concluded. For modules not-in a loop, the final interface file is just the normal one we create at the end-of compiling the module.--One slightly tricky part is keeping the cache up-to-date when performing parallel-upsweep. In order to do this we spawn a thread for each module which blocks on-the result variable and once unblocked adds the interface to the cache. This also-has the effect of writing the maximal number of modules into the cache as modules are not-inserted in the linearised order. In addition-to this we are careful to block the program continuing whilst there are still threads-waiting to write to the cache, lest we end up in situations where load is called-again before all threads have finished writing and old information will be placed into-the cache.-+the cache. The contents of the cache is retrieved, and the cache cleared, by iface_clearCache. +Note that because we only store the ModIface and Linkable in the ModIfaceCache,+hydration and rehydration is totally irrelevant, and we just store the CachedIface as+soon as it is completed. -} -- Abstract interface to a cache of HomeModInfo -- See Note [Caching HomeModInfo]-data HomeModInfoCache = HomeModInfoCache { hmi_clearCache :: IO [HomeModInfo]- , hmi_addToCache :: HomeModInfo -> IO () }+data ModIfaceCache = ModIfaceCache { iface_clearCache :: IO [CachedIface]+ , iface_addToCache :: CachedIface -> IO () } -noHomeCache :: Maybe HomeModInfoCache-noHomeCache = Nothing+addHmiToCache :: ModIfaceCache -> HomeModInfo -> IO ()+addHmiToCache c (HomeModInfo i _ l) = iface_addToCache c (CachedIface i l) -newHomeModInfoCache :: IO HomeModInfoCache-newHomeModInfoCache = do+data CachedIface = CachedIface { cached_modiface :: !ModIface+ , cached_linkable :: !(Maybe Linkable) }++noIfaceCache :: Maybe ModIfaceCache+noIfaceCache = Nothing++newIfaceCache :: IO ModIfaceCache+newIfaceCache = do ioref <- newIORef [] return $- HomeModInfoCache- { hmi_clearCache = atomicModifyIORef' ioref (\c -> ([], c))- , hmi_addToCache = \hmi -> atomicModifyIORef' ioref (\c -> (hmi:c, ()))+ ModIfaceCache+ { iface_clearCache = atomicModifyIORef' ioref (\c -> ([], c))+ , iface_addToCache = \hmi -> atomicModifyIORef' ioref (\c -> (hmi:c, ())) } @@ -483,7 +480,7 @@ -- All other errors are reported using the 'defaultWarnErrLogger'. load :: GhcMonad f => LoadHowMuch -> f SuccessFlag-load how_much = loadWithCache noHomeCache how_much+load how_much = loadWithCache noIfaceCache how_much mkBatchMsg :: HscEnv -> Messager mkBatchMsg hsc_env =@@ -493,7 +490,7 @@ else batchMsg -loadWithCache :: GhcMonad m => Maybe HomeModInfoCache -> LoadHowMuch -> m SuccessFlag+loadWithCache :: GhcMonad m => Maybe ModIfaceCache -> LoadHowMuch -> m SuccessFlag loadWithCache cache how_much = do (errs, mod_graph) <- depanalE [] False -- #17459 msg <- mkBatchMsg <$> getSession@@ -538,20 +535,29 @@ then emptyMessages else warn - -- | A ModuleGraphNode which also has a hs-boot file, and the list of nodes on any -- path from module to its boot file. data ModuleGraphNodeWithBootFile- = ModuleGraphNodeWithBootFile ModuleGraphNode [ModuleGraphNode]+ = ModuleGraphNodeWithBootFile+ ModuleGraphNode+ -- ^ The module itself (not the hs-boot module)+ [NodeKey]+ -- ^ The modules in between the module and its hs-boot file,+ -- not including the hs-boot file itself. + instance Outputable ModuleGraphNodeWithBootFile where ppr (ModuleGraphNodeWithBootFile mgn deps) = text "ModeGraphNodeWithBootFile: " <+> ppr mgn $$ ppr deps -getNode :: ModuleGraphNodeWithBootFile -> ModuleGraphNode-getNode (ModuleGraphNodeWithBootFile mgn _) = mgn-data BuildPlan = SingleModule ModuleGraphNode -- A simple, single module all alone but *might* have an hs-boot file which isn't part of a cycle- | ResolvedCycle [Either ModuleGraphNode ModuleGraphNodeWithBootFile] -- A resolved cycle, linearised by hs-boot files- | UnresolvedCycle [ModuleGraphNode] -- An actual cycle, which wasn't resolved by hs-boot files+-- | A 'BuildPlan' is the result of attempting to linearise a single strongly-connected+-- component of the module graph.+data BuildPlan+ -- | A simple, single module all alone (which *might* have an hs-boot file, if it isn't part of a cycle)+ = SingleModule ModuleGraphNode+ -- | A resolved cycle, linearised by hs-boot files+ | ResolvedCycle [Either ModuleGraphNode ModuleGraphNodeWithBootFile]+ -- | An actual cycle, which wasn't resolved by hs-boot files+ | UnresolvedCycle [ModuleGraphNode] instance Outputable BuildPlan where ppr (SingleModule mgn) = text "SingleModule" <> parens (ppr mgn)@@ -614,7 +620,7 @@ select_boot_modules :: [ModuleGraphNode] -> [ModuleGraphNode] select_boot_modules = mapMaybe (fmap fst . get_boot_module) - get_boot_module :: (ModuleGraphNode -> Maybe (ModuleGraphNode, [ModuleGraphNode]))+ get_boot_module :: ModuleGraphNode -> Maybe (ModuleGraphNode, [ModuleGraphNode]) get_boot_module m = case m of ModuleNode _ ms | HsSrcFile <- ms_hsc_src ms -> lookupModuleEnv boot_modules (ms_mod ms); _ -> Nothing -- Any cycles should be resolved now@@ -625,13 +631,13 @@ -- Cyclic collapseSCC _ = Nothing - toNodeWithBoot :: (ModuleGraphNode -> Either ModuleGraphNode ModuleGraphNodeWithBootFile)+ toNodeWithBoot :: ModuleGraphNode -> Either ModuleGraphNode ModuleGraphNodeWithBootFile toNodeWithBoot mn = case get_boot_module mn of -- The node doesn't have a boot file Nothing -> Left mn -- The node does have a boot file- Just path -> Right (ModuleGraphNodeWithBootFile mn (snd path))+ Just path -> Right (ModuleGraphNodeWithBootFile mn (map mkNodeKey (snd path))) -- The toposort and accumulation of acyclic modules is solely to pick-up -- hs-boot files which are **not** part of cycles.@@ -652,7 +658,7 @@ -- | Generalized version of 'load' which also supports a custom -- 'Messager' (for reporting progress) and 'ModuleGraph' (generally -- produced by calling 'depanal'.-load' :: GhcMonad m => Maybe HomeModInfoCache -> LoadHowMuch -> Maybe Messager -> ModuleGraph -> m SuccessFlag+load' :: GhcMonad m => Maybe ModIfaceCache -> LoadHowMuch -> Maybe Messager -> ModuleGraph -> m SuccessFlag load' mhmi_cache how_much mHscMessage mod_graph = do modifySession $ \hsc_env -> hsc_env { hsc_mod_graph = mod_graph } guessOutputFile@@ -708,7 +714,7 @@ build_plan = createBuildPlan mod_graph maybe_top_mod - cache <- liftIO $ maybe (return []) hmi_clearCache mhmi_cache+ cache <- liftIO $ maybe (return []) iface_clearCache mhmi_cache let -- prune the HPT so everything is not retained when doing an -- upsweep.@@ -813,19 +819,22 @@ -- old HPT holds on to the entire type environment from the previous -- compilation. -- Note [GHC Heap Invariants]-pruneCache :: [HomeModInfo]+pruneCache :: [CachedIface] -> [ModSummary] -> [HomeModInfo] pruneCache hpt summ = strictMap prune hpt- where prune hmi = hmi'{ hm_details = emptyModDetails }+ where prune (CachedIface { cached_modiface = iface+ , cached_linkable = linkable+ }) = HomeModInfo iface emptyModDetails linkable' where- modl = moduleName (mi_module (hm_iface hmi))- hmi' | Just ms <- lookupUFM ms_map modl- , mi_src_hash (hm_iface hmi) /= ms_hs_hash ms- = hmi{ hm_linkable = Nothing }+ modl = moduleName (mi_module iface)+ linkable'+ | Just ms <- lookupUFM ms_map modl+ , mi_src_hash iface /= ms_hs_hash ms+ = Nothing | otherwise- = hmi+ = linkable ms_map = listToUFM [(ms_mod_name ms, ms) | ms <- summ] @@ -968,8 +977,20 @@ waitResult :: ResultVar a -> MaybeT IO a waitResult (ResultVar f var) = MaybeT (fmap f <$> readMVar var) +data BuildResult = BuildResult { _resultOrigin :: ResultOrigin+ , resultVar :: ResultVar (Maybe HomeModInfo, ModuleNameSet)+ } -data BuildLoopState = BuildLoopState { buildDep :: M.Map NodeKey (SDoc, ResultVar (Maybe HomeModInfo))+-- The origin of this result var, useful for debugging+data ResultOrigin = NoLoop | Loop ResultLoopOrigin deriving (Show)++data ResultLoopOrigin = Initialise | Rehydrated | Finalised deriving (Show)++mkBuildResult :: ResultOrigin -> ResultVar (Maybe HomeModInfo, ModuleNameSet) -> BuildResult+mkBuildResult = BuildResult+++data BuildLoopState = BuildLoopState { buildDep :: M.Map NodeKey BuildResult -- The current way to build a specific TNodeKey, without cycles this just points to -- the appropiate result of compiling a module but with -- cycles there can be additional indirection and can point to the result of typechecking a loop@@ -985,14 +1006,20 @@ modify (\m -> m { nNODE = n + 1 }) return n -setModulePipeline :: NodeKey -> SDoc -> ResultVar (Maybe HomeModInfo) -> BuildM ()-setModulePipeline mgn doc wrapped_pipeline = do- modify (\m -> m { buildDep = M.insert mgn (doc, wrapped_pipeline) (buildDep m) }) -getBuildMap :: BuildM (M.Map- NodeKey (SDoc, ResultVar (Maybe HomeModInfo)))+setModulePipeline :: NodeKey -> BuildResult -> BuildM ()+setModulePipeline mgn build_result = do+ modify (\m -> m { buildDep = M.insert mgn build_result (buildDep m) })++type BuildMap = M.Map NodeKey BuildResult++getBuildMap :: BuildM BuildMap getBuildMap = gets buildDep +getDependencies :: [NodeKey] -> BuildMap -> [BuildResult]+getDependencies direct_deps build_map =+ strictMap (expectJust "dep_map" . flip M.lookup build_map) direct_deps+ type BuildM a = StateT BuildLoopState IO a @@ -1022,7 +1049,7 @@ -- if the module participates in a loop. This step also labels each node with a number for the output. -- See Note [Upsweep] for a high-level description. interpretBuildPlan :: HomeUnitGraph- -> Maybe HomeModInfoCache+ -> Maybe ModIfaceCache -> M.Map ModNodeKeyWithUid HomeModInfo -> [BuildPlan] -> IO ( Maybe [ModuleGraphNode] -- Is there an unresolved cycle@@ -1031,37 +1058,14 @@ interpretBuildPlan hug mhmi_cache old_hpt plan = do hug_var <- newMVar hug ((mcycle, plans), build_map) <- runStateT (buildLoop plan) (BuildLoopState M.empty 1 hug_var)- wait <- collect_results (buildDep build_map)+ let wait = collect_results (buildDep build_map) return (mcycle, plans, wait) where- collect_results build_map = do- -- 1. On success, write the result to the cache, fork threads waiting for each result- -- so that the cache can be updated out of order, before we wait at the end for everything to- -- finish. We do this here rather than when we update the hug_var because we only ever- -- want to add things to the cache which are externally visible- -- (something which is hard to work out in the main loop).- waits <- mapM (\(_doc, res_var) -> collect_result res_var) (M.elems build_map)- -- 2. Block waiting for all to finish- return (sequence waits)-- -- See Note [Caching HomeModInfo]- collect_result res_var = case mhmi_cache of- -- Avoid forking a new thread when there's no cache- Nothing -> return (runMaybeT (waitResult res_var))- Just hmi_cache -> do- -- Barrier used to ensure that we write to the cache before execution- -- continues.- barrier <- newEmptyMVar- forkIO (do- r <- runMaybeT (waitResult res_var)- case r of- Just (Just hmi) -> do- hmi_addToCache hmi_cache hmi- _ -> do- return ()- putMVar barrier r)- return (takeMVar barrier)+ collect_results build_map =+ sequence (map (\br -> collect_result (fst <$> resultVar br)) (M.elems build_map))+ where+ collect_result res_var = runMaybeT (waitResult res_var) n_mods = sum (map countMods plan) @@ -1074,7 +1078,7 @@ case plan of -- If there was no cycle, then typecheckLoop is not necessary SingleModule m -> do- (one_plan, _) <- buildSingleModule Nothing m+ one_plan <- buildSingleModule Nothing NoLoop m (cycle, all_plans) <- buildLoop plans return (cycle, one_plan : all_plans) @@ -1089,75 +1093,129 @@ -- Can't continue past this point as the cycle is unresolved. UnresolvedCycle ns -> return (Just ns, []) - buildSingleModule :: Maybe [ModuleGraphNode] -- Modules we need to rehydrate before compiling this module+ buildSingleModule :: Maybe [NodeKey] -- Modules we need to rehydrate before compiling this module+ -> ResultOrigin -> ModuleGraphNode -- The node we are compiling- -> BuildM (MakeAction, ResultVar (Maybe HomeModInfo))- buildSingleModule rehydrate_nodes mod = do+ -> BuildM MakeAction+ buildSingleModule rehydrate_nodes origin mod = do mod_idx <- nodeId- home_mod_map <- getBuildMap+ !build_map <- getBuildMap hug_var <- gets hug_var- -- 1. Get the transitive dependencies of this module, by looking up in the dependency map+ -- 1. Get the direct dependencies of this module let direct_deps = nodeDependencies False mod- doc_build_deps = map (expectJust "dep_map" . flip M.lookup home_mod_map) direct_deps- build_deps = map snd doc_build_deps- -- 2. Set the default way to build this node, not in a loop here- let build_action = withCurrentUnit (moduleGraphNodeUnitId mod) $+ -- It's really important to force build_deps, or the whole buildMap is retained,+ -- which would retain all the result variables, preventing us from collecting them+ -- after they are no longer used.+ !build_deps = getDependencies direct_deps build_map+ let build_action =+ withCurrentUnit (moduleGraphNodeUnitId mod) $ do+ (hug, deps) <- wait_deps_hug hug_var build_deps case mod of- InstantiationNode uid iu ->- const Nothing <$> executeInstantiationNode mod_idx n_mods (wait_deps_hug hug_var build_deps) uid iu+ InstantiationNode uid iu -> do+ executeInstantiationNode mod_idx n_mods hug uid iu+ return (Nothing, deps) ModuleNode _build_deps ms -> do- let !old_hmi = M.lookup (msKey ms) old_hpt- rehydrate_mods = mapMaybe moduleGraphNodeModule <$> rehydrate_nodes- hmi <- executeCompileNode mod_idx n_mods old_hmi (wait_deps_hug hug_var build_deps) rehydrate_mods ms- -- This global MVar is incrementally modified in order to avoid having to- -- recreate the HPT before compiling each module which leads to a quadratic amount of work.- hsc_env <- asks hsc_env- hmi' <- liftIO $ modifyMVar hug_var (\hug -> do- let new_hpt = addHomeModInfoToHug hmi hug- new_hsc = setHUG new_hpt hsc_env- maybeRehydrateAfter hmi new_hsc rehydrate_mods- )- return (Just hmi')+ let !old_hmi = M.lookup (msKey ms) old_hpt+ rehydrate_mods = mapMaybe nodeKeyModName <$> rehydrate_nodes+ hmi <- executeCompileNode mod_idx n_mods old_hmi hug rehydrate_mods ms+ -- Write the HMI to an external cache (if one exists)+ -- See Note [Caching HomeModInfo]+ liftIO $ forM mhmi_cache $ \hmi_cache -> addHmiToCache hmi_cache hmi+ -- This global MVar is incrementally modified in order to avoid having to+ -- recreate the HPT before compiling each module which leads to a quadratic amount of work.+ liftIO $ modifyMVar_ hug_var (return . addHomeModInfoToHug hmi)+ return (Just hmi, addToModuleNameSet (moduleGraphNodeUnitId mod) (ms_mod_name ms) deps ) LinkNode _nks uid -> do- executeLinkNode (wait_deps_hug hug_var build_deps) (mod_idx, n_mods) uid direct_deps- return Nothing+ executeLinkNode hug (mod_idx, n_mods) uid direct_deps+ return (Nothing, deps) res_var <- liftIO newEmptyMVar let result_var = mkResultVar res_var- setModulePipeline (mkNodeKey mod) (text "N") result_var- return $ (MakeAction build_action res_var, result_var)+ setModulePipeline (mkNodeKey mod) (mkBuildResult origin result_var)+ return $ (MakeAction build_action res_var) - buildOneLoopyModule :: ModuleGraphNodeWithBootFile -> BuildM (MakeAction, (ResultVar (Maybe HomeModInfo)))- buildOneLoopyModule (ModuleGraphNodeWithBootFile mn deps) =- buildSingleModule (Just deps) mn+ buildOneLoopyModule :: ModuleGraphNodeWithBootFile -> BuildM [MakeAction]+ buildOneLoopyModule (ModuleGraphNodeWithBootFile mn deps) = do+ ma <- buildSingleModule (Just deps) (Loop Initialise) mn+ -- Rehydration (1) from Note [Hydrating Modules], "Loops with multiple boot files"+ rehydrate_action <- rehydrateAction Rehydrated ((GWIB (mkNodeKey mn) IsBoot) : (map (\d -> GWIB d NotBoot) deps))+ return $ [ma, rehydrate_action] - buildModuleLoop :: [Either ModuleGraphNode ModuleGraphNodeWithBootFile] -> BuildM [MakeAction]++ buildModuleLoop :: [Either ModuleGraphNode ModuleGraphNodeWithBootFile] -> BuildM [MakeAction] buildModuleLoop ms = do- (build_modules, wait_modules) <- mapAndUnzipM (either (buildSingleModule Nothing) buildOneLoopyModule) ms+ build_modules <- concatMapM (either (fmap (:[]) <$> buildSingleModule Nothing (Loop Initialise)) buildOneLoopyModule) ms+ let extract (Left mn) = GWIB (mkNodeKey mn) NotBoot+ extract (Right (ModuleGraphNodeWithBootFile mn _)) = GWIB (mkNodeKey mn) IsBoot+ let loop_mods = map extract ms+ -- Rehydration (2) from Note [Hydrating Modules], "Loops with multiple boot files"+ -- Fixes the space leak described in that note.+ rehydrate_action <- rehydrateAction Finalised loop_mods++ return $ build_modules ++ [rehydrate_action]++ -- An action which rehydrates the given keys+ rehydrateAction :: ResultLoopOrigin -> [GenWithIsBoot NodeKey] -> BuildM MakeAction+ rehydrateAction origin deps = do+ hug_var <- gets hug_var+ !build_map <- getBuildMap res_var <- liftIO newEmptyMVar- let loop_action = wait_deps wait_modules- let fanout i = Just . (!! i) <$> mkResultVar res_var+ let+ !build_deps = getDependencies (map gwib_mod deps) build_map+ let loop_action = do+ (hug, tdeps) <- wait_deps_hug hug_var build_deps+ hsc_env <- asks hsc_env+ let new_hsc = setHUG hug hsc_env+ mns :: [ModuleName]+ mns = mapMaybe (nodeKeyModName . gwib_mod) deps++ hmis' <- liftIO $ rehydrateAfter new_hsc mns++ checkRehydrationInvariant hmis' deps++ -- Add hydrated interfaces to global variable+ liftIO $ modifyMVar_ hug_var (\hug -> return $ foldr addHomeModInfoToHug hug hmis')+ return (hmis', tdeps)++ let fanout i = first (Just . (!! i)) <$> mkResultVar res_var -- From outside the module loop, anyone must wait for the loop to finish and then -- use the result of the rehydrated iface. This makes sure that things not in the -- module loop will see the updated interfaces for all the identifiers in the loop.- let update_module_pipeline (m, i) = setModulePipeline (NodeKey_Module m) (text "T") (fanout i)+ boot_key :: NodeKey -> NodeKey+ boot_key (NodeKey_Module m) = NodeKey_Module (m { mnkModuleName = (mnkModuleName m) { gwib_isBoot = IsBoot } } )+ boot_key k = pprPanic "boot_key" (ppr k) - let ms_i = zip (mapMaybe (fmap msKey . moduleGraphNodeModSum . either id getNode) ms) [0..]- mapM update_module_pipeline ms_i- return $ build_modules ++ [MakeAction loop_action res_var]+ update_module_pipeline (m, i) =+ case gwib_isBoot m of+ NotBoot -> setModulePipeline (gwib_mod m) (mkBuildResult (Loop origin) (fanout i))+ IsBoot -> do+ setModulePipeline (gwib_mod m) (mkBuildResult (Loop origin) (fanout i))+ -- SPECIAL: Anything outside the loop needs to see A rather than A.hs-boot+ setModulePipeline (boot_key (gwib_mod m)) (mkBuildResult (Loop origin) (fanout i)) + let deps_i = zip deps [0..]+ mapM update_module_pipeline deps_i + return $ MakeAction loop_action res_var++ -- Checks that the interfaces returned from hydration match-up with the names of the+ -- modules which were fed into the function.+ checkRehydrationInvariant hmis deps =+ let hmi_names = map (moduleName . mi_module . hm_iface) hmis+ start = mapMaybe (nodeKeyModName . gwib_mod) deps+ in massertPpr (hmi_names == start) $ (ppr hmi_names $$ ppr start)++ withCurrentUnit :: UnitId -> RunMakeM a -> RunMakeM a withCurrentUnit uid = do local (\env -> env { hsc_env = hscSetActiveUnitId uid (hsc_env env)}) - upsweep :: Int -- ^ The number of workers we wish to run in parallel -> HscEnv -- ^ The base HscEnv, which is augmented for each module- -> Maybe HomeModInfoCache -- ^ A cache to incrementally write final interface files to+ -> Maybe ModIfaceCache -- ^ A cache to incrementally write final interface files to -> Maybe Messager -> M.Map ModNodeKeyWithUid HomeModInfo -> [BuildPlan]@@ -2320,13 +2378,11 @@ executeInstantiationNode :: Int -> Int- -> RunMakeM HomeUnitGraph+ -> HomeUnitGraph -> UnitId -> InstantiatedUnit -> RunMakeM ()-executeInstantiationNode k n wait_deps uid iu = do- -- Wait for the dependencies of this node- deps <- wait_deps+executeInstantiationNode k n deps uid iu = do env <- ask -- Output of the logger is mediated by a central worker to -- avoid output interleaving@@ -2342,16 +2398,15 @@ executeCompileNode :: Int -> Int -> Maybe HomeModInfo- -> RunMakeM HomeUnitGraph+ -> HomeUnitGraph -> Maybe [ModuleName] -- List of modules we need to rehydrate before compiling -> ModSummary -> RunMakeM HomeModInfo-executeCompileNode k n !old_hmi wait_deps mrehydrate_mods mod = do+executeCompileNode k n !old_hmi hug mrehydrate_mods mod = do me@MakeEnv{..} <- ask- deps <- wait_deps -- Rehydrate any dependencies if this module had a boot file or is a signature file. lift $ MaybeT (withAbstractSem compile_sem $ withLoggerHsc k me $ \hsc_env -> do- hydrated_hsc_env <- liftIO $ maybeRehydrateBefore (setHUG deps hsc_env) mod fixed_mrehydrate_mods+ hydrated_hsc_env <- liftIO $ maybeRehydrateBefore (setHUG hug hsc_env) mod fixed_mrehydrate_mods let -- Use the cached DynFlags which includes OPTIONS_GHC pragmas lcl_dynflags = ms_hspp_opts mod let lcl_hsc_env =@@ -2380,11 +2435,11 @@ -> [HomeModInfo] -- ^ These are the modules we want to rehydrate. -> IO HscEnv rehydrate hsc_env hmis = do- debugTraceMsg logger 2 $- text "Re-hydrating loop: "+ debugTraceMsg logger 2 $ (+ text "Re-hydrating loop: " <+> (ppr (map (mi_module . hm_iface) hmis))) new_mods <- fixIO $ \new_mods -> do let new_hpt = addListToHpt old_hpt new_mods- let new_hsc_env = hscUpdateHPT (const new_hpt) hsc_env+ let new_hsc_env = hscUpdateHPT_lazy (const new_hpt) hsc_env mds <- initIfaceCheck (text "rehydrate") new_hsc_env $ mapM (typecheckIface . hm_iface) hmis let new_mods = [ (mn,hmi{ hm_details = details })@@ -2414,17 +2469,14 @@ let mod_name = homeModuleInstantiation (hsc_home_unit_maybe hsc_env) (ms_mod mod) in mkModuleEnv . (:[]) . (mod_name,) <$> newIORef emptyTypeEnv -maybeRehydrateAfter :: HomeModInfo- -> HscEnv- -> Maybe [ModuleName]- -> IO (HomeUnitGraph, HomeModInfo)-maybeRehydrateAfter hmi new_hsc Nothing = return (hsc_HUG new_hsc, hmi)-maybeRehydrateAfter hmi new_hsc (Just mns) = do+rehydrateAfter :: HscEnv+ -> [ModuleName]+ -> IO [HomeModInfo]+rehydrateAfter new_hsc mns = do let new_hpt = hsc_HPT new_hsc hmis = map (expectJust "mrAfter" . lookupHpt new_hpt) mns- new_mod_name = moduleName (mi_module (hm_iface hmi))- hsc_env <- rehydrate (new_hsc { hsc_type_env_vars = emptyKnotVars }) (hmi : hmis)- return (hsc_HUG hsc_env, expectJust "rehydrate" $ lookupHpt (hsc_HPT hsc_env) new_mod_name)+ hsc_env <- rehydrate (new_hsc { hsc_type_env_vars = emptyKnotVars }) hmis+ return $ map (\mn -> expectJust "rehydrate" $ lookupHpt (hsc_HPT hsc_env) mn) mns {- Note [Hydrating Modules]@@ -2525,6 +2577,49 @@ There might be many unrelated modules (in the home package) that don't need to be rehydrated. +== Loops with multiple boot files++It is possible for a module graph to have a loop (SCC, when ignoring boot files)+which requires multiple boot files to break. In this case, we must perform+several hydration steps:+ 1. The hydration steps described above, which are necessary for correctness.+ 2. An extra hydration step at the end of compiling the entire SCC, in order to+ remove space leaks, as we explain below.++Consider the following example:++ ┌─────┐ ┌─────┐+ │ A │ │ B │+ └──┬──┘ └──┬──┘+ │ │+ ┌───▼───────────▼───┐+ │ C │+ └───┬───────────┬───┘+ │ │+ ┌────▼───┐ ┌───▼────┐+ │ A-boot │ │ B-boot │+ └────────┘ └────────┘++A, B and C live together in a SCC. Suppose that we compile the modules in the+order:++ A-boot, B-boot, C, A, B.++When we come to compile A, we will perform the necessary hydration steps,+because A has a boot file. This means that C will be hydrated relative to A,+and the ModDetails for A will reference C/A. Then, when B is compiled,+C will be rehydrated again, and so B will reference C/A,B. At this point,+its interface will be hydrated relative to both A and B.+This causes a space leak: there are now two different copies of C's ModDetails,+kept alive by modules A and B. This is especially problematic if C is large.++The way to avoid this space leak is to rehydrate an entire SCC together at the+end of compilation, so that all the ModDetails point to interfaces for .hs files.+In this example, when we hydrate A, B and C together, then both A and B will refer to+C/A,B.++See #21900 for some more discussion.+ == Modules "above" the loop This dark corner is the subject of #14092.@@ -2552,11 +2647,10 @@ -} -executeLinkNode :: RunMakeM HomeUnitGraph -> (Int, Int) -> UnitId -> [NodeKey] -> RunMakeM ()-executeLinkNode wait_deps kn uid deps = do+executeLinkNode :: HomeUnitGraph -> (Int, Int) -> UnitId -> [NodeKey] -> RunMakeM ()+executeLinkNode hug kn uid deps = do withCurrentUnit uid $ do MakeEnv{..} <- ask- hug <- wait_deps let dflags = hsc_dflags hsc_env let hsc_env' = setHUG hug hsc_env msg' = (\messager -> \recomp -> messager hsc_env kn recomp (LinkNode deps uid)) <$> env_messager@@ -2575,29 +2669,77 @@ Failed -> fail "Link Failed" Succeeded -> return () +{-+Note [ModuleNameSet, efficiency and space leaks]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +During upsweep, the results of compiling modules are placed into a MVar. When we need+to compute the right compilation environment for a module, we consult this MVar and+set the HomeUnitGraph accordingly. This is done to avoid having to precisely track+module dependencies and recreating the HUG from scratch each time, which is very expensive.++In serial mode (-j1), this all works out fine: a module can only be compiled+after its dependencies have finished compiling, and compilation can't be+interleaved with the compilation of other module loops. This ensures that+the HUG only ever contains finalised interfaces.++In parallel mode, we have to be more careful: the HUG variable can contain non-finalised+interfaces, which have been started by another thread. In order to avoid a space leak+in which a finalised interface is compiled against a HPT which contains a non-finalised+interface, we have to restrict the HUG to only contain the visible modules.++The collection of visible modules explains which transitive modules are visible+from a certain point. It is recorded in the ModuleNameSet.+Before a module is compiled, we use this set to restrict the HUG to the visible+modules only, avoiding this tricky space leak.++Efficiency of the ModuleNameSet is of utmost importance, because a union occurs for+each edge in the module graph. To achieve this, the set is represented directly as an IntSet,+which provides suitable performance – even using a UniqSet (which is backed by an IntMap) is+too slow. The crucial test of performance here is the time taken to a do a no-op build in --make mode.++See test "jspace" for an example which used to trigger this problem.++-}++-- See Note [ModuleNameSet, efficiency and space leaks]+type ModuleNameSet = M.Map UnitId I.IntSet++addToModuleNameSet :: UnitId -> ModuleName -> ModuleNameSet -> ModuleNameSet+addToModuleNameSet uid mn s =+ let k = (getKey $ getUnique $ mn)+ in M.insertWith (I.union) uid (I.singleton k) s+ -- | Wait for some dependencies to finish and then read from the given MVar.-wait_deps_hug :: MVar b -> [ResultVar (Maybe HomeModInfo)] -> ReaderT MakeEnv (MaybeT IO) b+wait_deps_hug :: MVar HomeUnitGraph -> [BuildResult] -> ReaderT MakeEnv (MaybeT IO) (HomeUnitGraph, ModuleNameSet) wait_deps_hug hug_var deps = do- _ <- wait_deps deps- liftIO $ readMVar hug_var-+ (_, module_deps) <- wait_deps deps+ hug <- liftIO $ readMVar hug_var+ let pruneHomeUnitEnv uid hme =+ let -- Restrict to things which are in the transitive closure to avoid retaining+ -- reference to loop modules which have already been compiled by other threads.+ -- See Note [ModuleNameSet, efficiency and space leaks]+ !new = udfmRestrictKeysSet (homeUnitEnv_hpt hme) (fromMaybe I.empty $ M.lookup uid module_deps)+ in hme { homeUnitEnv_hpt = new }+ return (unitEnv_mapWithKey pruneHomeUnitEnv hug, module_deps) -- | Wait for dependencies to finish, and then return their results.-wait_deps :: [ResultVar (Maybe HomeModInfo)] -> RunMakeM [HomeModInfo]-wait_deps [] = return []+wait_deps :: [BuildResult] -> RunMakeM ([HomeModInfo], ModuleNameSet)+wait_deps [] = return ([], M.empty) wait_deps (x:xs) = do- res <- lift $ waitResult x+ (res, deps) <- lift $ waitResult (resultVar x)+ (hmis, all_deps) <- wait_deps xs+ let !new_deps = deps `unionModuleNameSet` all_deps case res of- Nothing -> wait_deps xs- Just hmi -> (hmi:) <$> wait_deps xs+ Nothing -> return (hmis, new_deps)+ Just hmi -> return (hmi:hmis, new_deps)+ where+ unionModuleNameSet = M.unionWith I.union -- Executing the pipelines --- | Start a thread which reads from the LogQueueQueue - label_self :: String -> IO () label_self thread_name = do self_tid <- CC.myThreadId@@ -2756,4 +2898,9 @@ Where? No one place in the compiler. These leaks can be introduced by not suitable forcing functions which take a TcLclEnv as an argument. +5. At the end of a successful upsweep, the number of live ModDetails equals the+ number of non-boot Modules.+ Why? Each module has a HomeModInfo which contains a ModDetails from that module.+ Where? See Note [ModuleNameSet, efficiency and space leaks], a variety of places+ in the driver are responsible. -}
compiler/GHC/Driver/Pipeline.hs view
@@ -171,7 +171,7 @@ -> Just (DriverPsHeaderMessage (PsHeaderMessage msg)) _ -> Nothing - pipe_env = mkPipeEnv StopPreprocess input_fn (Temporary TFL_GhcSession)+ pipe_env = mkPipeEnv StopPreprocess input_fn mb_phase (Temporary TFL_GhcSession) mkInputFn = case mb_input_buf of Just input_buf -> do@@ -237,7 +237,7 @@ [ml_obj_file $ ms_location summary] plugin_hsc_env <- initializePlugins hsc_env- let pipe_env = mkPipeEnv NoStop input_fn pipelineOutput+ let pipe_env = mkPipeEnv NoStop input_fn Nothing pipelineOutput status <- hscRecompStatus mHscMessage plugin_hsc_env upd_summary mb_old_iface mb_old_linkable (mod_index, nmods) let pipeline = hscPipeline pipe_env (setDumpPrefix pipe_env plugin_hsc_env, upd_summary, status)@@ -512,7 +512,7 @@ NoStop -> doLink hsc_env o_files compileFile :: HscEnv -> StopPhase -> (FilePath, Maybe Phase) -> IO (Maybe FilePath)-compileFile hsc_env stop_phase (src, _mb_phase) = do+compileFile hsc_env stop_phase (src, mb_phase) = do exists <- doesFileExist src when (not exists) $ throwGhcExceptionIO (CmdLineError ("does not exist: " ++ src))@@ -533,8 +533,8 @@ | isJust mb_o_file = SpecificFile -- -o foo applies to the file we are compiling now | otherwise = Persistent- pipe_env = mkPipeEnv stop_phase src output- pipeline = pipelineStart pipe_env (setDumpPrefix pipe_env hsc_env) src+ pipe_env = mkPipeEnv stop_phase src mb_phase output+ pipeline = pipelineStart pipe_env (setDumpPrefix pipe_env hsc_env) src mb_phase runPipeline (hsc_hooks hsc_env) pipeline @@ -583,7 +583,7 @@ #if __GLASGOW_HASKELL__ < 811 RawObject -> panic "compileForeign: should be unreachable" #endif- pipe_env = mkPipeEnv NoStop stub_c (Temporary TFL_GhcSession)+ pipe_env = mkPipeEnv NoStop stub_c Nothing (Temporary TFL_GhcSession) res <- runPipeline (hsc_hooks hsc_env) (pipeline pipe_env hsc_env Nothing stub_c) case res of -- This should never happen as viaCPipeline should only return `Nothing` when the stop phase is `StopC`.@@ -606,8 +606,8 @@ empty_stub <- newTempName logger tmpfs (tmpDir dflags) TFL_CurrentModule "c" let home_unit = hsc_home_unit hsc_env src = text "int" <+> ppr (mkHomeModule home_unit mod_name) <+> text "= 0;"- writeFile empty_stub (showSDoc dflags (pprCode CStyle src))- let pipe_env = (mkPipeEnv NoStop empty_stub Persistent) { src_basename = basename}+ writeFile empty_stub (showSDoc dflags (pprCode src))+ let pipe_env = (mkPipeEnv NoStop empty_stub Nothing Persistent) { src_basename = basename} pipeline = viaCPipeline HCc pipe_env hsc_env (Just location) empty_stub _ <- runPipeline (hsc_hooks hsc_env) pipeline return ()@@ -617,15 +617,17 @@ mkPipeEnv :: StopPhase -- End phase -> FilePath -- input fn+ -> Maybe Phase -> PipelineOutput -- Output -> PipeEnv-mkPipeEnv stop_phase input_fn output =+mkPipeEnv stop_phase input_fn start_phase output = let (basename, suffix) = splitExtension input_fn suffix' = drop 1 suffix -- strip off the . env = PipeEnv{ stop_phase, src_filename = input_fn, src_basename = basename, src_suffix = suffix',+ start_phase = fromMaybe (startPhase suffix') start_phase, output_spec = output } in env @@ -695,8 +697,7 @@ where platform = targetPlatform (hsc_dflags hsc_env) runAfter :: P p => Phase -> a -> p a -> p a- runAfter = phaseIfAfter platform start_phase- start_phase = startPhase (src_suffix pipe_env)+ runAfter = phaseIfAfter platform (start_phase pipe_env) runAfterFlag :: P p => HscEnv -> Phase@@ -829,9 +830,9 @@ -- Pipeline from a given suffix-pipelineStart :: P m => PipeEnv -> HscEnv -> FilePath -> m (Maybe FilePath)-pipelineStart pipe_env hsc_env input_fn =- fromSuffix (src_suffix pipe_env)+pipelineStart :: P m => PipeEnv -> HscEnv -> FilePath -> Maybe Phase -> m (Maybe FilePath)+pipelineStart pipe_env hsc_env input_fn mb_phase =+ fromPhase (fromMaybe (startPhase $ src_suffix pipe_env) mb_phase) where stop_after = stop_phase pipe_env frontend :: P m => HscSource -> m (Maybe FilePath)@@ -863,33 +864,24 @@ objFromLinkable _ = Nothing - fromSuffix :: P m => String -> m (Maybe FilePath)- fromSuffix "lhs" = frontend HsSrcFile- fromSuffix "lhs-boot" = frontend HsBootFile- fromSuffix "lhsig" = frontend HsigFile- fromSuffix "hs" = frontend HsSrcFile- fromSuffix "hs-boot" = frontend HsBootFile- fromSuffix "hsig" = frontend HsigFile- fromSuffix "hscpp" = frontend HsSrcFile- fromSuffix "hspp" = frontend HsSrcFile- fromSuffix "hc" = c HCc- fromSuffix "c" = c Cc- fromSuffix "cpp" = c Ccxx- fromSuffix "C" = c Cc- fromSuffix "m" = c Cobjc- fromSuffix "M" = c Cobjcxx- fromSuffix "mm" = c Cobjcxx- fromSuffix "cc" = c Ccxx- fromSuffix "cxx" = c Ccxx- fromSuffix "s" = as False- fromSuffix "S" = as True- fromSuffix "ll" = llvmPipeline pipe_env hsc_env Nothing input_fn- fromSuffix "bc" = llvmLlcPipeline pipe_env hsc_env Nothing input_fn- fromSuffix "lm_s" = llvmManglePipeline pipe_env hsc_env Nothing input_fn- fromSuffix "o" = return (Just input_fn)- fromSuffix "cmm" = Just <$> cmmCppPipeline pipe_env hsc_env input_fn- fromSuffix "cmmcpp" = Just <$> cmmPipeline pipe_env hsc_env input_fn- fromSuffix _ = return (Just input_fn)+ fromPhase :: P m => Phase -> m (Maybe FilePath)+ fromPhase (Unlit p) = frontend p+ fromPhase (Cpp p) = frontend p+ fromPhase (HsPp p) = frontend p+ fromPhase (Hsc p) = frontend p+ fromPhase HCc = c HCc+ fromPhase Cc = c Cc+ fromPhase Ccxx = c Ccxx+ fromPhase Cobjc = c Cobjc+ fromPhase Cobjcxx = c Cobjcxx+ fromPhase (As p) = as p+ fromPhase LlvmOpt = llvmPipeline pipe_env hsc_env Nothing input_fn+ fromPhase LlvmLlc = llvmLlcPipeline pipe_env hsc_env Nothing input_fn+ fromPhase LlvmMangle = llvmManglePipeline pipe_env hsc_env Nothing input_fn+ fromPhase StopLn = return (Just input_fn)+ fromPhase CmmCpp = Just <$> cmmCppPipeline pipe_env hsc_env input_fn+ fromPhase Cmm = Just <$> cmmPipeline pipe_env hsc_env input_fn+ fromPhase MergeForeign = panic "fromPhase: MergeForeign" {- Note [The Pipeline Monad]
compiler/GHC/Driver/Pipeline/Execute.hs view
@@ -1180,20 +1180,13 @@ -- | See Note [Object merging]. joinObjectFiles :: HscEnv -> [FilePath] -> FilePath -> IO () joinObjectFiles hsc_env o_files output_fn- | can_merge_objs = do+ | can_merge_objs && not dashLSupported = do let toolSettings' = toolSettings dflags ldIsGnuLd = toolSettings_ldIsGnuLd toolSettings' ld_r args = GHC.SysTools.runMergeObjects (hsc_logger hsc_env) (hsc_tmpfs hsc_env) (hsc_dflags hsc_env) (- map GHC.SysTools.Option ld_build_id- ++ [ GHC.SysTools.Option "-o",+ [ GHC.SysTools.Option "-o", GHC.SysTools.FileOption "" output_fn ] ++ args)-- -- suppress the generation of the .note.gnu.build-id section,- -- which we don't need and sometimes causes ld to emit a- -- warning:- ld_build_id | toolSettings_ldSupportsBuildId toolSettings' = ["--build-id=none"]- | otherwise = [] if ldIsGnuLd then do
compiler/GHC/HsToCore/Expr.hs view
@@ -795,7 +795,7 @@ = do { builder_id <- dsLookupGlobalId builder_name ; return (if add_void then mkCoreApp (text "dsConLike" <+> ppr ps)- (Var builder_id) (Var voidPrimId)+ (Var builder_id) unboxedUnitExpr else Var builder_id) } | otherwise = pprPanic "dsConLike" (ppr ps)
compiler/GHC/HsToCore/Foreign/C.hs view
@@ -333,7 +333,7 @@ toCName :: Id -> String-toCName i = renderWithContext defaultSDocContext (pprCode CStyle (ppr (idName i)))+toCName i = renderWithContext defaultSDocContext (pprCode (ppr (idName i))) toCType :: Type -> (Maybe Header, SDoc) toCType = f False
compiler/GHC/HsToCore/Pmc/Solver.hs view
@@ -1,4 +1,3 @@- {-# LANGUAGE LambdaCase #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE ViewPatterns #-}@@ -59,9 +58,10 @@ import GHC.Core import GHC.Core.FVs (exprFreeVars) import GHC.Core.Map.Expr+import GHC.Core.Predicate (typeDeterminesValue) import GHC.Core.SimpleOpt (simpleOptExpr, exprIsConApp_maybe) import GHC.Core.Utils (exprType)-import GHC.Core.Make (mkListExpr, mkCharExpr)+import GHC.Core.Make (mkListExpr, mkCharExpr, mkRuntimeErrorApp, rUNTIME_ERROR_ID) import GHC.Types.Unique.Supply import GHC.Data.FastString import GHC.Types.SrcLoc@@ -75,7 +75,7 @@ import GHC.Builtin.Types import GHC.Builtin.Types.Prim (tYPETyCon) import GHC.Core.TyCo.Rep-import GHC.Core.TyCo.Subst (elemTCvSubst)+import GHC.Core.TyCo.Subst (elemSubst) import GHC.Core.Type import GHC.Tc.Solver (tcNormalise, tcCheckGivens, tcCheckWanteds) import GHC.Core.Unify (tcMatchTy)@@ -918,7 +918,7 @@ ex_tys = map exprToType ex_ty_args vis_args = reverse $ take arty $ reverse val_args uniq_supply <- lift $ lift $ getUniqueSupplyM- let (_, ex_tvs) = cloneTyVarBndrs (mkEmptyTCvSubst in_scope) dc_ex_tvs uniq_supply+ let (_, ex_tvs) = cloneTyVarBndrs (mkEmptySubst in_scope) dc_ex_tvs uniq_supply ty_cts = equateTys (map mkTyVarTy ex_tvs) ex_tys -- 1. @x ≁ ⊥@ if 'K' is not a Newtype constructor (#18341) when (not (isNewDataCon dc)) $@@ -942,23 +942,122 @@ pm_alt_con_app :: Id -> PmAltCon -> [TyVar] -> [Id] -> StateT Nabla (MaybeT DsM) () pm_alt_con_app x con tvs args = modifyT $ \nabla -> addConCt nabla x con tvs args +-- | Like 'modify', but with an effectful modifier action+modifyT :: Monad m => (s -> m s) -> StateT s m ()+modifyT f = StateT $ fmap ((,) ()) . f+ -- | Finds a representant of the semantic equality class of the given @e@. -- Which is the @x@ of a @let x = e'@ constraint (with @e@ semantically -- equivalent to @e'@) we encountered earlier, or a fresh identifier if -- there weren't any such constraints. representCoreExpr :: Nabla -> CoreExpr -> DsM (Id, Nabla) representCoreExpr nabla@MkNabla{ nabla_tm_st = ts@TmSt{ ts_reps = reps } } e- | Just rep <- lookupCoreMap reps e = pure (rep, nabla)+ | Just rep <- lookupCoreMap reps key = pure (rep, nabla) | otherwise = do rep <- mkPmId (exprType e)- let reps' = extendCoreMap reps e rep+ let reps' = extendCoreMap reps key rep let nabla' = nabla{ nabla_tm_st = ts{ ts_reps = reps' } } pure (rep, nabla')+ where+ key = makeDictsCoherent e+ -- Use a key in which dictionaries for the same type become equal.+ -- See Note [Unique dictionaries in the TmOracle CoreMap] --- | Like 'modify', but with an effectful modifier action-modifyT :: Monad m => (s -> m s) -> StateT s m ()-modifyT f = StateT $ fmap ((,) ()) . f+-- | Change out 'Id's which are uniquely determined by their type to a+-- common value, so that different names for dictionaries of the same type+-- are considered equal when building a 'CoreMap'.+--+-- See Note [Unique dictionaries in the TmOracle CoreMap]+makeDictsCoherent :: CoreExpr -> CoreExpr+makeDictsCoherent var@(Var v)+ | let ty = idType v+ , typeDeterminesValue ty+ = mkRuntimeErrorApp rUNTIME_ERROR_ID ty "dictionary"+ | otherwise+ = var+makeDictsCoherent lit@(Lit {})+ = lit+makeDictsCoherent (App f a)+ = App (makeDictsCoherent f) (makeDictsCoherent a)+makeDictsCoherent (Lam f body)+ = Lam f (makeDictsCoherent body)+makeDictsCoherent (Let bndr body)+ = Let+ (go_bndr bndr)+ (makeDictsCoherent body)+ where+ go_bndr (NonRec bndr expr) = NonRec bndr (makeDictsCoherent expr)+ go_bndr (Rec bndrs) = Rec (map ( \(b, expr) -> (b, makeDictsCoherent expr) ) bndrs)+makeDictsCoherent (Case scrut bndr ty alts)+ = Case scrut bndr ty+ [ Alt con bndr expr'+ | Alt con bndr expr <- alts+ , let expr' = makeDictsCoherent expr ]+makeDictsCoherent (Cast expr co)+ = Cast (makeDictsCoherent expr) co+makeDictsCoherent (Tick tick expr)+ = Tick tick (makeDictsCoherent expr)+makeDictsCoherent ty@(Type {})+ = ty+makeDictsCoherent co@(Coercion {})+ = co +{- Note [Unique dictionaries in the TmOracle CoreMap]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Any two dictionaries for a coherent typeclass should be considered equal+in the TmOracle CoreMap, as this allows us to report better pattern-match+warnings.++Consider for example T21662:++ view_fn :: forall (n :: Nat). KnownNat n => Int -> Bool++ foo :: Int -> Int+ foo (view_fn @12 -> True ) = 0+ foo (view_fn @12 -> False) = 1++In this example, the pattern match is exhaustive because we have covered+the range of the view pattern function. However, we may fail to recognise+the fact that the two cases use the same view function if the KnownNat+dictionaries aren't syntactically equal:++ eqn 1: [let ds_d1p0 = view_fn @12 $dKnownNat_a1ny ds_d1oR, True <- ds_d1p0]+ eqn 2: [let ds_d1p6 = view_fn @12 $dKnownNat_a1nC ds_d1oR, False <- ds_d1p6]++Note that the uniques of the KnownNat 12 dictionary differ. If we fail to utilise+the coherence of the KnownNat constraint, then we have to pessimistically assume+that we have two function calls with different arguments:++ foo (fn arg1 -> True ) = ...+ foo (fn arg2 -> False) = ...++In this case we can't determine whether the pattern matches are complete, so we+emit a pattern match warning.++Solution: replace all 'Id's whose type uniquely determines its value with+a common value, e.g. in the above example we would replace both+$dKnownNat_a1ny and $dKnownNat_a1nC with error @(KnownNat 12).++Why did we choose this solution? Here are some alternatives that were considered:++ 1. Perform CSE first. This would common up the dictionaries before we compare+ using the CoreMap.+ However, this is architecturally difficult as it would require threading+ a CSEnv through to desugarPat.+ 2. Directly modify CoreMap so that any two dictionaries of the same type are+ considered equal.+ The problem is that this affects all users of CoreMap. For example, CSE+ would now assume that any two dictionaries of the same type are equal,+ but this isn't necessarily true in the presence of magicDict, which+ violates coherence by design. It seems more prudent to limit the changes+ to the pattern-match checker only, to avoid undesirable consequences.++In the end, replacing dictionaries with an error value in the pattern-match+checker was the most self-contained, although we might want to revisit once+we implement a more robust approach to computing equality in the pattern-match+checker (see #19272).+-}+ {- Note [The Pos/Neg invariant] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Invariant applying to each VarInfo: Whenever we have @C @tvs args@ in 'vi_pos',@@ -1477,7 +1576,7 @@ -- Make sure that @ty@ is normalised before. -- -- See Note [Matching against a ConLike result type].-matchConLikeResTy :: FamInstEnvs -> TyState -> Type -> ConLike -> DsM (Maybe TCvSubst)+matchConLikeResTy :: FamInstEnvs -> TyState -> Type -> ConLike -> DsM (Maybe Subst) matchConLikeResTy env _ ty (RealDataCon dc) = pure $ do (rep_tc, tc_args, _co) <- splitReprTyConApp_maybe env ty if rep_tc == dataConTyCon dc@@ -1486,7 +1585,7 @@ matchConLikeResTy _ (TySt _ inert) ty (PatSynCon ps) = {-# SCC "matchConLikeResTy" #-} runMaybeT $ do let (univ_tvs,req_theta,_,_,_,con_res_ty) = patSynSig ps subst <- MaybeT $ pure $ tcMatchTy con_res_ty ty- guard $ all (`elemTCvSubst` subst) univ_tvs -- See the Note about T11336b+ guard $ all (`elemSubst` subst) univ_tvs -- See the Note about T11336b if null req_theta then pure subst else do
compiler/GHC/HsToCore/Quote.hs view
@@ -89,6 +89,8 @@ import qualified GHC.LanguageExtensions as LangExt +import Language.Haskell.Syntax.Basic (FieldLabelString(..))+ import Data.ByteString ( unpack ) import Control.Monad import Data.List (sort, sortBy)@@ -1635,10 +1637,10 @@ occ <- occNameLit uv sname <- repNameS occ repUnboundVar sname-repE (HsGetField _ e (L _ (DotFieldOcc _ (L _ f)))) = do+repE (HsGetField _ e (L _ (DotFieldOcc _ (L _ (FieldLabelString f))))) = do e1 <- repLE e repGetField e1 f-repE (HsProjection _ xs) = repProjection (fmap (unLoc . dfoLabel . unLoc) xs)+repE (HsProjection _ xs) = repProjection (fmap (field_label . unLoc . dfoLabel . unLoc) xs) repE (XExpr (HsExpanded orig_expr ds_expr)) = do { rebindable_on <- lift $ xoptM LangExt.RebindableSyntax ; if rebindable_on -- See Note [Quotation and rebindable syntax]
compiler/GHC/HsToCore/Utils.hs view
@@ -917,7 +917,7 @@ ; fail_fun_arg <- newSysLocalDs Many unboxedUnitTy ; let real_arg = setOneShotLambda fail_fun_arg ; return (NonRec fail_fun_var (Lam real_arg expr),- App (Var fail_fun_var) (Var voidPrimId)) }+ App (Var fail_fun_var) unboxedUnitExpr) } where ty = exprType expr
compiler/GHC/Iface/Ext/Utils.hs view
@@ -61,7 +61,7 @@ resolveVisibility :: Type -> [Type] -> [(Bool,Type)] resolveVisibility kind ty_args- = go (mkEmptyTCvSubst in_scope) kind ty_args+ = go (mkEmptySubst in_scope) kind ty_args where in_scope = mkInScopeSet (tyCoVarsOfTypes ty_args)
compiler/GHC/Iface/Tidy.hs view
@@ -24,16 +24,17 @@ import GHC.Core import GHC.Core.Unfold-import GHC.Core.Unfold.Make+-- import GHC.Core.Unfold.Make import GHC.Core.FVs import GHC.Core.Tidy-import GHC.Core.Seq (seqBinds)+import GHC.Core.Seq ( seqBinds ) import GHC.Core.Opt.Arity ( exprArity, typeArity, exprBotStrictness_maybe ) import GHC.Core.InstEnv import GHC.Core.Type ( Type, tidyTopType ) import GHC.Core.DataCon import GHC.Core.TyCon import GHC.Core.Class+import GHC.Core.Opt.OccurAnal ( occurAnalyseExpr ) import GHC.Iface.Tidy.StaticPtrTable import GHC.Iface.Env@@ -53,7 +54,6 @@ import GHC.Types.Id.Make ( mkDictSelRhs ) import GHC.Types.Id.Info import GHC.Types.Demand ( isDeadEndAppSig, isNopSig, nopSig, isDeadEndSig )-import GHC.Types.Cpr ( mkCprSig, botCpr ) import GHC.Types.Basic import GHC.Types.Name hiding (varName) import GHC.Types.Name.Set@@ -347,7 +347,7 @@ data TidyOpts = TidyOpts { opt_name_cache :: !NameCache- , opt_collect_ccs :: !Bool+ , opt_collect_ccs :: !Bool -- ^ Always true if we compile with -prof , opt_unfolding_opts :: !UnfoldingOpts , opt_expose_unfoldings :: !UnfoldingExposure -- ^ Which unfoldings to expose@@ -384,8 +384,7 @@ (unfold_env, tidy_occ_env) <- chooseExternalIds opts mod binds implicit_binds imp_rules let (trimmed_binds, trimmed_rules) = findExternalRules opts binds imp_rules unfold_env - let uf_opts = opt_unfolding_opts opts- (tidy_env, tidy_binds) <- tidyTopBinds uf_opts unfold_env boot_exports tidy_occ_env trimmed_binds+ (tidy_env, tidy_binds) <- tidyTopBinds unfold_env boot_exports tidy_occ_env trimmed_binds -- See Note [Grand plan for static forms] in GHC.Iface.Tidy.StaticPtrTable. (spt_entries, mcstub, tidy_binds') <- case opt_static_ptr_opts opts of@@ -468,7 +467,7 @@ -- unfoldings. collectCostCentres :: Module -> CoreProgram -> [CoreRule] -> S.Set CostCentre collectCostCentres mod_name binds rules- = foldl' go_bind (go_rules S.empty) binds+ = {-# SCC collectCostCentres #-} foldl' go_bind (go_rules S.empty) binds where go cs e = case e of Var{} -> cs@@ -965,6 +964,13 @@ called in the final code), we keep the rule too. This stuff is the only reason for the ru_auto field in a Rule.++NB: In #18532 we looked at keeping auto-rules and it turned out to just make+compiler performance worse while increasing code sizes at the same time. The impact+varied. Compiling Cabal got ~3% slower, allocated ~3% more and wrote 15% more code to disk.+Nofib only saw 0.7% more compiler allocations and executable file size growth. But given+there was no difference in runtime for these benchmarks it turned out to be flat out worse.+See the ticket for more details. -} findExternalRules :: TidyOpts@@ -976,7 +982,8 @@ findExternalRules opts binds imp_id_rules unfold_env = (trimmed_binds, filter keep_rule all_rules) where- imp_rules = filter expose_rule imp_id_rules+ imp_rules | (opt_expose_rules opts) = filter expose_rule imp_id_rules+ | otherwise = [] imp_user_rule_fvs = mapUnionVarSet user_rule_rhs_fvs imp_rules user_rule_rhs_fvs rule | isAutoRule rule = emptyVarSet@@ -997,9 +1004,7 @@ -- RHS: the auto rules that might mention a binder that has -- been discarded; see Note [Trimming auto-rules] - expose_rule rule- | not (opt_expose_rules opts) = False- | otherwise = all is_external_id (ruleLhsFreeIdsList rule)+ expose_rule rule = all is_external_id (ruleLhsFreeIdsList rule) -- Don't expose a rule whose LHS mentions a locally-defined -- Id that is completely internal (i.e. not visible to an -- importing module). NB: ruleLhsFreeIds only returns LocalIds.@@ -1042,7 +1047,8 @@ -- In needed_fvs', we don't bother to delete binders from the fv set local_rules = [ rule- | id <- bndrs+ | (opt_expose_rules opts)+ , id <- bndrs , is_external_id id -- Only collect rules for external Ids , rule <- idCoreRules id , expose_rule rule ] -- and ones that can fire in a client@@ -1093,12 +1099,12 @@ | otherwise = panic "tidyTopName" where- name = idName id+ !name = idName id external = isJust maybe_ref global = isExternalName name local = not global internal = not external- loc = nameSrcSpan name+ !loc = nameSrcSpan name old_occ = nameOccName name new_occ | Just ref <- maybe_ref@@ -1146,60 +1152,49 @@ -- -- * subst_env: A Var->Var mapping that substitutes the new Var for the old -tidyTopBinds :: UnfoldingOpts- -> UnfoldEnv+tidyTopBinds :: UnfoldEnv -> NameSet -> TidyOccEnv -> CoreProgram -> IO (TidyEnv, CoreProgram) -tidyTopBinds uf_opts unfold_env boot_exports init_occ_env binds+tidyTopBinds unfold_env boot_exports init_occ_env binds = do let result = tidy init_env binds seqBinds (snd result) `seq` return result -- This seqBinds avoids a spike in space usage (see #13564) where init_env = (init_occ_env, emptyVarEnv) - tidy = mapAccumL (tidyTopBind uf_opts unfold_env boot_exports)+ tidy = mapAccumL (tidyTopBind unfold_env boot_exports) -------------------------tidyTopBind :: UnfoldingOpts- -> UnfoldEnv+tidyTopBind :: UnfoldEnv -> NameSet -> TidyEnv -> CoreBind -> (TidyEnv, CoreBind) -tidyTopBind uf_opts unfold_env boot_exports+tidyTopBind unfold_env boot_exports (occ_env,subst1) (NonRec bndr rhs) = (tidy_env2, NonRec bndr' rhs') where- Just (name',show_unfold) = lookupVarEnv unfold_env bndr- (bndr', rhs') = tidyTopPair uf_opts show_unfold boot_exports tidy_env2 name' (bndr, rhs)+ (bndr', rhs') = tidyTopPair unfold_env boot_exports tidy_env2 (bndr, rhs) subst2 = extendVarEnv subst1 bndr bndr' tidy_env2 = (occ_env, subst2) -tidyTopBind uf_opts unfold_env boot_exports (occ_env, subst1) (Rec prs)+tidyTopBind unfold_env boot_exports (occ_env, subst1) (Rec prs) = (tidy_env2, Rec prs') where- prs' = [ tidyTopPair uf_opts show_unfold boot_exports tidy_env2 name' (id,rhs)- | (id,rhs) <- prs,- let (name',show_unfold) =- expectJust "tidyTopBind" $ lookupVarEnv unfold_env id- ]-- subst2 = extendVarEnvList subst1 (bndrs `zip` map fst prs')+ prs' = map (tidyTopPair unfold_env boot_exports tidy_env2) prs+ subst2 = extendVarEnvList subst1 (map fst prs `zip` map fst prs') tidy_env2 = (occ_env, subst2)-- bndrs = map fst prs+ -- This is where we "tie the knot": tidy_env2 is fed into tidyTopPair ------------------------------------------------------------tidyTopPair :: UnfoldingOpts- -> Bool -- show unfolding+tidyTopPair :: UnfoldEnv -> NameSet -> TidyEnv -- The TidyEnv is used to tidy the IdInfo -- It is knot-tied: don't look at it!- -> Name -- New name -> (Id, CoreExpr) -- Binder and RHS before tidying -> (Id, CoreExpr) -- This function is the heart of Step 2@@ -1208,17 +1203,18 @@ -- group, a variable late in the group might be mentioned -- in the IdInfo of one early in the group -tidyTopPair uf_opts show_unfold boot_exports rhs_tidy_env name' (bndr, rhs)+tidyTopPair unfold_env boot_exports rhs_tidy_env (bndr, rhs) = -- pprTrace "tidyTop" (ppr name' <+> ppr details <+> ppr rhs) $ (bndr1, rhs1) where+ Just (name',show_unfold) = lookupVarEnv unfold_env bndr !cbv_bndr = tidyCbvInfoTop boot_exports bndr rhs bndr1 = mkGlobalId details name' ty' idinfo' details = idDetails cbv_bndr -- Preserve the IdDetails ty' = tidyTopType (idType cbv_bndr) rhs1 = tidyExpr rhs_tidy_env rhs- idinfo' = tidyTopIdInfo uf_opts rhs_tidy_env name' ty'+ idinfo' = tidyTopIdInfo rhs_tidy_env name' ty' rhs rhs1 (idInfo cbv_bndr) show_unfold -- tidyTopIdInfo creates the final IdInfo for top-level@@ -1228,9 +1224,9 @@ -- Indeed, CorePrep must eta expand where necessary to make -- the manifest arity equal to the claimed arity. ---tidyTopIdInfo :: UnfoldingOpts -> TidyEnv -> Name -> Type+tidyTopIdInfo :: TidyEnv -> Name -> Type -> CoreExpr -> CoreExpr -> IdInfo -> Bool -> IdInfo-tidyTopIdInfo uf_opts rhs_tidy_env name rhs_ty orig_rhs tidy_rhs idinfo show_unfold+tidyTopIdInfo rhs_tidy_env name rhs_ty orig_rhs tidy_rhs idinfo show_unfold | not is_external -- For internal Ids (not externally visible) = vanillaIdInfo -- we only need enough info for code generation -- Arity and strictness info are enough;@@ -1268,46 +1264,38 @@ -- No demand signature, so try a -- cheap-and-cheerful bottom analyser- | Just (_, nsig) <- mb_bot_str- = nsig+ | Just (_, bot_str_sig, _) <- mb_bot_str+ = bot_str_sig -- No stricness info | otherwise = nopSig cpr = cprSigInfo idinfo- final_cpr | Just _ <- mb_bot_str- = mkCprSig arity botCpr+ final_cpr | Just (_, _, bot_cpr_sig) <- mb_bot_str+ = bot_cpr_sig | otherwise = cpr - _bottom_hidden id_sig = case mb_bot_str of- Nothing -> False- Just (arity, _) -> not (isDeadEndAppSig id_sig arity)+ _bottom_hidden id_sig+ = case mb_bot_str of+ Nothing -> False+ Just (arity, _, _) -> not (isDeadEndAppSig id_sig arity) --------- Unfolding ------------+ -- Force unfold_info (hence bangs), otherwise the old unfolding+ -- is retained during code generation. See #22071+ unf_info = realUnfoldingInfo idinfo- unfold_info- | isCompulsoryUnfolding unf_info || show_unfold- = tidyUnfolding rhs_tidy_env unf_info unf_from_rhs- | otherwise- = minimal_unfold_info- minimal_unfold_info = trimUnfolding unf_info- unf_from_rhs = mkFinalUnfolding uf_opts InlineRhs final_sig tidy_rhs- -- NB: do *not* expose the worker if show_unfold is off,- -- because that means this thing is a loop breaker or- -- marked NOINLINE or something like that- -- This is important: if you expose the worker for a loop-breaker- -- then you can make the simplifier go into an infinite loop, because- -- in effect the unfolding is exposed. See #1709- --- -- You might think that if show_unfold is False, then the thing should- -- not be w/w'd in the first place. But a legitimate reason is this:- -- the function returns bottom- -- In this case, show_unfold will be false (we don't expose unfoldings- -- for bottoming functions), but we might still have a worker/wrapper- -- split (see Note [Worker/wrapper for bottoming functions] in- -- GHC.Core.Opt.WorkWrap)+ !minimal_unfold_info = trimUnfolding unf_info + !unfold_info | isCompulsoryUnfolding unf_info || show_unfold+ = tidyTopUnfolding rhs_tidy_env tidy_rhs unf_info+ | otherwise+ = minimal_unfold_info+-- unf_from_rhs = mkFinalUnfolding uf_opts InlineRhs final_sig orig_rhs+ -- NB: use `orig_rhs` not `tidy_rhs` in this call to mkFinalUnfolding+ -- else you get a black hole (#22122). Reason: mkFinalUnfolding+ -- looks at IdInfo, and that is knot-tied in tidyTopBind (the Rec case) --------- Arity ------------ -- Usually the Id will have an accurate arity on it, because@@ -1319,10 +1307,59 @@ arity = exprArity orig_rhs `min` typeArity rhs_ty -- orig_rhs: using tidy_rhs would make a black hole, since -- exprArity uses the arities of Ids inside the rhs+ -- -- typeArity: see Note [Arity invariants for bindings] -- in GHC.Core.Opt.Arity -{-+------------ Unfolding --------------+tidyTopUnfolding :: TidyEnv -> CoreExpr -> Unfolding -> Unfolding+tidyTopUnfolding _ _ NoUnfolding = NoUnfolding+tidyTopUnfolding _ _ BootUnfolding = BootUnfolding+tidyTopUnfolding _ _ (OtherCon {}) = evaldUnfolding++tidyTopUnfolding tidy_env _ df@(DFunUnfolding { df_bndrs = bndrs, df_args = args })+ = df { df_bndrs = bndrs', df_args = map (tidyExpr tidy_env') args }+ where+ (tidy_env', bndrs') = tidyBndrs tidy_env bndrs++tidyTopUnfolding tidy_env tidy_rhs+ unf@(CoreUnfolding { uf_tmpl = unf_rhs, uf_src = src })+ = -- See Note [tidyTopUnfolding: avoiding black holes]+ unf { uf_tmpl = tidy_unf_rhs }+ where+ tidy_unf_rhs | isStableSource src+ = tidyExpr tidy_env unf_rhs -- Preserves OccInfo in unf_rhs+ | otherwise+ = occurAnalyseExpr tidy_rhs -- Do occ-anal++{- Note [tidyTopUnfolding: avoiding black holes]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+When we are exposing all unfoldings we don't want to tidy the unfolding+twice -- we just want to use the tidied RHS. That tidied RHS itself+contains fully-tidied Ids -- it is knot-tied. So the uf_tmpl for the+unfolding contains stuff we can't look at. Now consider (#22112)+ foo = foo+If we freshly compute the uf_is_value field for foo's unfolding,+we'll call `exprIsValue`, which will look at foo's unfolding!+Whether or not the RHS is a value depends on whether foo is a value...+black hole.++In the Simplifier we deal with this by not giving `foo` an unfolding+in its own RHS. And we could do that here. But it's qite nice+to common everything up to a single Id for foo, used everywhere.++And it's not too hard: simply leave the unfolding undisturbed, except+tidy the uf_tmpl field. Hence tidyTopUnfolding does+ unf { uf_tmpl = tidy_unf_rhs }++Don't mess with uf_is_value, or guidance; in particular don't recompute+them from tidy_unf_rhs.++And (unlike tidyNestedUnfolding) don't deep-seq the new unfolding,+because that'll cause a black hole (I /think/ because occurAnalyseExpr+looks in IdInfo).++ ************************************************************************ * * Old, dead, type-trimming code
compiler/GHC/Iface/Tidy/StaticPtrTable.hs view
@@ -249,11 +249,11 @@ [ text "static StgWord64 k" <> int i <> text "[2] = " <> pprFingerprint fp <> semi $$ text "extern StgPtr "- <> (pdoc platform $ mkClosureLabel (idName n) (idCafInfo n)) <> semi+ <> (pprCLabel platform CStyle $ mkClosureLabel (idName n) (idCafInfo n)) <> semi $$ text "hs_spt_insert" <> parens (hcat $ punctuate comma [ char 'k' <> int i- , char '&' <> pdoc platform (mkClosureLabel (idName n) (idCafInfo n))+ , char '&' <> pprCLabel platform CStyle (mkClosureLabel (idName n) (idCafInfo n)) ] ) <> semi
compiler/GHC/Rename/Bind.hs view
@@ -70,6 +70,8 @@ import GHC.Data.OrdList import qualified GHC.LanguageExtensions as LangExt +import Language.Haskell.Syntax.Basic (FieldLabelString(..))+ import Control.Monad import Data.Foldable ( toList ) import Data.List ( partition, sortBy )@@ -710,7 +712,7 @@ RecCon vars -> do { checkDupRdrNames (map (foLabel . recordPatSynField) vars) ; fls <- lookupConstructorFields name- ; let fld_env = mkFsEnv [ (flLabel fl, fl) | fl <- fls ]+ ; let fld_env = mkFsEnv [ (field_label $ flLabel fl, fl) | fl <- fls ] ; let rnRecordPatSynField (RecordPatSynField { recordPatSynField = visible , recordPatSynPatVar = hidden })
compiler/GHC/Rename/Env.hs view
@@ -104,6 +104,7 @@ import GHC.Types.FieldLabel import GHC.Data.Bag import GHC.Types.PkgQual+import Language.Haskell.Syntax.Basic (FieldLabelString(..)) {- *********************************************************@@ -498,7 +499,7 @@ = lookupExactOrOrig rdr_name id $ -- See Note [Record field names and Template Haskell] do { flds <- lookupConstructorFields con ; env <- getGlobalRdrEnv- ; let lbl = occNameFS (rdrNameOcc rdr_name)+ ; let lbl = FieldLabelString $ occNameFS (rdrNameOcc rdr_name) mb_field = do fl <- find ((== lbl) . flLabel) flds -- We have the label, now check it is in scope. If -- there is a qualifier, use pickGREs to check that
compiler/GHC/Rename/Expr.hs view
@@ -73,6 +73,8 @@ import GHC.Builtin.Types ( nilDataConName ) import qualified GHC.LanguageExtensions as LangExt +import Language.Haskell.Syntax.Basic (FieldLabelString(..))+ import Data.List (unzip4, minimumBy) import Data.List.NonEmpty ( NonEmpty(..) ) import Data.Maybe (isJust, isNothing)@@ -2730,11 +2732,11 @@ -- mkSetField a field b calculates a set_field @field expression. -- e.g mkSetSetField a field b = set_field @"field" a b (read as "set field 'field' on a to b"). mkSetField :: Name -> LHsExpr GhcRn -> LocatedAn NoEpAnns FieldLabelString -> LHsExpr GhcRn -> HsExpr GhcRn-mkSetField set_field a (L _ field) b =+mkSetField set_field a (L _ (FieldLabelString field)) b = genHsApp (genHsApp (genHsVar set_field `genAppType` genHsTyLit field) a) b mkGet :: Name -> [LHsExpr GhcRn] -> LocatedAn NoEpAnns FieldLabelString -> [LHsExpr GhcRn]-mkGet get_field l@(r : _) (L _ field) =+mkGet get_field l@(r : _) (L _ (FieldLabelString field)) = wrapGenSpan (genHsApp (genHsVar get_field `genAppType` genHsTyLit field) r) : l mkGet _ [] _ = panic "mkGet : The impossible has happened!" @@ -2751,7 +2753,7 @@ f acc field = genHsApps circName $ map wrapGenSpan [proj field, acc] proj :: LocatedAn NoEpAnns FieldLabelString -> HsExpr GhcRn- proj (L _ f) = genHsVar getFieldName `genAppType` genHsTyLit f+ proj (L _ (FieldLabelString f)) = genHsVar getFieldName `genAppType` genHsTyLit f -- mkProjUpdateSetField calculates functions representing dot notation record updates. -- e.g. Suppose an update like foo.bar = 1.
compiler/GHC/Rename/HsType.hs view
@@ -78,6 +78,8 @@ import GHC.Data.Maybe import qualified GHC.LanguageExtensions as LangExt +import Language.Haskell.Syntax.Basic (FieldLabelString(..))+ import Data.List (sortBy, nubBy, partition) import qualified Data.List.NonEmpty as NE import Data.List.NonEmpty (NonEmpty(..))@@ -1282,7 +1284,7 @@ = mapFvRn (rnField fl_env env) fields where env = mkTyKiEnv ctxt TypeLevel RnTypeBody- fl_env = mkFsEnv [ (flLabel fl, fl) | fl <- fls ]+ fl_env = mkFsEnv [ (field_label $ flLabel fl, fl) | fl <- fls ] rnField :: FastStringEnv FieldLabel -> RnTyKiEnv -> LConDeclField GhcPs -> RnM (LConDeclField GhcRn, FreeVars)
compiler/GHC/Rename/Names.hs view
@@ -86,6 +86,8 @@ import GHC.Data.FastString import GHC.Data.FastString.Env +import Language.Haskell.Syntax.Basic (FieldLabelString(..))+ import Control.Monad import Data.Either ( partitionEithers ) import Data.Map ( Map )@@ -993,7 +995,7 @@ find_con_decl_fld (L _ (FieldOcc _ (L _ rdr))) = expectJust "getLocalNonValBinders/find_con_decl_fld" $ find (\ fl -> flLabel fl == lbl) flds- where lbl = occNameFS (rdrNameOcc rdr)+ where lbl = FieldLabelString $ occNameFS (rdrNameOcc rdr) new_assoc :: DuplicateRecordFields -> FieldSelectors -> LInstDecl GhcPs -> RnM ([AvailInfo], [(Name, [FieldLabel])])@@ -1055,7 +1057,7 @@ , flHasFieldSelector = has_sel , flSelector = selName } } where- fieldLabelString = occNameFS $ rdrNameOcc fld+ fieldLabelString = FieldLabelString $ occNameFS $ rdrNameOcc fld selOccName = fieldSelectorOccName fieldLabelString (nameOccName dc) dup_fields_ok has_sel field | isExact fld = fld -- use an Exact RdrName as is to preserve the bindings
compiler/GHC/Rename/Pat.hs view
@@ -82,6 +82,7 @@ import Data.Maybe import Data.Ratio import GHC.Types.FieldLabel (DuplicateRecordFields(..))+import Language.Haskell.Syntax.Basic (FieldLabelString(..)) {- *********************************************************@@ -822,7 +823,7 @@ (dot_dot_fields, dot_dot_gres) = unzip [ (fl, gre) | fl <- con_fields- , let lbl = mkVarOccFS (flLabel fl)+ , let lbl = mkVarOccFS (field_label $ flLabel fl) , not (lbl `elemOccSet` present_flds) , Just gre <- [lookupGRE_FieldLabel rdr_env fl] -- Check selector is in scope@@ -840,7 +841,7 @@ , hfbPun = False }) | fl <- dot_dot_fields , let sel = flSelector fl- , let arg_rdr = mkVarUnqual (flLabel fl) ] }+ , let arg_rdr = mkVarUnqual (field_label $ flLabel fl) ] } rn_dotdot _dotdot _mb_con _flds = return []
compiler/GHC/Runtime/Debugger.hs view
@@ -67,7 +67,7 @@ -- Obtain the terms and the recovered type information let ids = [id | AnId id <- pprintables]- (subst, terms) <- mapAccumLM go emptyTCvSubst ids+ (subst, terms) <- mapAccumLM go emptySubst ids -- Apply the substitutions obtained after recovering the types modifySession $ \hsc_env ->@@ -101,7 +101,7 @@ liftIO $ printOutputForUser logger unqual $ vcat sdocs -- Do the obtainTerm--bindSuspensions-computeSubstitution dance- go :: GhcMonad m => TCvSubst -> Id -> m (TCvSubst, Term)+ go :: GhcMonad m => Subst -> Id -> m (Subst, Term) go subst id = do let id' = updateIdTypeAndMult (substTy subst) id id_ty' = idType id'@@ -124,7 +124,7 @@ (fsep $ [text "RTTI Improvement for", ppr id, text "old substitution:" , ppr subst, text "new substitution:" , ppr subst'])- ; return (subst `unionTCvSubst` subst', term')}+ ; return (subst `unionSubst` subst', term')} tidyTermTyVars :: GhcMonad m => Term -> m Term tidyTermTyVars t =
compiler/GHC/Runtime/Eval.hs view
@@ -621,10 +621,10 @@ = do { name <- newInteractiveBinder hsc_env occ (getSrcSpan old_id) ; return (Id.mkVanillaGlobalWithInfo name ty (idInfo old_id)) } - newTyVars :: UniqSupply -> [TcTyVar] -> TCvSubst+ newTyVars :: UniqSupply -> [TcTyVar] -> Subst -- Similarly, clone the type variables mentioned in the types -- we have here, *and* make them all RuntimeUnk tyvars- newTyVars us tvs = foldl' new_tv emptyTCvSubst (tvs `zip` uniqsFromSupply us)+ newTyVars us tvs = foldl' new_tv emptySubst (tvs `zip` uniqsFromSupply us) new_tv subst (tv,uniq) = extendTCvSubstWithClone subst tv new_tv where new_tv = mkRuntimeUnkTyVar (setNameUnique (tyVarName tv) uniq)@@ -1146,7 +1146,7 @@ Just (_, tys@(_:_)) -> all isTyVarTy tys _ -> isTyVarTy ty - empty_subst = mkEmptyTCvSubst (mkInScopeSet (tyCoVarsOfType (idType $ is_dfun clsInst)))+ empty_subst = mkEmptySubst (mkInScopeSet (tyCoVarsOfType (idType $ is_dfun clsInst))) {- Create a ClsInst with instantiated arguments and constraints.
compiler/GHC/Runtime/Heap/Inspect.hs view
@@ -637,7 +637,7 @@ -} -instTyVars :: [TyVar] -> TR (TCvSubst, [TcTyVar])+instTyVars :: [TyVar] -> TR (Subst, [TcTyVar]) -- Instantiate fresh mutable type variables from some TyVars -- This function preserves the print-name, which helps error messages instTyVars tvs@@ -1101,7 +1101,7 @@ -- improveType <base_type> <rtti_type> -- The types can contain skolem type variables, which need to be treated as normal vars. -- In particular, we want them to unify with things.-improveRTTIType :: HscEnv -> RttiType -> RttiType -> Maybe TCvSubst+improveRTTIType :: HscEnv -> RttiType -> RttiType -> Maybe Subst improveRTTIType _ base_ty new_ty = U.tcUnifyTyKi base_ty new_ty getDataConArgTys :: DataCon -> Type -> TR [Type]
compiler/GHC/Runtime/Loader.hs view
@@ -26,6 +26,7 @@ import GHC.Driver.Ppr import GHC.Driver.Hooks import GHC.Driver.Plugins+import GHC.Driver.Plugins.External import GHC.Linker.Loader ( loadModule, loadName ) import GHC.Runtime.Interpreter ( wormhole )@@ -75,22 +76,48 @@ -- pluginModNames or pluginModNameOpts changes. initializePlugins :: HscEnv -> IO HscEnv initializePlugins hsc_env- -- plugins not changed+ -- check that plugin specifications didn't change++ -- dynamic plugins | loaded_plugins <- loadedPlugins (hsc_plugins hsc_env) , map lpModuleName loaded_plugins == reverse (pluginModNames dflags)- -- arguments not changed , all same_args loaded_plugins- = return hsc_env -- no need to reload plugins FIXME: doesn't take static plugins into account++ -- external plugins+ , external_plugins <- externalPlugins (hsc_plugins hsc_env)+ , check_external_plugins external_plugins (externalPluginSpecs dflags)++ -- FIXME: we should check static plugins too++ = return hsc_env -- no change, no need to reload plugins+ | otherwise = do (loaded_plugins, links, pkgs) <- loadPlugins hsc_env- let plugins' = (hsc_plugins hsc_env) { loadedPlugins = loaded_plugins, loadedPluginDeps = (links, pkgs) }+ external_plugins <- loadExternalPlugins (externalPluginSpecs dflags)+ let plugins' = (hsc_plugins hsc_env) { staticPlugins = staticPlugins (hsc_plugins hsc_env)+ , externalPlugins = external_plugins+ , loadedPlugins = loaded_plugins+ , loadedPluginDeps = (links, pkgs)+ } let hsc_env' = hsc_env { hsc_plugins = plugins' } withPlugins (hsc_plugins hsc_env') driverPlugin hsc_env' where+ dflags = hsc_dflags hsc_env+ -- dynamic plugins plugin_args = pluginModNameOpts dflags same_args p = paArguments (lpPlugin p) == argumentsForPlugin p plugin_args argumentsForPlugin p = map snd . filter ((== lpModuleName p) . fst)- dflags = hsc_dflags hsc_env+ -- external plugins+ check_external_plugin p spec = and+ [ epUnit p == esp_unit_id spec+ , epModule p == esp_module spec+ , paArguments (epPlugin p) == esp_args spec+ ]+ check_external_plugins eps specs = case (eps,specs) of+ ([] , []) -> True+ (_ , []) -> False -- some external plugin removed+ ([] , _ ) -> False -- some external plugin added+ (p:ps,s:ss) -> check_external_plugin p s && check_external_plugins ps ss loadPlugins :: HscEnv -> IO ([LoadedPlugin], [Linkable], PkgsLoaded) loadPlugins hsc_env
compiler/GHC/Settings/IO.hs view
@@ -94,7 +94,6 @@ cc_args = words cc_args_str ++ unreg_cc_args cxx_args = words cxx_args_str ldSupportsCompactUnwind <- getBooleanSetting "ld supports compact unwind"- ldSupportsBuildId <- getBooleanSetting "ld supports build-id" ldSupportsFilelist <- getBooleanSetting "ld supports filelist" ldIsGnuLd <- getBooleanSetting "ld is GNU ld" arSupportsDashL <- getBooleanSetting "ar supports -L"@@ -163,7 +162,6 @@ , sToolSettings = ToolSettings { toolSettings_ldSupportsCompactUnwind = ldSupportsCompactUnwind- , toolSettings_ldSupportsBuildId = ldSupportsBuildId , toolSettings_ldSupportsFilelist = ldSupportsFilelist , toolSettings_ldIsGnuLd = ldIsGnuLd , toolSettings_ccSupportsNoPie = gccSupportsNoPie
compiler/GHC/Stg/InferTags/Rewrite.hs view
@@ -20,6 +20,7 @@ import GHC.Prelude +import GHC.Builtin.PrimOps ( PrimOp(..) ) import GHC.Types.Id import GHC.Types.Name import GHC.Types.Unique.Supply@@ -346,6 +347,19 @@ type IsScrut = Bool +rewriteArgs :: [StgArg] -> RM [StgArg]+rewriteArgs = mapM rewriteArg+rewriteArg :: StgArg -> RM StgArg+rewriteArg (StgVarArg v) = StgVarArg <$!> rewriteId v+rewriteArg (lit@StgLitArg{}) = return lit++-- Attach a tagSig if it's tagged+rewriteId :: Id -> RM Id+rewriteId v = do+ is_tagged <- isTagged v+ if is_tagged then return $! setIdTagSig v (TagSig TagProper)+ else return v+ rewriteExpr :: IsScrut -> InferStgExpr -> RM TgStgExpr rewriteExpr _ (e@StgCase {}) = rewriteCase e rewriteExpr _ (e@StgLet {}) = rewriteLet e@@ -355,8 +369,11 @@ rewriteExpr isScrut e@(StgApp {}) = rewriteApp isScrut e rewriteExpr _ (StgLit lit) = return $! (StgLit lit)+rewriteExpr _ (StgOpApp op@(StgPrimOp DataToTagOp) args res_ty) = do+ (StgOpApp op) <$!> rewriteArgs args <*> pure res_ty rewriteExpr _ (StgOpApp op args res_ty) = return $! (StgOpApp op args res_ty) + rewriteCase :: InferStgExpr -> RM TgStgExpr rewriteCase (StgCase scrut bndr alt_type alts) = withBinder NotTopLevel bndr $@@ -415,6 +432,7 @@ -- isTagged looks at more than the result of our analysis. -- So always update here if useful. let f' = if f_tagged+ -- TODO: We might consisder using a subst env instead of setting the sig only for select places. then setIdTagSig f (TagSig TagProper) else f return $! StgApp f' []
compiler/GHC/Stg/Pipeline.hs view
@@ -126,7 +126,7 @@ StgUnarise -> do us <- getUniqueSupplyM liftIO (stg_linter False "Pre-unarise" binds)- let binds' = unarise us binds+ let binds' = {-# SCC "StgUnarise" #-} unarise us binds liftIO (dump_when Opt_D_dump_stg_unarised "Unarised STG:" binds') liftIO (stg_linter True "Unarise" binds') return binds'
compiler/GHC/StgToCmm/Closure.hs view
@@ -208,7 +208,7 @@ mkLFArgument :: Id -> LambdaFormInfo mkLFArgument id | isUnliftedType ty = LFUnlifted- | might_be_a_function ty = LFUnknown True+ | mightBeFunTy ty = LFUnknown True | otherwise = LFUnknown False where ty = idType id@@ -236,19 +236,7 @@ LFThunk top (null fvs) (isUpdatable upd_flag) NonStandardThunk- (might_be_a_function thunk_ty)-----------------might_be_a_function :: Type -> Bool--- Return False only if we are *sure* it's a data type--- Look through newtypes etc as much as poss-might_be_a_function ty- | [LiftedRep] <- typePrimRep ty- , Just tc <- tyConAppTyCon_maybe (unwrapType ty)- , isDataTyCon tc- = False- | otherwise- = True+ (mightBeFunTy thunk_ty) ------------- mkConLFInfo :: DataCon -> LambdaFormInfo@@ -258,13 +246,13 @@ mkSelectorLFInfo :: Id -> Int -> Bool -> LambdaFormInfo mkSelectorLFInfo id offset updatable = LFThunk NotTopLevel False updatable (SelectorThunk offset)- (might_be_a_function (idType id))+ (mightBeFunTy (idType id)) ------------- mkApLFInfo :: Id -> UpdateFlag -> Arity -> LambdaFormInfo mkApLFInfo id upd_flag arity = LFThunk NotTopLevel (arity == 0) (isUpdatable upd_flag) (ApThunk arity)- (might_be_a_function (idType id))+ (mightBeFunTy (idType id)) ------------- mkLFImported :: Id -> LambdaFormInfo@@ -597,8 +585,8 @@ | n_args == 0 , Just sig <- idTagSig_maybe id , isTaggedSig sig -- Infered to be already evaluated by Tag Inference- -- When profiling we enter functions to update the SCC so we- -- can't use the infered enterInfo here.+ -- When profiling we must enter all potential functions to make sure we update the SCC+ -- even if the function itself is already evaluated. -- See Note [Evaluating functions with profiling] in rts/Apply.cmm , not (profileIsProfiling (stgToCmmProfile cfg) && might_be_a_function) = InferedReturnIt -- See Note [Tag Inference]
compiler/GHC/StgToCmm/Expr.hs view
@@ -45,7 +45,7 @@ import GHC.Builtin.PrimOps import GHC.Core.TyCon import GHC.Core.Type ( isUnliftedType )-import GHC.Types.RepType ( isZeroBitTy, countConRepArgs )+import GHC.Types.RepType ( isZeroBitTy, countConRepArgs, mightBeFunTy ) import GHC.Types.CostCentre ( CostCentreStack, currentCCS ) import GHC.Types.Tickish import GHC.Data.Maybe@@ -59,6 +59,7 @@ import Control.Arrow ( first ) import Data.List ( partition ) import GHC.Stg.InferTags.TagSig (isTaggedSig)+import GHC.Platform.Profile (profileIsProfiling) ------------------------------------------------------------------------ -- cgExpr: the main function@@ -75,6 +76,8 @@ -- dataToTag# :: a -> Int# -- See Note [dataToTag# magic] in GHC.Core.Opt.ConstantFold+-- TODO: There are some more optimization ideas for this code path+-- in #21710 cgExpr (StgOpApp (StgPrimOp DataToTagOp) [StgVarArg a] _res_ty) = do platform <- getPlatform emitComment (mkFastString "dataToTag#")@@ -91,15 +94,7 @@ -- the constructor index is too large to fit in the pointer and therefore -- we must look in the info table. See Note [Tagging big families]. - slow_path <- getCode $ do- tmp <- newTemp (bWord platform)- _ <- withSequel (AssignTo [tmp] False) (cgIdApp a [])- profile <- getProfile- align_check <- stgToCmmAlignCheck <$> getStgToCmmConfig- emitAssign (CmmLocal result_reg)- $ getConstrTag profile align_check (cmmUntag platform (CmmReg (CmmLocal tmp)))-- fast_path <- getCode $ do+ (fast_path :: CmmAGraph) <- getCode $ do -- Return the constructor index from the pointer tag return_ptr_tag <- getCode $ do emitAssign (CmmLocal result_reg)@@ -112,8 +107,22 @@ $ getConstrTag profile align_check (cmmUntag platform amode) emit =<< mkCmmIfThenElse' is_too_big_tag return_info_tag return_ptr_tag (Just False)-- emit =<< mkCmmIfThenElse' is_tagged fast_path slow_path (Just True)+ -- If we know the argument is already tagged there is no need to generate code to evaluate it+ -- so we skip straight to the fast path. If we don't know if there is a tag we take the slow+ -- path which evaluates the argument before fetching the tag.+ case (idTagSig_maybe a) of+ Just sig+ | isTaggedSig sig+ -> emit fast_path+ _ -> do+ slow_path <- getCode $ do+ tmp <- newTemp (bWord platform)+ _ <- withSequel (AssignTo [tmp] False) (cgIdApp a [])+ profile <- getProfile+ align_check <- stgToCmmAlignCheck <$> getStgToCmmConfig+ emitAssign (CmmLocal result_reg)+ $ getConstrTag profile align_check (cmmUntag platform (CmmReg (CmmLocal tmp)))+ emit =<< mkCmmIfThenElse' is_tagged fast_path slow_path (Just True) emitReturn [CmmReg $ CmmLocal result_reg] @@ -551,7 +560,6 @@ | not simple_scrut = True | isSingleton alts = False | up_hp_usg > 0 = False- | evaluatedScrut = False | otherwise = True -- cf Note [Compiling case expressions] gc_plan = if do_gc then GcInAlts alt_regs else NoGcInAlts@@ -567,14 +575,8 @@ where is_cmp_op (StgOpApp (StgPrimOp op) _ _) = isComparisonPrimOp op is_cmp_op _ = False- evaluatedScrut- | (StgApp v []) <- scrut- , Just sig <- idTagSig_maybe v- , isTaggedSig sig = True- | otherwise = False - {- Note [GC for conditionals] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ For boolean conditionals it seems that we have always done NoGcInAlts.@@ -628,7 +630,11 @@ isSimpleScrut (StgApp _ []) (PrimAlt _) = return True -- case x# of { 0# -> ..; ... } isSimpleScrut (StgApp f []) _ | Just sig <- idTagSig_maybe f- = return $! isTaggedSig sig -- case !x of { ... }+ , isTaggedSig sig -- case !x of { ... }+ = if mightBeFunTy (idType f)+ -- See Note [Evaluating functions with profiling] in rts/Apply.cmm+ then not . profileIsProfiling <$> getProfile+ else pure True isSimpleScrut _ _ = return False isSimpleOp :: StgOp -> [StgArg] -> FCode Bool
compiler/GHC/StgToCmm/Layout.hs view
@@ -297,7 +297,7 @@ platform <- getPlatform pprPanic "direct_call" $ text caller <+> ppr arity <+>- pdoc platform lbl <+> ppr (length args) <+>+ pprDebugCLabel platform lbl <+> ppr (length args) <+> pdoc platform (map snd args) <+> ppr (map fst args) | null rest_args -- Precisely the right number of arguments
compiler/GHC/StgToCmm/Prim.hs view
@@ -1597,6 +1597,7 @@ LabelThreadOp -> alwaysExternal IsCurrentThreadBoundOp -> alwaysExternal NoDuplicateOp -> alwaysExternal+ GetThreadLabelOp -> alwaysExternal ThreadStatusOp -> alwaysExternal MkWeakOp -> alwaysExternal MkWeakNoFinalizerOp -> alwaysExternal@@ -1624,6 +1625,7 @@ MkApUpd0_Op -> alwaysExternal NewBCOOp -> alwaysExternal UnpackClosureOp -> alwaysExternal+ ListThreadsOp -> alwaysExternal ClosureSizeOp -> alwaysExternal WhereFromOp -> alwaysExternal GetApStackValOp -> alwaysExternal
compiler/GHC/StgToCmm/Ticky.hs view
@@ -363,7 +363,7 @@ Just (CgIdInfo { cg_lf = cg_lf }) | isLFThunk cg_lf -> return $! CmmLabel $ mkClosureInfoTableLabel (profilePlatform profile) tickee cg_lf- _ -> pprTraceDebug "tickyThunkUnknown" (text t <> colon <> ppr name <+> ppr (mkInfoTableLabel name NoCafRefs))+ _ -> pprTraceDebug "tickyThunkUnknown" (text t <> colon <> ppr name <+> pprDebugCLabel (profilePlatform profile) (mkInfoTableLabel name NoCafRefs)) return $! zeroCLit platform TickyLNE {} -> return $! zeroCLit platform
compiler/GHC/Tc/Deriv.hs view
@@ -645,9 +645,9 @@ DerivErrDerivingViaWrongKind inst_ty_kind via_ty via_kind) let Just kind_subst = mb_match- ki_subst_range = getTCvSubstRangeFVs kind_subst+ ki_subst_range = getSubstRangeTyCoFVs kind_subst -- See Note [Unification of two kind variables in deriving]- unmapped_tkvs = filter (\v -> v `notElemTCvSubst` kind_subst+ unmapped_tkvs = filter (\v -> v `notElemSubst` kind_subst && not (v `elemVarSet` ki_subst_range)) tvs (subst, _) = substTyVarBndrs kind_subst unmapped_tkvs@@ -769,9 +769,9 @@ propagate_subst kind_subst tkvs' cls_tys' tc_args' mb_deriv_strat' = (final_tkvs, final_cls_tys, final_tc_args, final_mb_deriv_strat) where- ki_subst_range = getTCvSubstRangeFVs kind_subst+ ki_subst_range = getSubstRangeTyCoFVs kind_subst -- See Note [Unification of two kind variables in deriving]- unmapped_tkvs = filter (\v -> v `notElemTCvSubst` kind_subst+ unmapped_tkvs = filter (\v -> v `notElemSubst` kind_subst && not (v `elemVarSet` ki_subst_range)) tkvs' (subst, _) = substTyVarBndrs kind_subst unmapped_tkvs@@ -1008,7 +1008,7 @@ We used to accomplish this by doing the following: - unmapped_tkvs = filter (`notElemTCvSubst` kind_subst) all_tkvs+ unmapped_tkvs = filter (`notElemSubst` kind_subst) all_tkvs (subst, _) = substTyVarBndrs kind_subst unmapped_tkvs Where all_tkvs contains all kind variables in the class and instance types (in@@ -1024,9 +1024,9 @@ To prevent this, we need to filter out any variable from all_tkvs which either -1. Appears in the domain of kind_subst. notElemTCvSubst checks this.+1. Appears in the domain of kind_subst. notElemSubst checks this. 2. Appears in the range of kind_subst. To do this, we compute the free- variable set of the range of kind_subst with getTCvSubstRangeFVs, and check+ variable set of the range of kind_subst with getSubstRangeTyCoFVs, and check if a kind variable appears in that set. Note [Eta-reducing type synonyms]
compiler/GHC/Tc/Deriv/Generate.hs view
@@ -46,6 +46,7 @@ import GHC.Tc.Utils.Monad import GHC.Hs+import GHC.Types.FieldLabel import GHC.Types.Name.Reader import GHC.Types.Basic import GHC.Types.Fixity@@ -84,6 +85,8 @@ import GHC.Data.Pair import GHC.Data.Bag +import Language.Haskell.Syntax.Basic (FieldLabelString(..))+ import Data.List ( find, partition, intersperse ) import GHC.Data.Maybe ( expectJust ) import GHC.Unit.Module@@ -1110,7 +1113,7 @@ field_stmts = zipWithEqual "lbl_stmts" read_field labels as_needed con_arity = dataConSourceArity data_con- labels = map flLabel $ dataConFieldLabels data_con+ labels = map (field_label . flLabel) $ dataConFieldLabels data_con dc_nm = getName data_con is_infix = dataConIsInfix data_con is_record = labels `lengthExceeds` 0@@ -1234,7 +1237,7 @@ arg_tys = derivDataConInstArgTys data_con dit -- Correspond 1-1 with bs_needed con_pat = nlConVarPat data_con_RDR bs_needed nullary_con = con_arity == 0- labels = map flLabel $ dataConFieldLabels data_con+ labels = map (field_label . flLabel) $ dataConFieldLabels data_con lab_fields = length labels record_syntax = lab_fields > 0 @@ -2200,7 +2203,7 @@ , nlList labels -- Field labels , nlHsVar fixity ] -- Fixity - labels = map (nlHsLit . mkHsString . unpackFS . flLabel)+ labels = map (nlHsLit . mkHsString . unpackFS . field_label . flLabel) (dataConFieldLabels dc) dc_occ = getOccName dc is_infix = isDataSymOcc dc_occ@@ -2759,7 +2762,7 @@ -- | Apply a substitution to all of the 'Type's contained in a 'DerivInstTys'. -- See @Note [Instantiating field types in stock deriving]@ for why we need to -- substitute into a 'DerivInstTys' in the first place.-substDerivInstTys :: TCvSubst -> DerivInstTys -> DerivInstTys+substDerivInstTys :: Subst -> DerivInstTys -> DerivInstTys substDerivInstTys subst dit@(DerivInstTys { dit_cls_tys = cls_tys, dit_tc_args = tc_args , dit_rep_tc = rep_tc, dit_rep_tc_args = rep_tc_args })
compiler/GHC/Tc/Deriv/Generics.hs view
@@ -58,6 +58,8 @@ import GHC.Data.FastString import GHC.Utils.Misc +import Language.Haskell.Syntax.Basic (FieldLabelString(..))+ import Control.Monad (mplus) import Data.List (zip4, partition) import Data.Maybe (isJust)@@ -639,7 +641,7 @@ then promotedTrueDataCon else promotedFalseDataCon - selName = mkStrLitTy . flLabel+ selName = mkStrLitTy . field_label . flLabel mbSel Nothing = mkTyConApp promotedNothingDataCon [typeSymbolKind] mbSel (Just s) = mkTyConApp promotedJustDataCon
compiler/GHC/Tc/Deriv/Infer.hs view
@@ -178,7 +178,7 @@ con_arg_constraints :: (CtOrigin -> TypeOrKind -> Type- -> [(ThetaSpec, Maybe TCvSubst)])+ -> [(ThetaSpec, Maybe Subst)]) -> (ThetaSpec, [TyVar], [TcType], DerivInstTys) con_arg_constraints get_arg_constraints = let -- Constraints from the fields of each data constructor.@@ -215,8 +215,8 @@ -- kinds with (* -> *). -- See Note [Inferring the instance context] subst = foldl' composeTCvSubst- emptyTCvSubst (catMaybes mbSubsts)- unmapped_tvs = filter (\v -> v `notElemTCvSubst` subst+ emptySubst (catMaybes mbSubsts)+ unmapped_tvs = filter (\v -> v `notElemSubst` subst && not (v `isInScope` subst)) tvs (subst', _) = substTyVarBndrs subst unmapped_tvs stupid_theta_origin = mkDirectThetaSpec@@ -236,13 +236,13 @@ || is_generic1 get_gen1_constraints :: Class -> CtOrigin -> TypeOrKind -> Type- -> [(ThetaSpec, Maybe TCvSubst)]+ -> [(ThetaSpec, Maybe Subst)] get_gen1_constraints functor_cls orig t_or_k ty = mk_functor_like_constraints orig t_or_k functor_cls $ get_gen1_constrained_tys last_tv ty get_std_constrained_tys :: CtOrigin -> TypeOrKind -> Type- -> [(ThetaSpec, Maybe TCvSubst)]+ -> [(ThetaSpec, Maybe Subst)] get_std_constrained_tys orig t_or_k ty | is_functor_like = mk_functor_like_constraints orig t_or_k main_cls $@@ -253,7 +253,7 @@ mk_functor_like_constraints :: CtOrigin -> TypeOrKind -> Class -> [Type]- -> [(ThetaSpec, Maybe TCvSubst)]+ -> [(ThetaSpec, Maybe Subst)] -- 'cls' is usually main_cls (Functor or Traversable etc), but if -- main_cls = Generic1, then 'cls' can be Functor; see -- get_gen1_constraints
compiler/GHC/Tc/Deriv/Utils.hs view
@@ -637,7 +637,7 @@ , sps_type_or_kind = t_or_k }) -substPredSpec :: HasCallStack => TCvSubst -> PredSpec -> PredSpec+substPredSpec :: HasCallStack => Subst -> PredSpec -> PredSpec substPredSpec subst ps = case ps of SimplePredSpec { sps_pred = pred
compiler/GHC/Tc/Gen/Bind.hs view
@@ -43,6 +43,7 @@ import GHC.Tc.Types.Evidence import GHC.Tc.Types.Constraint import GHC.Core.Predicate+import GHC.Core.TyCo.Ppr( pprTyVars ) import GHC.Tc.Gen.HsType import GHC.Tc.Gen.Pat import GHC.Tc.Utils.TcMType@@ -59,7 +60,7 @@ import GHC.Types.Id import GHC.Types.Var as Var import GHC.Types.Var.Set-import GHC.Types.Var.Env( TidyEnv )+import GHC.Types.Var.Env( TidyEnv, TyVarEnv, mkVarEnv, lookupVarEnv ) import GHC.Unit.Module import GHC.Types.Name import GHC.Types.Name.Set@@ -934,7 +935,8 @@ ; let psig_qtvs = map binderVar psig_qtv_bndrs psig_qtv_set = mkVarSet psig_qtvs psig_qtv_prs = psig_qtv_nms `zip` psig_qtvs-+ psig_bndr_map :: TyVarEnv InvisTVBinder+ psig_bndr_map = mkVarEnv [ (binderVar tvb, tvb) | tvb <- psig_qtv_bndrs ] -- Check whether the quantified variables of the -- partial signature have been unified together@@ -950,32 +952,35 @@ ; annotated_theta <- zonkTcTypes annotated_theta ; (free_tvs, my_theta) <- choose_psig_context psig_qtv_set annotated_theta wcx+ -- NB: free_tvs includes tau_tvs - ; let keep_me = free_tvs `unionVarSet` psig_qtv_set- final_qtvs = [ mkTyVarBinder vis tv- | tv <- qtvs -- Pulling from qtvs maintains original order- , tv `elemVarSet` keep_me- , let vis = case lookupVarBndr tv psig_qtv_bndrs of- Just spec -> spec- Nothing -> InferredSpec ]+ ; let (_,final_qtvs) = foldr (choose_qtv psig_bndr_map) (free_tvs, []) qtvs+ -- Pulling from qtvs maintains original order+ -- NB: qtvs is already in dependency order + ; traceTc "chooseInferredQuantifiers" $+ vcat [ text "qtvs" <+> pprTyVars qtvs+ , text "psig_qtv_bndrs" <+> ppr psig_qtv_bndrs+ , text "free_tvs" <+> ppr free_tvs+ , text "final_tvs" <+> ppr final_qtvs ]+ ; return (final_qtvs, my_theta) } where- report_dup_tyvar_tv_err (n1,n2)- = addErrTc (TcRnPartialTypeSigTyVarMismatch n1 n2 fn_name hs_ty)-- report_mono_sig_tv_err (n,tv)- = addErrTc (TcRnPartialTypeSigBadQuantifier n fn_name m_unif_ty hs_ty)- where- m_unif_ty = listToMaybe- [ rhs- -- recall that residuals are always implications- | residual_implic <- bagToList $ wc_impl residual- , residual_ct <- bagToList $ wc_simple (ic_wanted residual_implic)- , let residual_pred = ctPred residual_ct- , Just (Nominal, lhs, rhs) <- [ getEqPredTys_maybe residual_pred ]- , Just lhs_tv <- [ tcGetTyVar_maybe lhs ]- , lhs_tv == tv ]+ choose_qtv :: TyVarEnv InvisTVBinder -> TcTyVar+ -> (TcTyVarSet, [InvisTVBinder]) -> (TcTyVarSet, [InvisTVBinder])+ -- Pick which of the original qtvs should be retained+ -- Keep it if (a) it is mentioned in the body of the type (free_tvs)+ -- (b) it is a forall'd variable of the partial signature (psig_qtv_bndrs)+ -- (c) it is mentioned in the kind of a retained qtv (#22065)+ choose_qtv psig_bndr_map tv (free_tvs, qtvs)+ | Just psig_bndr <- lookupVarEnv psig_bndr_map tv+ = (free_tvs', psig_bndr : qtvs)+ | tv `elemVarSet` free_tvs+ = (free_tvs', mkTyVarBinder InferredSpec tv : qtvs)+ | otherwise -- Do not pick it+ = (free_tvs, qtvs)+ where+ free_tvs' = free_tvs `unionVarSet` tyCoVarsOfType (tyVarKind tv) choose_psig_context :: VarSet -> TcThetaType -> Maybe TcType -> TcM (VarSet, TcThetaType)@@ -1018,6 +1023,22 @@ ; return (free_tvs, annotated_theta ++ diff_theta) } -- Return (annotated_theta ++ diff_theta) -- See Note [Extra-constraints wildcards]++ report_dup_tyvar_tv_err (n1,n2)+ = addErrTc (TcRnPartialTypeSigTyVarMismatch n1 n2 fn_name hs_ty)++ report_mono_sig_tv_err (n,tv)+ = addErrTc (TcRnPartialTypeSigBadQuantifier n fn_name m_unif_ty hs_ty)+ where+ m_unif_ty = listToMaybe+ [ rhs+ -- recall that residuals are always implications+ | residual_implic <- bagToList $ wc_impl residual+ , residual_ct <- bagToList $ wc_simple (ic_wanted residual_implic)+ , let residual_pred = ctPred residual_ct+ , Just (Nominal, lhs, rhs) <- [ getEqPredTys_maybe residual_pred ]+ , Just lhs_tv <- [ tcGetTyVar_maybe lhs ]+ , lhs_tv == tv ] mk_ctuple preds = mkBoxedTupleTy preds -- Hack alert! See GHC.Tc.Gen.HsType:
compiler/GHC/Tc/Gen/Expr.hs view
@@ -37,6 +37,7 @@ import GHC.Tc.Utils.Unify import GHC.Types.Basic import GHC.Types.Error+import GHC.Types.FieldLabel import GHC.Types.Unique.Map ( UniqMap, listToUniqMap, lookupUniqMap ) import GHC.Core.Multiplicity import GHC.Core.UsageEnv@@ -84,6 +85,8 @@ import GHC.Core.Class(classTyCon) import GHC.Types.Unique.Set ( UniqSet, mkUniqSet, elementOfUniqSet, nonDetEltsUniqSet ) +import Language.Haskell.Syntax.Basic (FieldLabelString(..))+ import Data.Function import Data.List (partition, sortBy, groupBy, intersect) @@ -1208,7 +1211,7 @@ -- After this we know that rbinds is unambiguous ; rbinds <- disambiguateRecordBinds record_expr record_rho rbnds res_ty ; let upd_flds = map (unLoc . hfbLHS . unLoc) rbinds- upd_fld_occs = map (occNameFS . rdrNameOcc . rdrNameAmbiguousFieldOcc) upd_flds+ upd_fld_occs = map (FieldLabelString . occNameFS . rdrNameOcc . rdrNameAmbiguousFieldOcc) upd_flds sel_ids = map selectorAmbiguousFieldOcc upd_flds upd_fld_names = map idName sel_ids @@ -1355,7 +1358,7 @@ Just (upd_id, _) -> (genWildPat, genLHsVar (idName upd_id)) -- Field is not being updated: LHS = variable pattern, RHS = that same variable. _ -> let fld_nm = mkInternalName (mkBuiltinUnique i)- (mkVarOccFS (flLabel fld_lbl))+ (mkVarOccFS (field_label $ flLabel fld_lbl)) generatedSrcSpan in (genVarPat fld_nm, genLHsVar fld_nm) @@ -1599,7 +1602,7 @@ = do { addErrTc (badFieldConErr (getName con_like) field_lbl) ; return Nothing } where- field_lbl = occNameFS $ rdrNameOcc (unLoc lbl)+ field_lbl = FieldLabelString $ occNameFS $ rdrNameOcc (unLoc lbl) checkMissingFields :: ConLike -> HsRecordBinds GhcRn -> [Scaled TcType] -> TcM ()@@ -1705,7 +1708,7 @@ membership :: [(FieldLabelString, [Bool])] membership = sortMembership $ map (\fld -> (fld, map (fld `elementOfUniqSet`) fieldLabelSets)) $- map (occNameFS . rdrNameOcc . rdrNameAmbiguousFieldOcc . unLoc . hfbLHS . unLoc) rbinds+ map (FieldLabelString . occNameFS . rdrNameOcc . rdrNameAmbiguousFieldOcc . unLoc . hfbLHS . unLoc) rbinds fieldLabelSets :: [UniqSet FieldLabelString] fieldLabelSets = map (mkUniqSet . map flLabel . conLikeFieldLabels) data_cons
compiler/GHC/Tc/Gen/HsType.hs view
@@ -1,4 +1,3 @@- {-# LANGUAGE DataKinds #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE RankNTypes #-}@@ -1572,12 +1571,12 @@ -- Note that in a typical application (F t1 t2 t3), -- the 'fun' is just a TyCon, so tcTypeKind is fast - empty_subst = mkEmptyTCvSubst $ mkInScopeSet $+ empty_subst = mkEmptySubst $ mkInScopeSet $ tyCoVarsOfType fun_ki go :: Int -- The # of the next argument -> TcType -- Function applied to some args- -> TCvSubst -- Applies to function kind+ -> Subst -- Applies to function kind -> TcKind -- Function kind -> [LHsTypeArg GhcRn] -- Un-type-checked args -> TcM (TcType, TcKind) -- Result type and its kind@@ -1687,7 +1686,7 @@ | otherwise = fallthrough - zapped_subst = zapTCvSubst subst+ zapped_subst = zapSubst subst substed_fun_ki = substTy subst fun_ki hs_ty = appTypeToArg orig_hs_ty (take (n-1) orig_hs_args) @@ -1700,10 +1699,10 @@ ty_app_err arg ty = failWith $ TcRnInvalidVisibleKindArgument arg ty -mkAppTyM :: TCvSubst+mkAppTyM :: Subst -> TcType -> TyCoBinder -- fun, plus its top-level binder -> TcType -- arg- -> TcM (TCvSubst, TcType) -- Extended subst, plus (fun arg)+ -> TcM (Subst, TcType) -- Extended subst, plus (fun arg) -- Precondition: the application (fun arg) is well-kinded after zonking -- That is, the application makes sense --@@ -2581,7 +2580,7 @@ -- Why? So that the TyConBinders of the TyCon will lexically scope over the -- associated types and methods of a class. ; let swizzle_env = mkVarEnv (map swap implicit_prs)- (subst, swizzled_tcbs) = mapAccumL (swizzleTcb swizzle_env) emptyTCvSubst all_tcbs+ (subst, swizzled_tcbs) = mapAccumL (swizzleTcb swizzle_env) emptySubst all_tcbs swizzled_kind = substTy subst tycon_res_kind all_tv_prs = mkTyVarNamePairs (binderVars swizzled_tcbs) @@ -2621,7 +2620,7 @@ -- Invariant: Length of returned TyConBinders + length of excess TyConBinders -- = length of incoming TyConBinders matchUpSigWithDecl sig_tcbs sig_res_kind hs_bndrs thing_inside- = go emptyTCvSubst sig_tcbs hs_bndrs+ = go emptySubst sig_tcbs hs_bndrs where go subst tcbs [] = do { let (subst', tcbs') = substTyConBindersX subst tcbs@@ -2663,16 +2662,16 @@ ; discardResult $ -- See Note [discardResult in kcCheckDeclHeader_sig] unifyKind (Just (NameThing hs_nm)) sig_kind expected_kind } -substTyConBinderX :: TCvSubst -> TyConBinder -> (TCvSubst, TyConBinder)+substTyConBinderX :: Subst -> TyConBinder -> (Subst, TyConBinder) substTyConBinderX subst (Bndr tv vis) = (subst', Bndr tv' vis) where (subst', tv') = substTyVarBndr subst tv -substTyConBindersX :: TCvSubst -> [TyConBinder] -> (TCvSubst, [TyConBinder])+substTyConBindersX :: Subst -> [TyConBinder] -> (Subst, [TyConBinder]) substTyConBindersX = mapAccumL substTyConBinderX -swizzleTcb :: VarEnv Name -> TCvSubst -> TyConBinder -> (TCvSubst, TyConBinder)+swizzleTcb :: VarEnv Name -> Subst -> TyConBinder -> (Subst, TyConBinder) swizzleTcb swizzle_env subst (Bndr tv vis) = (subst', Bndr tv2 vis) where@@ -3698,7 +3697,7 @@ -- Note [Avoid name clashes for associated data types] , not (occ `elem` avoid_occs) ] new_uniqs = uniqsFromSupply uniqs- subst = mkEmptyTCvSubst in_scope+ subst = mkEmptySubst in_scope details = SkolemTv skol_info (pushTcLevel lvl) False -- As always, allocate skolems one level in @@ -3713,7 +3712,7 @@ arg' = substTy subst (scaledThing arg) name = mkInternalName uniq occ loc tv = mkTcTyVar name arg' details- subst' = extendTCvInScope subst tv+ subst' = extendSubstInScope subst tv (uniq:uniqs') = uniqs (occ:occs') = occs @@ -3843,7 +3842,7 @@ tcbVisibilities tc orig_args = go (tyConKind tc) init_subst orig_args where- init_subst = mkEmptyTCvSubst (mkInScopeSet (tyCoVarsOfTypes orig_args))+ init_subst = mkEmptySubst (mkInScopeSet (tyCoVarsOfTypes orig_args)) go _ _ [] = []
compiler/GHC/Tc/Gen/Pat.hs view
@@ -1,4 +1,3 @@- {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE LambdaCase #-} {-# LANGUAGE RankNTypes #-}@@ -38,6 +37,7 @@ import GHC.Tc.Utils.Monad import GHC.Tc.Utils.Instantiate import GHC.Types.Error+import GHC.Types.FieldLabel import GHC.Types.Id import GHC.Types.Var import GHC.Types.Name@@ -71,8 +71,10 @@ import qualified GHC.LanguageExtensions as LangExt import Control.Arrow ( second ) import Control.Monad+import GHC.Data.FastString import qualified Data.List.NonEmpty as NE import GHC.Data.List.SetOps ( getNth )+import Language.Haskell.Syntax.Basic (FieldLabelString(..)) {- ************************************************************************@@ -1239,7 +1241,7 @@ tcConArgs :: ConLike -> [Scaled TcSigmaTypeFRR]- -> TCvSubst -- Instantiating substitution for constructor type+ -> Subst -- Instantiating substitution for constructor type -> Checker (HsConPatDetails GhcRn) (HsConPatDetails GhcTc) tcConArgs con_like arg_tys tenv penv con_args thing_inside = case con_args of PrefixCon type_args arg_pats -> do@@ -1297,7 +1299,7 @@ pun), res) } - find_field_ty :: Name -> FieldLabelString -> TcM (Scaled TcType)+ find_field_ty :: Name -> FastString -> TcM (Scaled TcType) find_field_ty sel lbl = case [ty | (fl, ty) <- field_tys, flSelector fl == sel ] of @@ -1307,7 +1309,7 @@ -- f (R { foo = (a,b) }) = a+b -- If foo isn't one of R's fields, we don't want to crash when -- typechecking the "a+b".- [] -> failWith (badFieldConErr (getName con_like) lbl)+ [] -> failWith (badFieldConErr (getName con_like) (FieldLabelString lbl)) -- The normal case, when the field comes from the right constructor (pat_ty : extras) -> do
compiler/GHC/Tc/Gen/Splice.hs view
@@ -132,6 +132,7 @@ import GHC.Data.Maybe( MaybeErr(..) ) import qualified GHC.Data.EnumSet as EnumSet +import Language.Haskell.Syntax.Basic (FieldLabelString(..)) import qualified Language.Haskell.TH as TH -- THSyntax gives access to internal functions and data types import qualified Language.Haskell.TH.Syntax as TH@@ -877,12 +878,6 @@ tcTopSpliceExpr isTypedSplice tc_action = checkNoErrs $ -- checkNoErrs: must not try to run the thing -- if the type checker fails!- unsetGOptM Opt_DeferTypeErrors $- -- Don't defer type errors. Not only are we- -- going to run this code, but we do an unsafe- -- coerce, so we get a seg-fault if, say we- -- splice a type into a place where an expression- -- is expected (#7276) setStage (Splice isTypedSplice) $ do { -- Typecheck the expression (mb_expr', wanted) <- tryCaptureConstraints tc_action@@ -2768,7 +2763,7 @@ mod = assert (isExternalName name) $ nameModule name pkg_str = unitString (moduleUnit mod) mod_str = moduleNameString (moduleName mod)- occ_str = unpackFS (flLabel fl)+ occ_str = unpackFS (field_label $ flLabel fl) reifySelector :: Id -> TyCon -> TH.Name reifySelector id tc
compiler/GHC/Tc/Instance/Class.hs view
@@ -28,6 +28,7 @@ import GHC.Builtin.Types.Prim import GHC.Builtin.Names +import GHC.Types.FieldLabel import GHC.Types.Name.Reader( lookupGRE_FieldLabel, greMangledName ) import GHC.Types.SafeHaskell import GHC.Types.Name ( Name, pprDefinedAt )@@ -51,6 +52,8 @@ import GHC.Utils.Misc( splitAtList, fstOf3 ) import GHC.Data.FastString +import Language.Haskell.Syntax.Basic (FieldLabelString(..))+ import Data.Maybe {- *******************************************************************@@ -917,7 +920,7 @@ -- use representation tycon (if data family); it has the fields , let r_tc = fstOf3 (tcLookupDataFamInst fam_inst_envs tc args) -- x should be a field of r- , Just fl <- lookupTyConFieldLabel x r_tc+ , Just fl <- lookupTyConFieldLabel (FieldLabelString x) r_tc -- the field selector should be in scope , Just gre <- lookupGRE_FieldLabel rdr_env fl
compiler/GHC/Tc/Instance/FunDeps.hs view
@@ -324,7 +324,7 @@ meta_tvs = [ setVarType tv (substTy subst (varType tv)) | tv <- qtvs- , tv `notElemTCvSubst` subst+ , tv `notElemSubst` subst , tv `elemVarSet` rtys1_tvs ] -- meta_tvs are the quantified type variables -- that have not been substituted out@@ -343,7 +343,7 @@ -- whose kind mentions that kind variable! #6015, #6068 -- (c) no need to include tyvars not in rtys1 where- init_subst = mkEmptyTCvSubst $ mkInScopeSet $+ init_subst = mkEmptySubst $ mkInScopeSet $ mkVarSet qtvs `unionVarSet` tyCoVarsOfTypes ltys2 (ltys1, rtys1) = instFD fd clas_tvs tys_inst (ltys2, rtys2) = instFD fd clas_tvs tys_actual
compiler/GHC/Tc/Module.hs view
@@ -2668,8 +2668,15 @@ tcRnType hsc_env flexi normalise rdr_type = runTcInteractive hsc_env $ setXOptM LangExt.PolyKinds $ -- See Note [Kind-generalise in tcRnType]- do { (HsWC { hswc_ext = wcs, hswc_body = rn_type }, _fvs)- <- rnHsWcType GHCiCtx (mkHsWildCardBndrs rdr_type)+ do { (HsWC { hswc_ext = wcs, hswc_body = rn_sig_type@(L _ (HsSig{sig_bndrs = outer_bndrs, sig_body = body })) }, _fvs)+ -- we are using 'rnHsSigWcType' to bind the unbound type variables+ -- and in combination with 'tcOuterTKBndrs' we are able to+ -- implicitly quantify them as if the user wrote 'forall' by+ -- hand (see #19217). This allows kind check to work in presence+ -- of free type variables :+ -- ghci> :k [a]+ -- [a] :: *+ <- rnHsSigWcType GHCiCtx (mkHsWildCardBndrs $ noLocA (mkHsImplicitSigType rdr_type)) -- The type can have wild cards, but no implicit -- generalisation; e.g. :kind (T _) ; failIfErrsM@@ -2679,14 +2686,14 @@ -- Now kind-check the type -- It can have any rank or kind -- First bring into scope any wildcards- ; traceTc "tcRnType" (vcat [ppr wcs, ppr rn_type])- ; ((ty, kind), wanted)+ ; traceTc "tcRnType" (vcat [ppr wcs, ppr rn_sig_type])+ ; si <- mkSkolemInfo $ SigTypeSkol (GhciCtxt True)+ ; ((_, (ty, kind)), wanted) <- captureTopConstraints $ pushTcLevelM_ $ bindNamedWildCardBinders wcs $ \ wcs' -> do { mapM_ emitNamedTypeHole wcs'- ; tcInferLHsTypeUnsaturated rn_type }-+ ; tcOuterTKBndrs si outer_bndrs $ tcInferLHsTypeUnsaturated body } -- Since all the wanteds are equalities, the returned bindings will be empty ; empty_binds <- simplifyTop wanted ; massertPpr (isEmptyBag empty_binds) (ppr empty_binds)
compiler/GHC/Tc/Solver/Canonical.hs view
@@ -867,7 +867,7 @@ -- TcLclEnv for the implication, and that in turn sets the location -- for the Givens when solving the constraint (#21006) do { skol_info <- mkSkolemInfo QuantCtxtSkol- ; let empty_subst = mkEmptyTCvSubst $ mkInScopeSet $+ ; let empty_subst = mkEmptySubst $ mkInScopeSet $ tyCoVarsOfTypes (pred:theta) `delVarSetList` tvs ; (subst, skol_tvs) <- tcInstSkolTyVarsX skol_info empty_subst tvs ; given_ev_vars <- mapM newEvVar (substTheta subst theta)@@ -1210,7 +1210,7 @@ ; canEqHardFailure ev s1 s2 } else do { traceTcS "Creating implication for polytype equality" $ ppr ev- ; let empty_subst1 = mkEmptyTCvSubst $ mkInScopeSet free_tvs+ ; let empty_subst1 = mkEmptySubst $ mkInScopeSet free_tvs ; skol_info <- mkSkolemInfo (UnifyForAllSkol phi1) ; (subst1, skol_tvs) <- tcInstSkolTyVarsX skol_info empty_subst1 $ binderVars bndrs1@@ -1218,7 +1218,7 @@ ; let phi1' = substTy subst1 phi1 -- Unify the kinds, extend the substitution- go :: [TcTyVar] -> TCvSubst -> [TyVarBinder]+ go :: [TcTyVar] -> Subst -> [TyVarBinder] -> TcS (TcCoercion, Cts) go (skol_tv:skol_tvs) subst (bndr2:bndrs2) = do { let tv2 = binderVar bndr2@@ -1239,7 +1239,7 @@ go _ _ _ = panic "cna_eq_nc_forall" -- case (s:ss) [] - empty_subst2 = mkEmptyTCvSubst (getTCvInScope subst1)+ empty_subst2 = mkEmptySubst (getSubstInScope subst1) ; (lvl, (all_co, wanteds)) <- pushLevelNoWorkList (ppr skol_info) $ go skol_tvs empty_subst2 bndrs2
compiler/GHC/Tc/Solver/Interact.hs view
@@ -1,4 +1,3 @@- {-# OPTIONS_GHC -Wno-incomplete-record-updates #-} {-# OPTIONS_GHC -Wno-incomplete-uni-patterns #-} @@ -1859,19 +1858,19 @@ | otherwise = do { traceTcS "emitFunDepWanteds 2" (ppr (ctl_depth loc) $$ ppr tvs $$ ppr eqs)- ; subst <- instFlexiX emptyTCvSubst tvs -- Takes account of kind substitution+ ; subst <- instFlexiX emptySubst tvs -- Takes account of kind substitution ; mapM_ (do_one_eq loc all_rewriters subst) (reverse eqs) } -- See Note [Reverse order of fundep equations] where all_rewriters = work_rewriters S.<> rewriters do_one_eq loc rewriters subst (Pair ty1 ty2)- = unifyWanted rewriters loc Nominal (Type.substTy subst' ty1) ty2+ = unifyWanted rewriters loc Nominal (substTyUnchecked subst' ty1) ty2 -- ty2 does not mention fd_qtvs, so no need to subst it. -- See GHC.Tc.Instance.Fundeps Note [Improving against instances] -- Wrinkle (1) where- subst' = extendTCvInScopeSet subst (tyCoVarsOfType ty1)+ subst' = extendSubstInScopeSet subst (tyCoVarsOfType ty1) -- The free vars of ty1 aren't just fd_qtvs: ty1 is the result -- of matching with the [W] constraint. So we add its free -- vars to InScopeSet, to satisfy substTy's invariants, even@@ -2082,7 +2081,7 @@ -> (a -> [Type]) -- get LHS of an axiom -> (a -> Type) -- get RHS of an axiom -> (a -> Maybe CoAxBranch) -- Just => apartness check required- -> [( [Type], TCvSubst, [TyVar], Maybe CoAxBranch )]+ -> [( [Type], Subst, [TyVar], Maybe CoAxBranch )] -- Result: -- ( [arguments of a matching axiom] -- , RHS-unifying substitution@@ -2102,7 +2101,7 @@ -- in telescope order e.g. (k:*) (a:k) injImproveEqns :: [Bool]- -> ([Type], TCvSubst, [TyCoVar], Maybe CoAxBranch)+ -> ([Type], Subst, [TyCoVar], Maybe CoAxBranch) -> TcS [TypeEqn] injImproveEqns inj_args (ax_args, subst, unsubstTvs, cabr) = do { subst <- instFlexiX subst unsubstTvs@@ -2577,4 +2576,3 @@ Test case: typecheck/should_compile/T20582. -}-
compiler/GHC/Tc/Solver/Monad.hs view
@@ -1614,11 +1614,11 @@ cloneMetaTyVar :: TcTyVar -> TcS TcTyVar cloneMetaTyVar tv = wrapTcS (TcM.cloneMetaTyVar tv) -instFlexiX :: TCvSubst -> [TKVar] -> TcS TCvSubst+instFlexiX :: Subst -> [TKVar] -> TcS Subst instFlexiX subst tvs = wrapTcS (foldlM instFlexiHelper subst tvs) -instFlexiHelper :: TCvSubst -> TKVar -> TcM TCvSubst+instFlexiHelper :: Subst -> TKVar -> TcM Subst -- Makes fresh tyvar, extends the substitution, and the in-scope set instFlexiHelper subst tv = do { uniq <- TcM.newUnique@@ -1637,7 +1637,7 @@ matchGlobalInst dflags short_cut cls tys = wrapTcS (TcM.matchGlobalInst dflags short_cut cls tys) -tcInstSkolTyVarsX :: SkolemInfo -> TCvSubst -> [TyVar] -> TcS (TCvSubst, [TcTyVar])+tcInstSkolTyVarsX :: SkolemInfo -> Subst -> [TyVar] -> TcS (Subst, [TcTyVar]) tcInstSkolTyVarsX skol_info subst tvs = wrapTcS $ TcM.tcInstSkolTyVarsX skol_info subst tvs -- Creating and setting evidence variables and CtFlavors
compiler/GHC/Tc/TyCl.hs view
@@ -98,6 +98,8 @@ import GHC.Utils.Constants (debugIsOn) import GHC.Utils.Misc +import Language.Haskell.Syntax.Basic (FieldLabelString(..))+ import Control.Monad import Data.Functor.Identity import Data.List ( partition)@@ -2585,7 +2587,7 @@ ]) ; let subst = case traverse getTyVar_maybe pats of Just cpt_tvs -> zipTvSubst cpt_tvs (mkTyVarTys fam_tvs)- Nothing -> emptyTCvSubst+ Nothing -> emptySubst -- The Nothing case can only be reached in invalid -- associated type family defaults. In such cases, we -- simply create an empty substitution and let GHC fall@@ -3798,7 +3800,7 @@ [InvisTVBinder], -- The constructor's rejigged, user-written -- type variables [EqSpec], -- Equality predicates- TCvSubst) -- Substitution to apply to argument types+ Subst) -- Substitution to apply to argument types -- We don't check that the TyCon given in the ResTy is -- the same as the parent tycon, because checkValidDataCon will do it -- NB: All arguments may potentially be knot-tied@@ -3847,7 +3849,7 @@ -- albeit bogus, relying on checkValidDataCon to check the -- bad-result-type error before seeing that the other fields look odd -- See Note [rejigConRes]- = (tc_tvs, dc_tvs `minusList` tc_tvs, dc_tvbndrs, [], emptyTCvSubst)+ = (tc_tvs, dc_tvs `minusList` tc_tvs, dc_tvbndrs, [], emptySubst) where dc_tvs = binderVars dc_tvbndrs tc_tvs = binderVars tc_tvbndrs@@ -3995,28 +3997,28 @@ -- See Note [mkGADTVars]. mkGADTVars :: [TyVar] -- ^ The tycon vars -> [TyVar] -- ^ The datacon vars- -> TCvSubst -- ^ The matching between the template result type+ -> Subst -- ^ The matching between the template result type -- and the actual result type -> ( [TyVar] , [EqSpec]- , TCvSubst ) -- ^ The univ. variables, the GADT equalities,+ , Subst ) -- ^ The univ. variables, the GADT equalities, -- and a subst to apply to the GADT equalities -- and existentials. mkGADTVars tmpl_tvs dc_tvs subst = choose [] [] empty_subst empty_subst tmpl_tvs where in_scope = mkInScopeSet (mkVarSet tmpl_tvs `unionVarSet` mkVarSet dc_tvs)- `unionInScope` getTCvInScope subst- empty_subst = mkEmptyTCvSubst in_scope+ `unionInScope` getSubstInScope subst+ empty_subst = mkEmptySubst in_scope choose :: [TyVar] -- accumulator of univ tvs, reversed -> [EqSpec] -- accumulator of GADT equalities, reversed- -> TCvSubst -- template substitution- -> TCvSubst -- res. substitution+ -> Subst -- template substitution+ -> Subst -- res. substitution -> [TyVar] -- template tvs (the univ tvs passed in) -> ( [TyVar] -- the univ_tvs , [EqSpec] -- GADT equalities- , TCvSubst ) -- a substitution to fix kinds in ex_tvs+ , Subst ) -- a substitution to fix kinds in ex_tvs choose univs eqs _t_sub r_sub [] = (reverse univs, reverse eqs, r_sub)@@ -4270,7 +4272,7 @@ -- The order of these equivalence classes might conceivably (non-deterministically) -- depend on the result of this comparison, but that just affects the order in which -- fields are checked for compatibility. It will not affect the compiled binary.- cmp_fld (f1,_) (f2,_) = flLabel f1 `uniqCompareFS` flLabel f2+ cmp_fld (f1,_) (f2,_) = field_label (flLabel f1) `uniqCompareFS` field_label (flLabel f2) get_fields con = dataConFieldLabels con `zip` repeat con -- dataConFieldLabels may return the empty list, which is fine @@ -4438,6 +4440,12 @@ | HsSrcBang _ _ SrcStrict <- bang , isUnliftedType orig_arg_ty = addDiagnosticTc $ TcRnBangOnUnliftedType orig_arg_ty++ -- Warn about a ~ on an unlifted type (#21951)+ -- e.g. data T = MkT ~Int#+ | HsSrcBang _ _ SrcLazy <- bang+ , isUnliftedType orig_arg_ty+ = addDiagnosticTc $ TcRnLazyBangOnUnliftedType orig_arg_ty | HsSrcBang _ want_unpack _ <- bang , isSrcUnpacked want_unpack
compiler/GHC/Tc/TyCl/Class.hs view
@@ -18,7 +18,6 @@ , tcClassMinimalDef , HsSigFun , mkHsSigFun- , badMethodErr , instDeclCtxt1 , instDeclCtxt2 , instDeclCtxt3@@ -70,6 +69,7 @@ import Control.Monad import Data.List ( mapAccumL, partition )+import qualified Data.List.NonEmpty as NE {- Dictionary handling@@ -112,10 +112,6 @@ ************************************************************************ -} -illegalHsigDefaultMethod :: Name -> TcRnMessage-illegalHsigDefaultMethod n = TcRnUnknownMessage $ mkPlainError noHints $- text "Illegal default method(s) in class definition of" <+> ppr n <+> text "in hsig file"- tcClassSigs :: Name -- Name of the class -> [LSig GhcRn] -> LHsBinds GhcRn@@ -130,7 +126,7 @@ ; op_info <- concatMapM (addLocM (tc_sig gen_dm_env)) vanilla_sigs ; let op_names = mkNameSet [ n | (n,_,_) <- op_info ]- ; sequence_ [ failWithTc (badMethodErr clas n)+ ; sequence_ [ failWithTc (TcRnBadMethodErr clas n) | n <- dm_bind_names, not (n `elemNameSet` op_names) ] -- Value binding for non class-method (ie no TypeSig) @@ -141,11 +137,12 @@ -- (Generic signatures without value bindings indicate -- that a default of this form is expected to be -- provided.)- when (not (null def_methods)) $- failWithTc (illegalHsigDefaultMethod clas)+ case bagToList def_methods of+ [] -> return ()+ meth : meths -> failWithTc (TcRnIllegalHsigDefaultMethods clas (meth NE.:| meths)) else -- Error for each generic signature without value binding- sequence_ [ failWithTc (badGenericMethod clas n)+ sequence_ [ failWithTc (TcRnBadGenericMethod clas n) | (n,_) <- gen_dm_prs, not (n `elem` dm_bind_names) ] ; traceTc "tcClassSigs 2" (ppr clas)@@ -236,7 +233,7 @@ tcDefMeth _ _ _ _ _ prag_fn (sel_id, Nothing) = do { -- No default method- mapM_ (addLocMA (badDmPrag sel_id))+ mapM_ (addLocMA (badDmPrag sel_id )) (lookupPragEnv prag_fn (idName sel_id)) ; return emptyBag } @@ -262,9 +259,8 @@ ; spec_prags <- discardConstraints $ tcSpecPrags global_dm_id prags- ; let dia = TcRnUnknownMessage $- mkPlainDiagnostic WarningWithoutFlag noHints $- (text "Ignoring SPECIALISE pragmas on default method" <+> quotes (ppr sel_name))+ ; let dia = TcRnIgnoreSpecialisePragmaOnDefMethod sel_name+ ; diagnosticTc (not (null spec_prags)) dia ; let hs_ty = hs_sig_fn sel_name@@ -340,7 +336,7 @@ -- since you can't write a default implementation. when (tcg_src tcg_env /= HsigFile) $ whenIsJust (isUnsatisfied (mindef `impliesAtom`) defMindef) $- (\bf -> addDiagnosticTc (warningMinimalDefIncomplete bf))+ (\bf -> addDiagnosticTc (TcRnWarningMinimalDefIncomplete bf)) return mindef where -- By default require all methods without a default implementation@@ -441,18 +437,6 @@ ************************************************************************ -} -badMethodErr :: Outputable a => a -> Name -> TcRnMessage-badMethodErr clas op- = TcRnUnknownMessage $ mkPlainError noHints $- hsep [text "Class", quotes (ppr clas),- text "does not have a method", quotes (ppr op)]--badGenericMethod :: Outputable a => a -> Name -> TcRnMessage-badGenericMethod clas op- = TcRnUnknownMessage $ mkPlainError noHints $- hsep [text "Class", quotes (ppr clas),- text "has a generic-default signature without a binding", quotes (ppr op)]- {- badGenericInstanceType :: LHsBinds Name -> SDoc badGenericInstanceType binds@@ -472,19 +456,10 @@ where ppr_inst_ty (_,inst) = ppr (simpleInstInfoTy inst) -}+ badDmPrag :: TcId -> Sig GhcRn -> TcM () badDmPrag sel_id prag- = addErrTc (TcRnUnknownMessage $ mkPlainError noHints $- text "The" <+> hsSigDoc prag <+> text "for default method"- <+> quotes (ppr sel_id)- <+> text "lacks an accompanying binding")--warningMinimalDefIncomplete :: ClassMinimalDef -> TcRnMessage-warningMinimalDefIncomplete mindef- = TcRnUnknownMessage $ mkPlainDiagnostic WarningWithoutFlag noHints $- vcat [ text "The MINIMAL pragma does not require:"- , nest 2 (pprBooleanFormulaNice mindef)- , text "but there is no default implementation." ]+ = addErrTc (TcRnDefaultMethodForPragmaLacksBinding sel_id prag) instDeclCtxt1 :: LHsSigType GhcRn -> SDoc instDeclCtxt1 hs_inst_ty@@ -505,7 +480,7 @@ 2 (quotes doc) tcATDefault :: SrcSpan- -> TCvSubst+ -> Subst -> NameSet -> ClassATItem -> TcM [FamInst]@@ -563,10 +538,6 @@ -- hs-boot and signatures never need to provide complete "definitions" -- of any sort, as they aren't really defining anything, but just -- constraining items which are defined elsewhere.- ; let dia = TcRnUnknownMessage $- mkPlainDiagnostic (WarningWithFlag Opt_WarnMissingMethods) noHints $- (text "No explicit" <+> text "associated type"- <+> text "or default declaration for"- <+> quotes (ppr name))+ ; let dia = TcRnNoExplicitAssocTypeOrDefaultDeclaration name ; diagnosticTc (warn && hsc_src == HsSrcFile) dia }
compiler/GHC/Tc/TyCl/Instance.hs view
@@ -27,8 +27,8 @@ import GHC.Tc.TyCl import GHC.Tc.TyCl.Utils ( addTyConsToGblEnv ) import GHC.Tc.TyCl.Class ( tcClassDecl2, tcATDefault,- HsSigFun, mkHsSigFun, badMethodErr,- findMethodBind, instantiateMethod )+ HsSigFun, mkHsSigFun, findMethodBind,+ instantiateMethod ) import GHC.Tc.Solver( pushLevelAndSolveEqualitiesX, reportUnsolvedEqualities ) import GHC.Tc.Gen.Sig import GHC.Tc.Utils.Monad@@ -1800,7 +1800,7 @@ -- Check if any method bindings do not correspond to the class. -- See Note [Mismatched class methods and associated type families]. checkMethBindMembership- = mapM_ (addErrTc . badMethodErr clas) mismatched_meths+ = mapM_ (addErrTc . TcRnBadMethodErr (className clas)) mismatched_meths where bind_nms = map unLoc $ collectMethodBinders binds cls_meth_nms = map (idName . fst) op_items
compiler/GHC/Tc/TyCl/PatSyn.hs view
@@ -56,7 +56,6 @@ import GHC.Tc.Types.Origin import GHC.Tc.TyCl.Build import GHC.Types.Var.Set-import GHC.Types.Id.Make import GHC.Tc.TyCl.Utils import GHC.Core.ConLike import GHC.Types.FieldLabel@@ -436,7 +435,7 @@ -- expected type. Even though the tyvars in the type are -- already skolems, this step changes their TcLevels, -- avoiding level-check errors when unifying.- ; (skol_subst0, skol_univ_bndrs) <- skolemiseTvBndrsX skol_info emptyTCvSubst univ_bndrs+ ; (skol_subst0, skol_univ_bndrs) <- skolemiseTvBndrsX skol_info emptySubst univ_bndrs ; (skol_subst, skol_ex_bndrs) <- skolemiseTvBndrsX skol_info skol_subst0 ex_bndrs ; let skol_univ_tvs = binderVars skol_univ_bndrs skol_ex_tvs = binderVars skol_ex_bndrs@@ -457,7 +456,7 @@ tcExtendNameTyVarEnv univ_tv_prs $ tcCheckPat PatSyn lpat (unrestricted skol_pat_ty) $ do { let in_scope = mkInScopeSetList skol_univ_tvs- empty_subst = mkEmptyTCvSubst in_scope+ empty_subst = mkEmptySubst in_scope ; (inst_subst, ex_tvs') <- mapAccumLM newMetaTyVarX empty_subst skol_ex_tvs -- newMetaTyVarX: see the "Existential type variables" -- part of Note [Checking against a pattern signature]@@ -494,7 +493,7 @@ (args', skol_arg_tys) skol_pat_ty rec_fields } where- tc_arg :: TCvSubst -> Name -> Type -> TcM (LHsExpr GhcTc)+ tc_arg :: Subst -> Name -> Type -> TcM (LHsExpr GhcTc) -- Look up the variable actually bound by lpat -- and check that it has the expected type tc_arg subst arg_name arg_ty@@ -515,8 +514,8 @@ -- See Note [Pattern synonyms and higher rank types] ; return (mkLHsWrap wrap $ nlHsVar arg_id) } -skolemiseTvBndrsX :: SkolemInfo -> TCvSubst -> [VarBndr TyVar flag]- -> TcM (TCvSubst, [VarBndr TcTyVar flag])+skolemiseTvBndrsX :: SkolemInfo -> Subst -> [VarBndr TyVar flag]+ -> TcM (Subst, [VarBndr TcTyVar flag]) -- Make new TcTyVars, all skolems with levels, but do not clone -- The level is one level deeper than the current level -- See Note [Skolemising when checking a pattern synonym]@@ -525,8 +524,8 @@ ; let pushed_lvl = pushTcLevel tc_lvl details = SkolemTv skol_info pushed_lvl False - mk_skol_tv_x :: TCvSubst -> VarBndr TyVar flag- -> (TCvSubst, VarBndr TcTyVar flag)+ mk_skol_tv_x :: Subst -> VarBndr TyVar flag+ -> (Subst, VarBndr TcTyVar flag) mk_skol_tv_x subst (Bndr tv flag) = (subst', Bndr new_tv flag) where@@ -796,8 +795,8 @@ res_ty = mkTyVarTy res_tv is_unlifted = null args && null prov_dicts (cont_args, cont_arg_tys)- | is_unlifted = ([nlHsVar voidPrimId], [unboxedUnitTy])- | otherwise = (args, arg_tys)+ | is_unlifted = ([nlHsDataCon unboxedUnitDataCon], [unboxedUnitTy])+ | otherwise = (args, arg_tys) cont_ty = mkInfSigmaTy ex_tvs prov_theta $ mkVisFunTysMany cont_arg_tys res_ty @@ -818,7 +817,7 @@ inst_wrap = mkWpEvApps prov_dicts <.> mkWpTyApps ex_tys cont' = foldl' nlHsApp (mkLHsWrap inst_wrap (nlHsVar cont)) cont_args - fail' = nlHsApps fail [nlHsVar voidPrimId]+ fail' = nlHsApps fail [nlHsDataCon unboxedUnitDataCon] args = map nlVarPat [scrutinee, cont, fail] lwpat = noLocA $ WildPat pat_ty
compiler/GHC/Tc/TyCl/Utils.hs view
@@ -81,6 +81,8 @@ import GHC.Types.TyThing import qualified GHC.LanguageExtensions as LangExt +import Language.Haskell.Syntax.Basic (FieldLabelString(..))+ import Control.Monad {-@@ -935,7 +937,7 @@ { hfbAnn = noAnn , hfbLHS = L locc (FieldOcc sel_name- (L locn $ mkVarUnqual lbl))+ (L locn $ mkVarUnqual (field_label lbl))) , hfbRHS = L loc' (VarPat noExtField (L locn field_var)) , hfbPun = False })@@ -982,7 +984,7 @@ inst_tys = substTyVars eq_subst univ_tvs unit_rhs = mkLHsTupleExpr [] noExtField- msg_lit = HsStringPrim NoSourceText (bytesFS lbl)+ msg_lit = HsStringPrim NoSourceText (bytesFS (field_label lbl)) {- Note [Polymorphic selectors]
compiler/GHC/Tc/Utils/Instantiate.hs view
@@ -1,4 +1,3 @@- {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE DisambiguateRecordFields #-} @@ -179,7 +178,7 @@ topSkolemise skolem_info ty = go init_subst idHsWrapper [] [] ty where- init_subst = mkEmptyTCvSubst (mkInScopeSet (tyCoVarsOfType ty))+ init_subst = mkEmptySubst (mkInScopeSet (tyCoVarsOfType ty)) -- Why recursive? See Note [Skolemisation] go subst wrap tv_prs ev_vars ty@@ -241,16 +240,16 @@ where free_tvs = tyCoVarsOfType body_ty `unionVarSet` tyCoVarsOfTypes theta in_scope = mkInScopeSet (free_tvs `delVarSetList` tvs)- empty_subst = mkEmptyTCvSubst in_scope+ empty_subst = mkEmptySubst in_scope -instTyVarsWith :: CtOrigin -> [TyVar] -> [TcType] -> TcM TCvSubst+instTyVarsWith :: CtOrigin -> [TyVar] -> [TcType] -> TcM Subst -- Use this when you want to instantiate (forall a b c. ty) with -- types [ta, tb, tc], but when the kinds of 'a' and 'ta' might -- not yet match (perhaps because there are unsolved constraints; #14154) -- If they don't match, emit a kind-equality to promise that they will -- eventually do so, and thus make a kind-homongeneous substitution. instTyVarsWith orig tvs tys- = go emptyTCvSubst tvs tys+ = go emptySubst tvs tys where go subst [] [] = return subst@@ -335,11 +334,11 @@ where dfun_ty = idType dfun_id (dfun_tvs, dfun_theta, _) = tcSplitSigmaTy dfun_ty- empty_subst = mkEmptyTCvSubst (mkInScopeSet (tyCoVarsOfType dfun_ty))+ empty_subst = mkEmptySubst (mkInScopeSet (tyCoVarsOfType dfun_ty)) -- With quantified constraints, the -- type of a dfun may not be closed - go :: TCvSubst -> [TyVar] -> [DFunInstType] -> TcM (TCvSubst, [TcType])+ go :: Subst -> [TyVar] -> [DFunInstType] -> TcM (Subst, [TcType]) go subst [] [] = return (subst, []) go subst (tv:tvs) (Just ty : mb_tys) = do { (subst', tys) <- go (extendTvSubstAndInScope subst tv ty)@@ -382,7 +381,7 @@ tcInstInvisibleTyBindersN n ty = go n empty_subst ty where- empty_subst = mkEmptyTCvSubst (mkInScopeSet (tyCoVarsOfType ty))+ empty_subst = mkEmptySubst (mkInScopeSet (tyCoVarsOfType ty)) go n subst kind | n > 0@@ -395,7 +394,7 @@ = return ([], substTy subst kind) -- | Used only in *types*-tcInstInvisibleTyBinder :: TCvSubst -> TyBinder -> TcM (TCvSubst, TcType)+tcInstInvisibleTyBinder :: Subst -> TyBinder -> TcM (Subst, TcType) tcInstInvisibleTyBinder subst (Named (Bndr tv _)) = do { (subst', tv') <- newMetaTyVarX subst tv ; return (subst', mkTyVarTy tv') }@@ -458,7 +457,7 @@ * * ********************************************************************* -} -tcInstType :: ([TyVar] -> TcM (TCvSubst, [TcTyVar]))+tcInstType :: ([TyVar] -> TcM (Subst, [TcTyVar])) -- ^ How to instantiate the type variables -> Id -- ^ Type to instantiate -> TcM ([(Name, TcTyVar)], TcThetaType, TcType) -- ^ Result@@ -470,7 +469,7 @@ | otherwise = do { (subst, tyvars') <- inst_tyvars tyvars ; let tv_prs = map tyVarName tyvars `zip` tyvars'- subst' = extendTCvInScopeSet subst (tyCoVarsOfType rho)+ subst' = extendSubstInScopeSet subst (tyCoVarsOfType rho) ; return (tv_prs, substTheta subst' theta, substTy subst' tau) } where (tyvars, rho) = tcSplitForAllInvisTyVars (idType id)@@ -484,16 +483,16 @@ -- (?x :: Int) => Int -> Int = return ([], theta, tau) | otherwise- = do { (subst, tyvars') <- mapAccumLM inst_invis_bndr emptyTCvSubst tyvars+ = do { (subst, tyvars') <- mapAccumLM inst_invis_bndr emptySubst tyvars ; let tv_prs = map (tyVarName . binderVar) tyvars `zip` tyvars'- subst' = extendTCvInScopeSet subst (tyCoVarsOfType rho)+ subst' = extendSubstInScopeSet subst (tyCoVarsOfType rho) ; return (tv_prs, substTheta subst' theta, substTy subst' tau) } where (tyvars, rho) = splitForAllInvisTVBinders poly_ty (theta, tau) = tcSplitPhiTy rho - inst_invis_bndr :: TCvSubst -> InvisTVBinder- -> TcM (TCvSubst, InvisTVBinder)+ inst_invis_bndr :: Subst -> InvisTVBinder+ -> TcM (Subst, InvisTVBinder) inst_invis_bndr subst (Bndr tv spec) = do { (subst', tv') <- newMetaTyVarTyVarX subst tv ; return (subst', Bndr tv' spec) }@@ -506,14 +505,14 @@ = do { (tv_prs, theta, tau) <- tcInstType (tcInstSuperSkolTyVars skol_info) dfun ; return (map snd tv_prs, theta, tau) } -tcSuperSkolTyVars :: TcLevel -> SkolemInfo -> [TyVar] -> (TCvSubst, [TcTyVar])+tcSuperSkolTyVars :: TcLevel -> SkolemInfo -> [TyVar] -> (Subst, [TcTyVar]) -- Make skolem constants, but do *not* give them new names, as above -- As always, allocate them one level in -- Moreover, make them "super skolems"; see GHC.Core.InstEnv -- Note [Binding when looking up instances] -- See Note [Kind substitution when instantiating] -- Precondition: tyvars should be ordered by scoping-tcSuperSkolTyVars tc_lvl skol_info = mapAccumL do_one emptyTCvSubst+tcSuperSkolTyVars tc_lvl skol_info = mapAccumL do_one emptySubst where details = SkolemTv skol_info (pushTcLevel tc_lvl) True -- The "super" bit@@ -525,29 +524,29 @@ -- | Given a list of @['TyVar']@, skolemize the type variables, -- returning a substitution mapping the original tyvars to the -- skolems, and the list of newly bound skolems.-tcInstSkolTyVars :: SkolemInfo -> [TyVar] -> TcM (TCvSubst, [TcTyVar])+tcInstSkolTyVars :: SkolemInfo -> [TyVar] -> TcM (Subst, [TcTyVar]) -- See Note [Skolemising type variables]-tcInstSkolTyVars skol_info = tcInstSkolTyVarsX skol_info emptyTCvSubst+tcInstSkolTyVars skol_info = tcInstSkolTyVarsX skol_info emptySubst -tcInstSkolTyVarsX :: SkolemInfo -> TCvSubst -> [TyVar] -> TcM (TCvSubst, [TcTyVar])+tcInstSkolTyVarsX :: SkolemInfo -> Subst -> [TyVar] -> TcM (Subst, [TcTyVar]) -- See Note [Skolemising type variables] tcInstSkolTyVarsX skol_info = tcInstSkolTyVarsPushLevel skol_info False -tcInstSuperSkolTyVars :: SkolemInfo -> [TyVar] -> TcM (TCvSubst, [TcTyVar])+tcInstSuperSkolTyVars :: SkolemInfo -> [TyVar] -> TcM (Subst, [TcTyVar]) -- See Note [Skolemising type variables] -- This version freshens the names and creates "super skolems"; -- see comments around superSkolemTv.-tcInstSuperSkolTyVars skol_info = tcInstSuperSkolTyVarsX skol_info emptyTCvSubst+tcInstSuperSkolTyVars skol_info = tcInstSuperSkolTyVarsX skol_info emptySubst -tcInstSuperSkolTyVarsX :: SkolemInfo -> TCvSubst -> [TyVar] -> TcM (TCvSubst, [TcTyVar])+tcInstSuperSkolTyVarsX :: SkolemInfo -> Subst -> [TyVar] -> TcM (Subst, [TcTyVar]) -- See Note [Skolemising type variables] -- This version freshens the names and creates "super skolems"; -- see comments around superSkolemTv. tcInstSuperSkolTyVarsX skol_info subst = tcInstSkolTyVarsPushLevel skol_info True subst tcInstSkolTyVarsPushLevel :: SkolemInfo -> Bool -- True <=> make "super skolem"- -> TCvSubst -> [TyVar]- -> TcM (TCvSubst, [TcTyVar])+ -> Subst -> [TyVar]+ -> TcM (Subst, [TcTyVar]) -- Skolemise one level deeper, hence pushTcLevel -- See Note [Skolemising type variables] tcInstSkolTyVarsPushLevel skol_info overlappable subst tvs@@ -557,8 +556,8 @@ ; tcInstSkolTyVarsAt skol_info pushed_lvl overlappable subst tvs } tcInstSkolTyVarsAt :: SkolemInfo -> TcLevel -> Bool- -> TCvSubst -> [TyVar]- -> TcM (TCvSubst, [TcTyVar])+ -> Subst -> [TyVar]+ -> TcM (Subst, [TcTyVar]) tcInstSkolTyVarsAt skol_info lvl overlappable subst tvs = freshenTyCoVarsX new_skol_tv subst tvs where@@ -575,12 +574,12 @@ ; skol_info <- mkSkolemInfo skol_info ; let details = SkolemTv skol_info lvl False mk_skol_tv name kind = return (mkTcTyVar name kind details) -- No freshening- ; (subst, tvs') <- instantiateTyVarsX mk_skol_tv emptyTCvSubst tvs+ ; (subst, tvs') <- instantiateTyVarsX mk_skol_tv emptySubst tvs ; return (tvs', substTy subst body_ty) } instantiateTyVarsX :: (Name -> Kind -> TcM TcTyVar)- -> TCvSubst -> [TyVar]- -> TcM (TCvSubst, [TcTyVar])+ -> Subst -> [TyVar]+ -> TcM (Subst, [TcTyVar]) -- Instantiate each type variable in turn with the specified function instantiateTyVarsX mk_tv subst tvs = case tvs of@@ -592,25 +591,25 @@ ; return (subst', tv':tvs') } -------------------freshenTyVarBndrs :: [TyVar] -> TcM (TCvSubst, [TyVar])+freshenTyVarBndrs :: [TyVar] -> TcM (Subst, [TyVar]) -- ^ Give fresh uniques to a bunch of TyVars, but they stay -- as TyVars, rather than becoming TcTyVars -- Used in 'GHC.Tc.Instance.Family.newFamInst', and 'GHC.Tc.Utils.Instantiate.newClsInst' freshenTyVarBndrs = freshenTyCoVars mkTyVar -freshenCoVarBndrsX :: TCvSubst -> [CoVar] -> TcM (TCvSubst, [CoVar])+freshenCoVarBndrsX :: Subst -> [CoVar] -> TcM (Subst, [CoVar]) -- ^ Give fresh uniques to a bunch of CoVars -- Used in "GHC.Tc.Instance.Family.newFamInst" freshenCoVarBndrsX subst = freshenTyCoVarsX mkCoVar subst ------------------ freshenTyCoVars :: (Name -> Kind -> TyCoVar)- -> [TyVar] -> TcM (TCvSubst, [TyCoVar])-freshenTyCoVars mk_tcv = freshenTyCoVarsX mk_tcv emptyTCvSubst+ -> [TyVar] -> TcM (Subst, [TyCoVar])+freshenTyCoVars mk_tcv = freshenTyCoVarsX mk_tcv emptySubst freshenTyCoVarsX :: (Name -> Kind -> TyCoVar)- -> TCvSubst -> [TyCoVar]- -> TcM (TCvSubst, [TyCoVar])+ -> Subst -> [TyCoVar]+ -> TcM (Subst, [TyCoVar]) -- This a complete freshening operation: -- the skolems have a fresh unique, and a location from the monad -- See Note [Skolemising type variables]
compiler/GHC/Tc/Utils/TcMType.hs view
@@ -1,4 +1,3 @@- {-# LANGUAGE MultiWayIf #-} {-# LANGUAGE TupleSections #-} @@ -1072,35 +1071,35 @@ ; let rr = mkTyConApp boxedRepDataConTyCon [lev] ; return (mkTYPEapp rr) } -newMetaTyVars :: [TyVar] -> TcM (TCvSubst, [TcTyVar])+newMetaTyVars :: [TyVar] -> TcM (Subst, [TcTyVar]) -- Instantiate with META type variables -- Note that this works for a sequence of kind, type, and coercion variables -- variables. Eg [ (k:*), (a:k->k) ] -- Gives [ (k7:*), (a8:k7->k7) ]-newMetaTyVars = newMetaTyVarsX emptyTCvSubst- -- emptyTCvSubst has an empty in-scope set, but that's fine here+newMetaTyVars = newMetaTyVarsX emptySubst+ -- emptySubst has an empty in-scope set, but that's fine here -- Since the tyvars are freshly made, they cannot possibly be -- captured by any existing for-alls. -newMetaTyVarsX :: TCvSubst -> [TyVar] -> TcM (TCvSubst, [TcTyVar])+newMetaTyVarsX :: Subst -> [TyVar] -> TcM (Subst, [TcTyVar]) -- Just like newMetaTyVars, but start with an existing substitution. newMetaTyVarsX subst = mapAccumLM newMetaTyVarX subst -newMetaTyVarX :: TCvSubst -> TyVar -> TcM (TCvSubst, TcTyVar)+newMetaTyVarX :: Subst -> TyVar -> TcM (Subst, TcTyVar) -- Make a new unification variable tyvar whose Name and Kind come from -- an existing TyVar. We substitute kind variables in the kind. newMetaTyVarX = new_meta_tv_x TauTv -newMetaTyVarTyVarX :: TCvSubst -> TyVar -> TcM (TCvSubst, TcTyVar)+newMetaTyVarTyVarX :: Subst -> TyVar -> TcM (Subst, TcTyVar) -- Just like newMetaTyVarX, but make a TyVarTv newMetaTyVarTyVarX = new_meta_tv_x TyVarTv -newWildCardX :: TCvSubst -> TyVar -> TcM (TCvSubst, TcTyVar)+newWildCardX :: Subst -> TyVar -> TcM (Subst, TcTyVar) newWildCardX subst tv = do { new_tv <- newAnonMetaTyVar TauTv (substTy subst (tyVarKind tv)) ; return (extendTvSubstWithClone subst tv new_tv, new_tv) } -new_meta_tv_x :: MetaInfo -> TCvSubst -> TyVar -> TcM (TCvSubst, TcTyVar)+new_meta_tv_x :: MetaInfo -> Subst -> TyVar -> TcM (Subst, TcTyVar) new_meta_tv_x info subst tv = do { new_tv <- cloneAnonMetaTyVar info tv substd_kind ; let subst1 = extendTvSubstWithClone subst tv new_tv
compiler/GHC/Tc/Utils/Unify.hs view
@@ -1370,7 +1370,7 @@ deeplySkolemise skol_info ty = go init_subst ty where- init_subst = mkEmptyTCvSubst (mkInScopeSet (tyCoVarsOfType ty))+ init_subst = mkEmptySubst (mkInScopeSet (tyCoVarsOfType ty)) go subst ty | Just (arg_tys, tvs, theta, ty') <- tcDeepSplitSigmaTy_maybe ty@@ -1397,7 +1397,7 @@ deeplyInstantiate orig ty = go init_subst ty where- init_subst = mkEmptyTCvSubst (mkInScopeSet (tyCoVarsOfType ty))+ init_subst = mkEmptySubst (mkInScopeSet (tyCoVarsOfType ty)) go subst ty | Just (arg_tys, tvs, theta, rho) <- tcDeepSplitSigmaTy_maybe ty
compiler/GHC/Tc/Validity.hs view
@@ -1,4 +1,3 @@- {-# LANGUAGE DerivingStrategies #-} {-# OPTIONS_GHC -Wno-incomplete-record-updates #-}@@ -73,6 +72,8 @@ import GHC.Builtin.Uniques ( mkAlphaTyVarUnique ) import qualified GHC.LanguageExtensions as LangExt +import Language.Haskell.Syntax.Basic (FieldLabelString(..))+ import Control.Monad import Data.Foldable import Data.Function@@ -1582,7 +1583,7 @@ -> whoops (text "Record data type may not be a data family") | otherwise -> case isStrLitTy x_ty of Just lbl- | isJust (lookupTyConFieldLabel lbl tc)+ | isJust (lookupTyConFieldLabel (FieldLabelString lbl) tc) -> whoops (ppr tc <+> text "already has a field" <+> quotes (ppr lbl)) | otherwise -> return ()@@ -2272,7 +2273,7 @@ -- For check_match, bind_me, see -- Note [Matching in the consistent-instantiation check] check_match :: [(Type,Type,ArgFlag)] -> TcM ()- check_match triples = go emptyTCvSubst emptyTCvSubst triples+ check_match triples = go emptySubst emptySubst triples go _ _ [] = return () go lr_subst rl_subst ((ty1,ty2,vis):triples)
compiler/GHC/ThToHs.hs view
@@ -55,6 +55,8 @@ import GHC.Utils.Outputable as Outputable import GHC.Utils.Panic +import Language.Haskell.Syntax.Basic (FieldLabelString(..))+ import qualified Data.ByteString as BS import Control.Monad( unless, ap ) import Control.Applicative( (<|>) )@@ -1106,8 +1108,10 @@ cvt (LabelE s) = return $ HsOverLabel noComments (fsLit s) cvt (ImplicitParamVarE n) = do { n' <- ipName n; return $ HsIPVar noComments n' } cvt (GetFieldE exp f) = do { e' <- cvtl exp- ; return $ HsGetField noComments e' (L noSrcSpanA (DotFieldOcc noAnn (L noSrcSpanA (fsLit f)))) }- cvt (ProjectionE xs) = return $ HsProjection noAnn $ fmap (L noSrcSpanA . DotFieldOcc noAnn . L noSrcSpanA . fsLit) xs+ ; return $ HsGetField noComments e'+ (L noSrcSpanA (DotFieldOcc noAnn (L noSrcSpanA (FieldLabelString (fsLit f))))) }+ cvt (ProjectionE xs) = return $ HsProjection noAnn $ fmap+ (L noSrcSpanA . DotFieldOcc noAnn . L noSrcSpanA . FieldLabelString . fsLit) xs {- | #16895 Ensure an infix expression's operator is a variable/constructor. Consider this example:
ghc-lib.cabal view
@@ -1,7 +1,7 @@ cabal-version: 2.0 build-type: Simple name: ghc-lib-version: 0.20220801+version: 0.20220901 license: BSD3 license-file: LICENSE category: Development@@ -65,7 +65,7 @@ else build-depends: Win32 build-depends:- base >= 4.15 && < 4.18,+ base > 4.16 && < 4.18, ghc-prim > 0.2 && < 0.10, bytestring >= 0.10 && < 0.12, time >= 1.4 && < 1.13,@@ -80,10 +80,10 @@ pretty == 1.1.*, transformers == 0.5.*, process >= 1 && < 1.7,+ stm, rts, hpc == 0.6.*,- ghc-lib-parser,- stm+ ghc-lib-parser == 0.20220901 build-tool-depends: alex:alex >= 3.1, happy:happy >= 1.19.4 other-extensions: BangPatterns@@ -257,6 +257,7 @@ GHC.Driver.Pipeline.Monad, GHC.Driver.Pipeline.Phases, GHC.Driver.Plugins,+ GHC.Driver.Plugins.External, GHC.Driver.Ppr, GHC.Driver.Session, GHC.Exts.Heap,
ghc-lib/stage0/compiler/build/primop-data-decl.hs-incl view
@@ -598,7 +598,9 @@ | LabelThreadOp | IsCurrentThreadBoundOp | NoDuplicateOp+ | GetThreadLabelOp | ThreadStatusOp+ | ListThreadsOp | MkWeakOp | MkWeakNoFinalizerOp | AddCFinalizerToWeakOp
ghc-lib/stage0/compiler/build/primop-docs.hs-incl view
@@ -282,6 +282,10 @@ , ("State#"," 'State#' is the primitive, unlifted type of states. It has\n one type parameter, thus @'State#' 'RealWorld'@, or @'State#' s@,\n where s is a type variable. The only purpose of the type parameter\n is to keep different state threads separate. It is represented by\n nothing at all. ") , ("RealWorld"," 'RealWorld' is deeply magical. It is /primitive/, but it is not\n /unlifted/ (hence @ptrArg@). We never manipulate values of type\n 'RealWorld'; it's only used in the type system, to parameterise 'State#'. ") , ("ThreadId#","(In a non-concurrent implementation, this can be a singleton\n type, whose (unique) value is returned by 'myThreadId#'. The\n other operations can be omitted.)")+ , ("labelThread#","Set the label of the given thread. The @ByteArray#@ should contain\n a UTF-8-encoded string.")+ , ("threadLabel#","Get the label of the given thread.\n Morally of type @ThreadId# -> IO (Maybe ByteArray#)@, with a @1#@ tag\n denoting @Just@.\n\n @since 0.10")+ , ("threadStatus#","Get the status of the given thread. Result is\n @(ThreadStatus, Capability, Locked)@ where\n @ThreadStatus@ is one of the status constants defined in\n @rts/Constants.h@, @Capability@ is the number of\n the capability which currently owns the thread, and\n @Locked@ is a boolean indicating whether the\n thread is bound to that capability.\n\n @since 0.9")+ , ("listThreads#"," Returns an array of the threads started by the program. Note that this\n threads which have finished execution may or may not be present in this\n list, depending upon whether they have been collected by the garbage collector.\n\n @since 0.10") , ("mkWeak#"," @'mkWeak#' k v finalizer s@ creates a weak reference to value @k@,\n with an associated reference to some value @v@. If @k@ is still\n alive then @v@ can be retrieved using 'deRefWeak#'. Note that\n the type of @k@ must be represented by a pointer (i.e. of kind\n @'TYPE' ''LiftedRep' or @'TYPE' ''UnliftedRep'@). ") , ("addCFinalizerToWeak#"," @'addCFinalizerToWeak#' fptr ptr flag eptr w@ attaches a C\n function pointer @fptr@ to a weak pointer @w@ as a finalizer. If\n @flag@ is zero, @fptr@ will be called with one argument,\n @ptr@. Otherwise, it will be called with two arguments,\n @eptr@ and @ptr@. 'addCFinalizerToWeak#' returns\n 1 on success, or 0 if @w@ is already dead. ") , ("finalizeWeak#"," Finalize a weak pointer. The return value is an unboxed tuple\n containing the new state of the world and an \"unboxed Maybe\",\n represented by an 'Int#' and a (possibly invalid) finalization\n action. An 'Int#' of @1@ indicates that the finalizer is valid. The\n return value @b@ from the finalizer should be ignored. ")
ghc-lib/stage0/compiler/build/primop-has-side-effects.hs-incl view
@@ -199,6 +199,7 @@ primOpHasSideEffects IsCurrentThreadBoundOp = True primOpHasSideEffects NoDuplicateOp = True primOpHasSideEffects ThreadStatusOp = True+primOpHasSideEffects ListThreadsOp = True primOpHasSideEffects MkWeakOp = True primOpHasSideEffects MkWeakNoFinalizerOp = True primOpHasSideEffects AddCFinalizerToWeakOp = True
ghc-lib/stage0/compiler/build/primop-list.hs-incl view
@@ -597,7 +597,9 @@ , LabelThreadOp , IsCurrentThreadBoundOp , NoDuplicateOp+ , GetThreadLabelOp , ThreadStatusOp+ , ListThreadsOp , MkWeakOp , MkWeakNoFinalizerOp , AddCFinalizerToWeakOp
ghc-lib/stage0/compiler/build/primop-out-of-line.hs-incl view
@@ -67,7 +67,9 @@ primOpOutOfLine LabelThreadOp = True primOpOutOfLine IsCurrentThreadBoundOp = True primOpOutOfLine NoDuplicateOp = True+primOpOutOfLine GetThreadLabelOp = True primOpOutOfLine ThreadStatusOp = True+primOpOutOfLine ListThreadsOp = True primOpOutOfLine MkWeakOp = True primOpOutOfLine MkWeakNoFinalizerOp = True primOpOutOfLine AddCFinalizerToWeakOp = True
ghc-lib/stage0/compiler/build/primop-primop-info.hs-incl view
@@ -594,10 +594,12 @@ primOpInfo KillThreadOp = mkGenPrimOp (fsLit "killThread#") [alphaTyVarSpec] [threadIdPrimTy, alphaTy, mkStatePrimTy realWorldTy] (mkStatePrimTy realWorldTy) primOpInfo YieldOp = mkGenPrimOp (fsLit "yield#") [] [mkStatePrimTy realWorldTy] (mkStatePrimTy realWorldTy) primOpInfo MyThreadIdOp = mkGenPrimOp (fsLit "myThreadId#") [] [mkStatePrimTy realWorldTy] ((mkTupleTy Unboxed [mkStatePrimTy realWorldTy, threadIdPrimTy]))-primOpInfo LabelThreadOp = mkGenPrimOp (fsLit "labelThread#") [] [threadIdPrimTy, addrPrimTy, mkStatePrimTy realWorldTy] (mkStatePrimTy realWorldTy)+primOpInfo LabelThreadOp = mkGenPrimOp (fsLit "labelThread#") [] [threadIdPrimTy, byteArrayPrimTy, mkStatePrimTy realWorldTy] (mkStatePrimTy realWorldTy) primOpInfo IsCurrentThreadBoundOp = mkGenPrimOp (fsLit "isCurrentThreadBound#") [] [mkStatePrimTy realWorldTy] ((mkTupleTy Unboxed [mkStatePrimTy realWorldTy, intPrimTy])) primOpInfo NoDuplicateOp = mkGenPrimOp (fsLit "noDuplicate#") [deltaTyVarSpec] [mkStatePrimTy deltaTy] (mkStatePrimTy deltaTy)+primOpInfo GetThreadLabelOp = mkGenPrimOp (fsLit "threadLabel#") [] [threadIdPrimTy, mkStatePrimTy realWorldTy] ((mkTupleTy Unboxed [mkStatePrimTy realWorldTy, intPrimTy, byteArrayPrimTy])) primOpInfo ThreadStatusOp = mkGenPrimOp (fsLit "threadStatus#") [] [threadIdPrimTy, mkStatePrimTy realWorldTy] ((mkTupleTy Unboxed [mkStatePrimTy realWorldTy, intPrimTy, intPrimTy, intPrimTy]))+primOpInfo ListThreadsOp = mkGenPrimOp (fsLit "listThreads#") [] [mkStatePrimTy realWorldTy] ((mkTupleTy Unboxed [mkStatePrimTy realWorldTy, mkArrayPrimTy threadIdPrimTy])) primOpInfo MkWeakOp = mkGenPrimOp (fsLit "mkWeak#") [levity1TyVarInf, levity2TyVarInf, levPolyAlphaTyVarSpec, levPolyBetaTyVarSpec, gammaTyVarSpec] [levPolyAlphaTy, levPolyBetaTy, (mkVisFunTyMany (mkStatePrimTy realWorldTy) ((mkTupleTy Unboxed [mkStatePrimTy realWorldTy, gammaTy]))), mkStatePrimTy realWorldTy] ((mkTupleTy Unboxed [mkStatePrimTy realWorldTy, mkWeakPrimTy levPolyBetaTy])) primOpInfo MkWeakNoFinalizerOp = mkGenPrimOp (fsLit "mkWeakNoFinalizer#") [levity1TyVarInf, levity2TyVarInf, levPolyAlphaTyVarSpec, levPolyBetaTyVarSpec] [levPolyAlphaTy, levPolyBetaTy, mkStatePrimTy realWorldTy] ((mkTupleTy Unboxed [mkStatePrimTy realWorldTy, mkWeakPrimTy levPolyBetaTy])) primOpInfo AddCFinalizerToWeakOp = mkGenPrimOp (fsLit "addCFinalizerToWeak#") [levity2TyVarInf, levPolyBetaTyVarSpec] [addrPrimTy, addrPrimTy, intPrimTy, addrPrimTy, mkWeakPrimTy levPolyBetaTy, mkStatePrimTy realWorldTy] ((mkTupleTy Unboxed [mkStatePrimTy realWorldTy, intPrimTy]))
ghc-lib/stage0/compiler/build/primop-tag.hs-incl view
@@ -1,1307 +1,1309 @@ maxPrimOpTag :: Int-maxPrimOpTag = 1303-primOpTag :: PrimOp -> Int-primOpTag CharGtOp = 0-primOpTag CharGeOp = 1-primOpTag CharEqOp = 2-primOpTag CharNeOp = 3-primOpTag CharLtOp = 4-primOpTag CharLeOp = 5-primOpTag OrdOp = 6-primOpTag Int8ToIntOp = 7-primOpTag IntToInt8Op = 8-primOpTag Int8NegOp = 9-primOpTag Int8AddOp = 10-primOpTag Int8SubOp = 11-primOpTag Int8MulOp = 12-primOpTag Int8QuotOp = 13-primOpTag Int8RemOp = 14-primOpTag Int8QuotRemOp = 15-primOpTag Int8SllOp = 16-primOpTag Int8SraOp = 17-primOpTag Int8SrlOp = 18-primOpTag Int8ToWord8Op = 19-primOpTag Int8EqOp = 20-primOpTag Int8GeOp = 21-primOpTag Int8GtOp = 22-primOpTag Int8LeOp = 23-primOpTag Int8LtOp = 24-primOpTag Int8NeOp = 25-primOpTag Word8ToWordOp = 26-primOpTag WordToWord8Op = 27-primOpTag Word8AddOp = 28-primOpTag Word8SubOp = 29-primOpTag Word8MulOp = 30-primOpTag Word8QuotOp = 31-primOpTag Word8RemOp = 32-primOpTag Word8QuotRemOp = 33-primOpTag Word8AndOp = 34-primOpTag Word8OrOp = 35-primOpTag Word8XorOp = 36-primOpTag Word8NotOp = 37-primOpTag Word8SllOp = 38-primOpTag Word8SrlOp = 39-primOpTag Word8ToInt8Op = 40-primOpTag Word8EqOp = 41-primOpTag Word8GeOp = 42-primOpTag Word8GtOp = 43-primOpTag Word8LeOp = 44-primOpTag Word8LtOp = 45-primOpTag Word8NeOp = 46-primOpTag Int16ToIntOp = 47-primOpTag IntToInt16Op = 48-primOpTag Int16NegOp = 49-primOpTag Int16AddOp = 50-primOpTag Int16SubOp = 51-primOpTag Int16MulOp = 52-primOpTag Int16QuotOp = 53-primOpTag Int16RemOp = 54-primOpTag Int16QuotRemOp = 55-primOpTag Int16SllOp = 56-primOpTag Int16SraOp = 57-primOpTag Int16SrlOp = 58-primOpTag Int16ToWord16Op = 59-primOpTag Int16EqOp = 60-primOpTag Int16GeOp = 61-primOpTag Int16GtOp = 62-primOpTag Int16LeOp = 63-primOpTag Int16LtOp = 64-primOpTag Int16NeOp = 65-primOpTag Word16ToWordOp = 66-primOpTag WordToWord16Op = 67-primOpTag Word16AddOp = 68-primOpTag Word16SubOp = 69-primOpTag Word16MulOp = 70-primOpTag Word16QuotOp = 71-primOpTag Word16RemOp = 72-primOpTag Word16QuotRemOp = 73-primOpTag Word16AndOp = 74-primOpTag Word16OrOp = 75-primOpTag Word16XorOp = 76-primOpTag Word16NotOp = 77-primOpTag Word16SllOp = 78-primOpTag Word16SrlOp = 79-primOpTag Word16ToInt16Op = 80-primOpTag Word16EqOp = 81-primOpTag Word16GeOp = 82-primOpTag Word16GtOp = 83-primOpTag Word16LeOp = 84-primOpTag Word16LtOp = 85-primOpTag Word16NeOp = 86-primOpTag Int32ToIntOp = 87-primOpTag IntToInt32Op = 88-primOpTag Int32NegOp = 89-primOpTag Int32AddOp = 90-primOpTag Int32SubOp = 91-primOpTag Int32MulOp = 92-primOpTag Int32QuotOp = 93-primOpTag Int32RemOp = 94-primOpTag Int32QuotRemOp = 95-primOpTag Int32SllOp = 96-primOpTag Int32SraOp = 97-primOpTag Int32SrlOp = 98-primOpTag Int32ToWord32Op = 99-primOpTag Int32EqOp = 100-primOpTag Int32GeOp = 101-primOpTag Int32GtOp = 102-primOpTag Int32LeOp = 103-primOpTag Int32LtOp = 104-primOpTag Int32NeOp = 105-primOpTag Word32ToWordOp = 106-primOpTag WordToWord32Op = 107-primOpTag Word32AddOp = 108-primOpTag Word32SubOp = 109-primOpTag Word32MulOp = 110-primOpTag Word32QuotOp = 111-primOpTag Word32RemOp = 112-primOpTag Word32QuotRemOp = 113-primOpTag Word32AndOp = 114-primOpTag Word32OrOp = 115-primOpTag Word32XorOp = 116-primOpTag Word32NotOp = 117-primOpTag Word32SllOp = 118-primOpTag Word32SrlOp = 119-primOpTag Word32ToInt32Op = 120-primOpTag Word32EqOp = 121-primOpTag Word32GeOp = 122-primOpTag Word32GtOp = 123-primOpTag Word32LeOp = 124-primOpTag Word32LtOp = 125-primOpTag Word32NeOp = 126-primOpTag Int64ToIntOp = 127-primOpTag IntToInt64Op = 128-primOpTag Int64NegOp = 129-primOpTag Int64AddOp = 130-primOpTag Int64SubOp = 131-primOpTag Int64MulOp = 132-primOpTag Int64QuotOp = 133-primOpTag Int64RemOp = 134-primOpTag Int64SllOp = 135-primOpTag Int64SraOp = 136-primOpTag Int64SrlOp = 137-primOpTag Int64ToWord64Op = 138-primOpTag Int64EqOp = 139-primOpTag Int64GeOp = 140-primOpTag Int64GtOp = 141-primOpTag Int64LeOp = 142-primOpTag Int64LtOp = 143-primOpTag Int64NeOp = 144-primOpTag Word64ToWordOp = 145-primOpTag WordToWord64Op = 146-primOpTag Word64AddOp = 147-primOpTag Word64SubOp = 148-primOpTag Word64MulOp = 149-primOpTag Word64QuotOp = 150-primOpTag Word64RemOp = 151-primOpTag Word64AndOp = 152-primOpTag Word64OrOp = 153-primOpTag Word64XorOp = 154-primOpTag Word64NotOp = 155-primOpTag Word64SllOp = 156-primOpTag Word64SrlOp = 157-primOpTag Word64ToInt64Op = 158-primOpTag Word64EqOp = 159-primOpTag Word64GeOp = 160-primOpTag Word64GtOp = 161-primOpTag Word64LeOp = 162-primOpTag Word64LtOp = 163-primOpTag Word64NeOp = 164-primOpTag IntAddOp = 165-primOpTag IntSubOp = 166-primOpTag IntMulOp = 167-primOpTag IntMul2Op = 168-primOpTag IntMulMayOfloOp = 169-primOpTag IntQuotOp = 170-primOpTag IntRemOp = 171-primOpTag IntQuotRemOp = 172-primOpTag IntAndOp = 173-primOpTag IntOrOp = 174-primOpTag IntXorOp = 175-primOpTag IntNotOp = 176-primOpTag IntNegOp = 177-primOpTag IntAddCOp = 178-primOpTag IntSubCOp = 179-primOpTag IntGtOp = 180-primOpTag IntGeOp = 181-primOpTag IntEqOp = 182-primOpTag IntNeOp = 183-primOpTag IntLtOp = 184-primOpTag IntLeOp = 185-primOpTag ChrOp = 186-primOpTag IntToWordOp = 187-primOpTag IntToFloatOp = 188-primOpTag IntToDoubleOp = 189-primOpTag WordToFloatOp = 190-primOpTag WordToDoubleOp = 191-primOpTag IntSllOp = 192-primOpTag IntSraOp = 193-primOpTag IntSrlOp = 194-primOpTag WordAddOp = 195-primOpTag WordAddCOp = 196-primOpTag WordSubCOp = 197-primOpTag WordAdd2Op = 198-primOpTag WordSubOp = 199-primOpTag WordMulOp = 200-primOpTag WordMul2Op = 201-primOpTag WordQuotOp = 202-primOpTag WordRemOp = 203-primOpTag WordQuotRemOp = 204-primOpTag WordQuotRem2Op = 205-primOpTag WordAndOp = 206-primOpTag WordOrOp = 207-primOpTag WordXorOp = 208-primOpTag WordNotOp = 209-primOpTag WordSllOp = 210-primOpTag WordSrlOp = 211-primOpTag WordToIntOp = 212-primOpTag WordGtOp = 213-primOpTag WordGeOp = 214-primOpTag WordEqOp = 215-primOpTag WordNeOp = 216-primOpTag WordLtOp = 217-primOpTag WordLeOp = 218-primOpTag PopCnt8Op = 219-primOpTag PopCnt16Op = 220-primOpTag PopCnt32Op = 221-primOpTag PopCnt64Op = 222-primOpTag PopCntOp = 223-primOpTag Pdep8Op = 224-primOpTag Pdep16Op = 225-primOpTag Pdep32Op = 226-primOpTag Pdep64Op = 227-primOpTag PdepOp = 228-primOpTag Pext8Op = 229-primOpTag Pext16Op = 230-primOpTag Pext32Op = 231-primOpTag Pext64Op = 232-primOpTag PextOp = 233-primOpTag Clz8Op = 234-primOpTag Clz16Op = 235-primOpTag Clz32Op = 236-primOpTag Clz64Op = 237-primOpTag ClzOp = 238-primOpTag Ctz8Op = 239-primOpTag Ctz16Op = 240-primOpTag Ctz32Op = 241-primOpTag Ctz64Op = 242-primOpTag CtzOp = 243-primOpTag BSwap16Op = 244-primOpTag BSwap32Op = 245-primOpTag BSwap64Op = 246-primOpTag BSwapOp = 247-primOpTag BRev8Op = 248-primOpTag BRev16Op = 249-primOpTag BRev32Op = 250-primOpTag BRev64Op = 251-primOpTag BRevOp = 252-primOpTag Narrow8IntOp = 253-primOpTag Narrow16IntOp = 254-primOpTag Narrow32IntOp = 255-primOpTag Narrow8WordOp = 256-primOpTag Narrow16WordOp = 257-primOpTag Narrow32WordOp = 258-primOpTag DoubleGtOp = 259-primOpTag DoubleGeOp = 260-primOpTag DoubleEqOp = 261-primOpTag DoubleNeOp = 262-primOpTag DoubleLtOp = 263-primOpTag DoubleLeOp = 264-primOpTag DoubleAddOp = 265-primOpTag DoubleSubOp = 266-primOpTag DoubleMulOp = 267-primOpTag DoubleDivOp = 268-primOpTag DoubleNegOp = 269-primOpTag DoubleFabsOp = 270-primOpTag DoubleToIntOp = 271-primOpTag DoubleToFloatOp = 272-primOpTag DoubleExpOp = 273-primOpTag DoubleExpM1Op = 274-primOpTag DoubleLogOp = 275-primOpTag DoubleLog1POp = 276-primOpTag DoubleSqrtOp = 277-primOpTag DoubleSinOp = 278-primOpTag DoubleCosOp = 279-primOpTag DoubleTanOp = 280-primOpTag DoubleAsinOp = 281-primOpTag DoubleAcosOp = 282-primOpTag DoubleAtanOp = 283-primOpTag DoubleSinhOp = 284-primOpTag DoubleCoshOp = 285-primOpTag DoubleTanhOp = 286-primOpTag DoubleAsinhOp = 287-primOpTag DoubleAcoshOp = 288-primOpTag DoubleAtanhOp = 289-primOpTag DoublePowerOp = 290-primOpTag DoubleDecode_2IntOp = 291-primOpTag DoubleDecode_Int64Op = 292-primOpTag FloatGtOp = 293-primOpTag FloatGeOp = 294-primOpTag FloatEqOp = 295-primOpTag FloatNeOp = 296-primOpTag FloatLtOp = 297-primOpTag FloatLeOp = 298-primOpTag FloatAddOp = 299-primOpTag FloatSubOp = 300-primOpTag FloatMulOp = 301-primOpTag FloatDivOp = 302-primOpTag FloatNegOp = 303-primOpTag FloatFabsOp = 304-primOpTag FloatToIntOp = 305-primOpTag FloatExpOp = 306-primOpTag FloatExpM1Op = 307-primOpTag FloatLogOp = 308-primOpTag FloatLog1POp = 309-primOpTag FloatSqrtOp = 310-primOpTag FloatSinOp = 311-primOpTag FloatCosOp = 312-primOpTag FloatTanOp = 313-primOpTag FloatAsinOp = 314-primOpTag FloatAcosOp = 315-primOpTag FloatAtanOp = 316-primOpTag FloatSinhOp = 317-primOpTag FloatCoshOp = 318-primOpTag FloatTanhOp = 319-primOpTag FloatAsinhOp = 320-primOpTag FloatAcoshOp = 321-primOpTag FloatAtanhOp = 322-primOpTag FloatPowerOp = 323-primOpTag FloatToDoubleOp = 324-primOpTag FloatDecode_IntOp = 325-primOpTag NewArrayOp = 326-primOpTag ReadArrayOp = 327-primOpTag WriteArrayOp = 328-primOpTag SizeofArrayOp = 329-primOpTag SizeofMutableArrayOp = 330-primOpTag IndexArrayOp = 331-primOpTag UnsafeFreezeArrayOp = 332-primOpTag UnsafeThawArrayOp = 333-primOpTag CopyArrayOp = 334-primOpTag CopyMutableArrayOp = 335-primOpTag CloneArrayOp = 336-primOpTag CloneMutableArrayOp = 337-primOpTag FreezeArrayOp = 338-primOpTag ThawArrayOp = 339-primOpTag CasArrayOp = 340-primOpTag NewSmallArrayOp = 341-primOpTag ShrinkSmallMutableArrayOp_Char = 342-primOpTag ReadSmallArrayOp = 343-primOpTag WriteSmallArrayOp = 344-primOpTag SizeofSmallArrayOp = 345-primOpTag SizeofSmallMutableArrayOp = 346-primOpTag GetSizeofSmallMutableArrayOp = 347-primOpTag IndexSmallArrayOp = 348-primOpTag UnsafeFreezeSmallArrayOp = 349-primOpTag UnsafeThawSmallArrayOp = 350-primOpTag CopySmallArrayOp = 351-primOpTag CopySmallMutableArrayOp = 352-primOpTag CloneSmallArrayOp = 353-primOpTag CloneSmallMutableArrayOp = 354-primOpTag FreezeSmallArrayOp = 355-primOpTag ThawSmallArrayOp = 356-primOpTag CasSmallArrayOp = 357-primOpTag NewByteArrayOp_Char = 358-primOpTag NewPinnedByteArrayOp_Char = 359-primOpTag NewAlignedPinnedByteArrayOp_Char = 360-primOpTag MutableByteArrayIsPinnedOp = 361-primOpTag ByteArrayIsPinnedOp = 362-primOpTag ByteArrayContents_Char = 363-primOpTag MutableByteArrayContents_Char = 364-primOpTag ShrinkMutableByteArrayOp_Char = 365-primOpTag ResizeMutableByteArrayOp_Char = 366-primOpTag UnsafeFreezeByteArrayOp = 367-primOpTag SizeofByteArrayOp = 368-primOpTag SizeofMutableByteArrayOp = 369-primOpTag GetSizeofMutableByteArrayOp = 370-primOpTag IndexByteArrayOp_Char = 371-primOpTag IndexByteArrayOp_WideChar = 372-primOpTag IndexByteArrayOp_Int = 373-primOpTag IndexByteArrayOp_Word = 374-primOpTag IndexByteArrayOp_Addr = 375-primOpTag IndexByteArrayOp_Float = 376-primOpTag IndexByteArrayOp_Double = 377-primOpTag IndexByteArrayOp_StablePtr = 378-primOpTag IndexByteArrayOp_Int8 = 379-primOpTag IndexByteArrayOp_Int16 = 380-primOpTag IndexByteArrayOp_Int32 = 381-primOpTag IndexByteArrayOp_Int64 = 382-primOpTag IndexByteArrayOp_Word8 = 383-primOpTag IndexByteArrayOp_Word16 = 384-primOpTag IndexByteArrayOp_Word32 = 385-primOpTag IndexByteArrayOp_Word64 = 386-primOpTag IndexByteArrayOp_Word8AsChar = 387-primOpTag IndexByteArrayOp_Word8AsWideChar = 388-primOpTag IndexByteArrayOp_Word8AsInt = 389-primOpTag IndexByteArrayOp_Word8AsWord = 390-primOpTag IndexByteArrayOp_Word8AsAddr = 391-primOpTag IndexByteArrayOp_Word8AsFloat = 392-primOpTag IndexByteArrayOp_Word8AsDouble = 393-primOpTag IndexByteArrayOp_Word8AsStablePtr = 394-primOpTag IndexByteArrayOp_Word8AsInt16 = 395-primOpTag IndexByteArrayOp_Word8AsInt32 = 396-primOpTag IndexByteArrayOp_Word8AsInt64 = 397-primOpTag IndexByteArrayOp_Word8AsWord16 = 398-primOpTag IndexByteArrayOp_Word8AsWord32 = 399-primOpTag IndexByteArrayOp_Word8AsWord64 = 400-primOpTag ReadByteArrayOp_Char = 401-primOpTag ReadByteArrayOp_WideChar = 402-primOpTag ReadByteArrayOp_Int = 403-primOpTag ReadByteArrayOp_Word = 404-primOpTag ReadByteArrayOp_Addr = 405-primOpTag ReadByteArrayOp_Float = 406-primOpTag ReadByteArrayOp_Double = 407-primOpTag ReadByteArrayOp_StablePtr = 408-primOpTag ReadByteArrayOp_Int8 = 409-primOpTag ReadByteArrayOp_Int16 = 410-primOpTag ReadByteArrayOp_Int32 = 411-primOpTag ReadByteArrayOp_Int64 = 412-primOpTag ReadByteArrayOp_Word8 = 413-primOpTag ReadByteArrayOp_Word16 = 414-primOpTag ReadByteArrayOp_Word32 = 415-primOpTag ReadByteArrayOp_Word64 = 416-primOpTag ReadByteArrayOp_Word8AsChar = 417-primOpTag ReadByteArrayOp_Word8AsWideChar = 418-primOpTag ReadByteArrayOp_Word8AsInt = 419-primOpTag ReadByteArrayOp_Word8AsWord = 420-primOpTag ReadByteArrayOp_Word8AsAddr = 421-primOpTag ReadByteArrayOp_Word8AsFloat = 422-primOpTag ReadByteArrayOp_Word8AsDouble = 423-primOpTag ReadByteArrayOp_Word8AsStablePtr = 424-primOpTag ReadByteArrayOp_Word8AsInt16 = 425-primOpTag ReadByteArrayOp_Word8AsInt32 = 426-primOpTag ReadByteArrayOp_Word8AsInt64 = 427-primOpTag ReadByteArrayOp_Word8AsWord16 = 428-primOpTag ReadByteArrayOp_Word8AsWord32 = 429-primOpTag ReadByteArrayOp_Word8AsWord64 = 430-primOpTag WriteByteArrayOp_Char = 431-primOpTag WriteByteArrayOp_WideChar = 432-primOpTag WriteByteArrayOp_Int = 433-primOpTag WriteByteArrayOp_Word = 434-primOpTag WriteByteArrayOp_Addr = 435-primOpTag WriteByteArrayOp_Float = 436-primOpTag WriteByteArrayOp_Double = 437-primOpTag WriteByteArrayOp_StablePtr = 438-primOpTag WriteByteArrayOp_Int8 = 439-primOpTag WriteByteArrayOp_Int16 = 440-primOpTag WriteByteArrayOp_Int32 = 441-primOpTag WriteByteArrayOp_Int64 = 442-primOpTag WriteByteArrayOp_Word8 = 443-primOpTag WriteByteArrayOp_Word16 = 444-primOpTag WriteByteArrayOp_Word32 = 445-primOpTag WriteByteArrayOp_Word64 = 446-primOpTag WriteByteArrayOp_Word8AsChar = 447-primOpTag WriteByteArrayOp_Word8AsWideChar = 448-primOpTag WriteByteArrayOp_Word8AsInt = 449-primOpTag WriteByteArrayOp_Word8AsWord = 450-primOpTag WriteByteArrayOp_Word8AsAddr = 451-primOpTag WriteByteArrayOp_Word8AsFloat = 452-primOpTag WriteByteArrayOp_Word8AsDouble = 453-primOpTag WriteByteArrayOp_Word8AsStablePtr = 454-primOpTag WriteByteArrayOp_Word8AsInt16 = 455-primOpTag WriteByteArrayOp_Word8AsInt32 = 456-primOpTag WriteByteArrayOp_Word8AsInt64 = 457-primOpTag WriteByteArrayOp_Word8AsWord16 = 458-primOpTag WriteByteArrayOp_Word8AsWord32 = 459-primOpTag WriteByteArrayOp_Word8AsWord64 = 460-primOpTag CompareByteArraysOp = 461-primOpTag CopyByteArrayOp = 462-primOpTag CopyMutableByteArrayOp = 463-primOpTag CopyByteArrayToAddrOp = 464-primOpTag CopyMutableByteArrayToAddrOp = 465-primOpTag CopyAddrToByteArrayOp = 466-primOpTag SetByteArrayOp = 467-primOpTag AtomicReadByteArrayOp_Int = 468-primOpTag AtomicWriteByteArrayOp_Int = 469-primOpTag CasByteArrayOp_Int = 470-primOpTag CasByteArrayOp_Int8 = 471-primOpTag CasByteArrayOp_Int16 = 472-primOpTag CasByteArrayOp_Int32 = 473-primOpTag CasByteArrayOp_Int64 = 474-primOpTag FetchAddByteArrayOp_Int = 475-primOpTag FetchSubByteArrayOp_Int = 476-primOpTag FetchAndByteArrayOp_Int = 477-primOpTag FetchNandByteArrayOp_Int = 478-primOpTag FetchOrByteArrayOp_Int = 479-primOpTag FetchXorByteArrayOp_Int = 480-primOpTag AddrAddOp = 481-primOpTag AddrSubOp = 482-primOpTag AddrRemOp = 483-primOpTag AddrToIntOp = 484-primOpTag IntToAddrOp = 485-primOpTag AddrGtOp = 486-primOpTag AddrGeOp = 487-primOpTag AddrEqOp = 488-primOpTag AddrNeOp = 489-primOpTag AddrLtOp = 490-primOpTag AddrLeOp = 491-primOpTag IndexOffAddrOp_Char = 492-primOpTag IndexOffAddrOp_WideChar = 493-primOpTag IndexOffAddrOp_Int = 494-primOpTag IndexOffAddrOp_Word = 495-primOpTag IndexOffAddrOp_Addr = 496-primOpTag IndexOffAddrOp_Float = 497-primOpTag IndexOffAddrOp_Double = 498-primOpTag IndexOffAddrOp_StablePtr = 499-primOpTag IndexOffAddrOp_Int8 = 500-primOpTag IndexOffAddrOp_Int16 = 501-primOpTag IndexOffAddrOp_Int32 = 502-primOpTag IndexOffAddrOp_Int64 = 503-primOpTag IndexOffAddrOp_Word8 = 504-primOpTag IndexOffAddrOp_Word16 = 505-primOpTag IndexOffAddrOp_Word32 = 506-primOpTag IndexOffAddrOp_Word64 = 507-primOpTag ReadOffAddrOp_Char = 508-primOpTag ReadOffAddrOp_WideChar = 509-primOpTag ReadOffAddrOp_Int = 510-primOpTag ReadOffAddrOp_Word = 511-primOpTag ReadOffAddrOp_Addr = 512-primOpTag ReadOffAddrOp_Float = 513-primOpTag ReadOffAddrOp_Double = 514-primOpTag ReadOffAddrOp_StablePtr = 515-primOpTag ReadOffAddrOp_Int8 = 516-primOpTag ReadOffAddrOp_Int16 = 517-primOpTag ReadOffAddrOp_Int32 = 518-primOpTag ReadOffAddrOp_Int64 = 519-primOpTag ReadOffAddrOp_Word8 = 520-primOpTag ReadOffAddrOp_Word16 = 521-primOpTag ReadOffAddrOp_Word32 = 522-primOpTag ReadOffAddrOp_Word64 = 523-primOpTag WriteOffAddrOp_Char = 524-primOpTag WriteOffAddrOp_WideChar = 525-primOpTag WriteOffAddrOp_Int = 526-primOpTag WriteOffAddrOp_Word = 527-primOpTag WriteOffAddrOp_Addr = 528-primOpTag WriteOffAddrOp_Float = 529-primOpTag WriteOffAddrOp_Double = 530-primOpTag WriteOffAddrOp_StablePtr = 531-primOpTag WriteOffAddrOp_Int8 = 532-primOpTag WriteOffAddrOp_Int16 = 533-primOpTag WriteOffAddrOp_Int32 = 534-primOpTag WriteOffAddrOp_Int64 = 535-primOpTag WriteOffAddrOp_Word8 = 536-primOpTag WriteOffAddrOp_Word16 = 537-primOpTag WriteOffAddrOp_Word32 = 538-primOpTag WriteOffAddrOp_Word64 = 539-primOpTag InterlockedExchange_Addr = 540-primOpTag InterlockedExchange_Word = 541-primOpTag CasAddrOp_Addr = 542-primOpTag CasAddrOp_Word = 543-primOpTag CasAddrOp_Word8 = 544-primOpTag CasAddrOp_Word16 = 545-primOpTag CasAddrOp_Word32 = 546-primOpTag CasAddrOp_Word64 = 547-primOpTag FetchAddAddrOp_Word = 548-primOpTag FetchSubAddrOp_Word = 549-primOpTag FetchAndAddrOp_Word = 550-primOpTag FetchNandAddrOp_Word = 551-primOpTag FetchOrAddrOp_Word = 552-primOpTag FetchXorAddrOp_Word = 553-primOpTag AtomicReadAddrOp_Word = 554-primOpTag AtomicWriteAddrOp_Word = 555-primOpTag NewMutVarOp = 556-primOpTag ReadMutVarOp = 557-primOpTag WriteMutVarOp = 558-primOpTag AtomicModifyMutVar2Op = 559-primOpTag AtomicModifyMutVar_Op = 560-primOpTag CasMutVarOp = 561-primOpTag CatchOp = 562-primOpTag RaiseOp = 563-primOpTag RaiseIOOp = 564-primOpTag MaskAsyncExceptionsOp = 565-primOpTag MaskUninterruptibleOp = 566-primOpTag UnmaskAsyncExceptionsOp = 567-primOpTag MaskStatus = 568-primOpTag AtomicallyOp = 569-primOpTag RetryOp = 570-primOpTag CatchRetryOp = 571-primOpTag CatchSTMOp = 572-primOpTag NewTVarOp = 573-primOpTag ReadTVarOp = 574-primOpTag ReadTVarIOOp = 575-primOpTag WriteTVarOp = 576-primOpTag NewMVarOp = 577-primOpTag TakeMVarOp = 578-primOpTag TryTakeMVarOp = 579-primOpTag PutMVarOp = 580-primOpTag TryPutMVarOp = 581-primOpTag ReadMVarOp = 582-primOpTag TryReadMVarOp = 583-primOpTag IsEmptyMVarOp = 584-primOpTag NewIOPortOp = 585-primOpTag ReadIOPortOp = 586-primOpTag WriteIOPortOp = 587-primOpTag DelayOp = 588-primOpTag WaitReadOp = 589-primOpTag WaitWriteOp = 590-primOpTag ForkOp = 591-primOpTag ForkOnOp = 592-primOpTag KillThreadOp = 593-primOpTag YieldOp = 594-primOpTag MyThreadIdOp = 595-primOpTag LabelThreadOp = 596-primOpTag IsCurrentThreadBoundOp = 597-primOpTag NoDuplicateOp = 598-primOpTag ThreadStatusOp = 599-primOpTag MkWeakOp = 600-primOpTag MkWeakNoFinalizerOp = 601-primOpTag AddCFinalizerToWeakOp = 602-primOpTag DeRefWeakOp = 603-primOpTag FinalizeWeakOp = 604-primOpTag TouchOp = 605-primOpTag MakeStablePtrOp = 606-primOpTag DeRefStablePtrOp = 607-primOpTag EqStablePtrOp = 608-primOpTag MakeStableNameOp = 609-primOpTag StableNameToIntOp = 610-primOpTag CompactNewOp = 611-primOpTag CompactResizeOp = 612-primOpTag CompactContainsOp = 613-primOpTag CompactContainsAnyOp = 614-primOpTag CompactGetFirstBlockOp = 615-primOpTag CompactGetNextBlockOp = 616-primOpTag CompactAllocateBlockOp = 617-primOpTag CompactFixupPointersOp = 618-primOpTag CompactAdd = 619-primOpTag CompactAddWithSharing = 620-primOpTag CompactSize = 621-primOpTag ReallyUnsafePtrEqualityOp = 622-primOpTag ParOp = 623-primOpTag SparkOp = 624-primOpTag SeqOp = 625-primOpTag GetSparkOp = 626-primOpTag NumSparks = 627-primOpTag KeepAliveOp = 628-primOpTag DataToTagOp = 629-primOpTag TagToEnumOp = 630-primOpTag AddrToAnyOp = 631-primOpTag AnyToAddrOp = 632-primOpTag MkApUpd0_Op = 633-primOpTag NewBCOOp = 634-primOpTag UnpackClosureOp = 635-primOpTag ClosureSizeOp = 636-primOpTag GetApStackValOp = 637-primOpTag GetCCSOfOp = 638-primOpTag GetCurrentCCSOp = 639-primOpTag ClearCCSOp = 640-primOpTag WhereFromOp = 641-primOpTag TraceEventOp = 642-primOpTag TraceEventBinaryOp = 643-primOpTag TraceMarkerOp = 644-primOpTag SetThreadAllocationCounter = 645-primOpTag (VecBroadcastOp IntVec 16 W8) = 646-primOpTag (VecBroadcastOp IntVec 8 W16) = 647-primOpTag (VecBroadcastOp IntVec 4 W32) = 648-primOpTag (VecBroadcastOp IntVec 2 W64) = 649-primOpTag (VecBroadcastOp IntVec 32 W8) = 650-primOpTag (VecBroadcastOp IntVec 16 W16) = 651-primOpTag (VecBroadcastOp IntVec 8 W32) = 652-primOpTag (VecBroadcastOp IntVec 4 W64) = 653-primOpTag (VecBroadcastOp IntVec 64 W8) = 654-primOpTag (VecBroadcastOp IntVec 32 W16) = 655-primOpTag (VecBroadcastOp IntVec 16 W32) = 656-primOpTag (VecBroadcastOp IntVec 8 W64) = 657-primOpTag (VecBroadcastOp WordVec 16 W8) = 658-primOpTag (VecBroadcastOp WordVec 8 W16) = 659-primOpTag (VecBroadcastOp WordVec 4 W32) = 660-primOpTag (VecBroadcastOp WordVec 2 W64) = 661-primOpTag (VecBroadcastOp WordVec 32 W8) = 662-primOpTag (VecBroadcastOp WordVec 16 W16) = 663-primOpTag (VecBroadcastOp WordVec 8 W32) = 664-primOpTag (VecBroadcastOp WordVec 4 W64) = 665-primOpTag (VecBroadcastOp WordVec 64 W8) = 666-primOpTag (VecBroadcastOp WordVec 32 W16) = 667-primOpTag (VecBroadcastOp WordVec 16 W32) = 668-primOpTag (VecBroadcastOp WordVec 8 W64) = 669-primOpTag (VecBroadcastOp FloatVec 4 W32) = 670-primOpTag (VecBroadcastOp FloatVec 2 W64) = 671-primOpTag (VecBroadcastOp FloatVec 8 W32) = 672-primOpTag (VecBroadcastOp FloatVec 4 W64) = 673-primOpTag (VecBroadcastOp FloatVec 16 W32) = 674-primOpTag (VecBroadcastOp FloatVec 8 W64) = 675-primOpTag (VecPackOp IntVec 16 W8) = 676-primOpTag (VecPackOp IntVec 8 W16) = 677-primOpTag (VecPackOp IntVec 4 W32) = 678-primOpTag (VecPackOp IntVec 2 W64) = 679-primOpTag (VecPackOp IntVec 32 W8) = 680-primOpTag (VecPackOp IntVec 16 W16) = 681-primOpTag (VecPackOp IntVec 8 W32) = 682-primOpTag (VecPackOp IntVec 4 W64) = 683-primOpTag (VecPackOp IntVec 64 W8) = 684-primOpTag (VecPackOp IntVec 32 W16) = 685-primOpTag (VecPackOp IntVec 16 W32) = 686-primOpTag (VecPackOp IntVec 8 W64) = 687-primOpTag (VecPackOp WordVec 16 W8) = 688-primOpTag (VecPackOp WordVec 8 W16) = 689-primOpTag (VecPackOp WordVec 4 W32) = 690-primOpTag (VecPackOp WordVec 2 W64) = 691-primOpTag (VecPackOp WordVec 32 W8) = 692-primOpTag (VecPackOp WordVec 16 W16) = 693-primOpTag (VecPackOp WordVec 8 W32) = 694-primOpTag (VecPackOp WordVec 4 W64) = 695-primOpTag (VecPackOp WordVec 64 W8) = 696-primOpTag (VecPackOp WordVec 32 W16) = 697-primOpTag (VecPackOp WordVec 16 W32) = 698-primOpTag (VecPackOp WordVec 8 W64) = 699-primOpTag (VecPackOp FloatVec 4 W32) = 700-primOpTag (VecPackOp FloatVec 2 W64) = 701-primOpTag (VecPackOp FloatVec 8 W32) = 702-primOpTag (VecPackOp FloatVec 4 W64) = 703-primOpTag (VecPackOp FloatVec 16 W32) = 704-primOpTag (VecPackOp FloatVec 8 W64) = 705-primOpTag (VecUnpackOp IntVec 16 W8) = 706-primOpTag (VecUnpackOp IntVec 8 W16) = 707-primOpTag (VecUnpackOp IntVec 4 W32) = 708-primOpTag (VecUnpackOp IntVec 2 W64) = 709-primOpTag (VecUnpackOp IntVec 32 W8) = 710-primOpTag (VecUnpackOp IntVec 16 W16) = 711-primOpTag (VecUnpackOp IntVec 8 W32) = 712-primOpTag (VecUnpackOp IntVec 4 W64) = 713-primOpTag (VecUnpackOp IntVec 64 W8) = 714-primOpTag (VecUnpackOp IntVec 32 W16) = 715-primOpTag (VecUnpackOp IntVec 16 W32) = 716-primOpTag (VecUnpackOp IntVec 8 W64) = 717-primOpTag (VecUnpackOp WordVec 16 W8) = 718-primOpTag (VecUnpackOp WordVec 8 W16) = 719-primOpTag (VecUnpackOp WordVec 4 W32) = 720-primOpTag (VecUnpackOp WordVec 2 W64) = 721-primOpTag (VecUnpackOp WordVec 32 W8) = 722-primOpTag (VecUnpackOp WordVec 16 W16) = 723-primOpTag (VecUnpackOp WordVec 8 W32) = 724-primOpTag (VecUnpackOp WordVec 4 W64) = 725-primOpTag (VecUnpackOp WordVec 64 W8) = 726-primOpTag (VecUnpackOp WordVec 32 W16) = 727-primOpTag (VecUnpackOp WordVec 16 W32) = 728-primOpTag (VecUnpackOp WordVec 8 W64) = 729-primOpTag (VecUnpackOp FloatVec 4 W32) = 730-primOpTag (VecUnpackOp FloatVec 2 W64) = 731-primOpTag (VecUnpackOp FloatVec 8 W32) = 732-primOpTag (VecUnpackOp FloatVec 4 W64) = 733-primOpTag (VecUnpackOp FloatVec 16 W32) = 734-primOpTag (VecUnpackOp FloatVec 8 W64) = 735-primOpTag (VecInsertOp IntVec 16 W8) = 736-primOpTag (VecInsertOp IntVec 8 W16) = 737-primOpTag (VecInsertOp IntVec 4 W32) = 738-primOpTag (VecInsertOp IntVec 2 W64) = 739-primOpTag (VecInsertOp IntVec 32 W8) = 740-primOpTag (VecInsertOp IntVec 16 W16) = 741-primOpTag (VecInsertOp IntVec 8 W32) = 742-primOpTag (VecInsertOp IntVec 4 W64) = 743-primOpTag (VecInsertOp IntVec 64 W8) = 744-primOpTag (VecInsertOp IntVec 32 W16) = 745-primOpTag (VecInsertOp IntVec 16 W32) = 746-primOpTag (VecInsertOp IntVec 8 W64) = 747-primOpTag (VecInsertOp WordVec 16 W8) = 748-primOpTag (VecInsertOp WordVec 8 W16) = 749-primOpTag (VecInsertOp WordVec 4 W32) = 750-primOpTag (VecInsertOp WordVec 2 W64) = 751-primOpTag (VecInsertOp WordVec 32 W8) = 752-primOpTag (VecInsertOp WordVec 16 W16) = 753-primOpTag (VecInsertOp WordVec 8 W32) = 754-primOpTag (VecInsertOp WordVec 4 W64) = 755-primOpTag (VecInsertOp WordVec 64 W8) = 756-primOpTag (VecInsertOp WordVec 32 W16) = 757-primOpTag (VecInsertOp WordVec 16 W32) = 758-primOpTag (VecInsertOp WordVec 8 W64) = 759-primOpTag (VecInsertOp FloatVec 4 W32) = 760-primOpTag (VecInsertOp FloatVec 2 W64) = 761-primOpTag (VecInsertOp FloatVec 8 W32) = 762-primOpTag (VecInsertOp FloatVec 4 W64) = 763-primOpTag (VecInsertOp FloatVec 16 W32) = 764-primOpTag (VecInsertOp FloatVec 8 W64) = 765-primOpTag (VecAddOp IntVec 16 W8) = 766-primOpTag (VecAddOp IntVec 8 W16) = 767-primOpTag (VecAddOp IntVec 4 W32) = 768-primOpTag (VecAddOp IntVec 2 W64) = 769-primOpTag (VecAddOp IntVec 32 W8) = 770-primOpTag (VecAddOp IntVec 16 W16) = 771-primOpTag (VecAddOp IntVec 8 W32) = 772-primOpTag (VecAddOp IntVec 4 W64) = 773-primOpTag (VecAddOp IntVec 64 W8) = 774-primOpTag (VecAddOp IntVec 32 W16) = 775-primOpTag (VecAddOp IntVec 16 W32) = 776-primOpTag (VecAddOp IntVec 8 W64) = 777-primOpTag (VecAddOp WordVec 16 W8) = 778-primOpTag (VecAddOp WordVec 8 W16) = 779-primOpTag (VecAddOp WordVec 4 W32) = 780-primOpTag (VecAddOp WordVec 2 W64) = 781-primOpTag (VecAddOp WordVec 32 W8) = 782-primOpTag (VecAddOp WordVec 16 W16) = 783-primOpTag (VecAddOp WordVec 8 W32) = 784-primOpTag (VecAddOp WordVec 4 W64) = 785-primOpTag (VecAddOp WordVec 64 W8) = 786-primOpTag (VecAddOp WordVec 32 W16) = 787-primOpTag (VecAddOp WordVec 16 W32) = 788-primOpTag (VecAddOp WordVec 8 W64) = 789-primOpTag (VecAddOp FloatVec 4 W32) = 790-primOpTag (VecAddOp FloatVec 2 W64) = 791-primOpTag (VecAddOp FloatVec 8 W32) = 792-primOpTag (VecAddOp FloatVec 4 W64) = 793-primOpTag (VecAddOp FloatVec 16 W32) = 794-primOpTag (VecAddOp FloatVec 8 W64) = 795-primOpTag (VecSubOp IntVec 16 W8) = 796-primOpTag (VecSubOp IntVec 8 W16) = 797-primOpTag (VecSubOp IntVec 4 W32) = 798-primOpTag (VecSubOp IntVec 2 W64) = 799-primOpTag (VecSubOp IntVec 32 W8) = 800-primOpTag (VecSubOp IntVec 16 W16) = 801-primOpTag (VecSubOp IntVec 8 W32) = 802-primOpTag (VecSubOp IntVec 4 W64) = 803-primOpTag (VecSubOp IntVec 64 W8) = 804-primOpTag (VecSubOp IntVec 32 W16) = 805-primOpTag (VecSubOp IntVec 16 W32) = 806-primOpTag (VecSubOp IntVec 8 W64) = 807-primOpTag (VecSubOp WordVec 16 W8) = 808-primOpTag (VecSubOp WordVec 8 W16) = 809-primOpTag (VecSubOp WordVec 4 W32) = 810-primOpTag (VecSubOp WordVec 2 W64) = 811-primOpTag (VecSubOp WordVec 32 W8) = 812-primOpTag (VecSubOp WordVec 16 W16) = 813-primOpTag (VecSubOp WordVec 8 W32) = 814-primOpTag (VecSubOp WordVec 4 W64) = 815-primOpTag (VecSubOp WordVec 64 W8) = 816-primOpTag (VecSubOp WordVec 32 W16) = 817-primOpTag (VecSubOp WordVec 16 W32) = 818-primOpTag (VecSubOp WordVec 8 W64) = 819-primOpTag (VecSubOp FloatVec 4 W32) = 820-primOpTag (VecSubOp FloatVec 2 W64) = 821-primOpTag (VecSubOp FloatVec 8 W32) = 822-primOpTag (VecSubOp FloatVec 4 W64) = 823-primOpTag (VecSubOp FloatVec 16 W32) = 824-primOpTag (VecSubOp FloatVec 8 W64) = 825-primOpTag (VecMulOp IntVec 16 W8) = 826-primOpTag (VecMulOp IntVec 8 W16) = 827-primOpTag (VecMulOp IntVec 4 W32) = 828-primOpTag (VecMulOp IntVec 2 W64) = 829-primOpTag (VecMulOp IntVec 32 W8) = 830-primOpTag (VecMulOp IntVec 16 W16) = 831-primOpTag (VecMulOp IntVec 8 W32) = 832-primOpTag (VecMulOp IntVec 4 W64) = 833-primOpTag (VecMulOp IntVec 64 W8) = 834-primOpTag (VecMulOp IntVec 32 W16) = 835-primOpTag (VecMulOp IntVec 16 W32) = 836-primOpTag (VecMulOp IntVec 8 W64) = 837-primOpTag (VecMulOp WordVec 16 W8) = 838-primOpTag (VecMulOp WordVec 8 W16) = 839-primOpTag (VecMulOp WordVec 4 W32) = 840-primOpTag (VecMulOp WordVec 2 W64) = 841-primOpTag (VecMulOp WordVec 32 W8) = 842-primOpTag (VecMulOp WordVec 16 W16) = 843-primOpTag (VecMulOp WordVec 8 W32) = 844-primOpTag (VecMulOp WordVec 4 W64) = 845-primOpTag (VecMulOp WordVec 64 W8) = 846-primOpTag (VecMulOp WordVec 32 W16) = 847-primOpTag (VecMulOp WordVec 16 W32) = 848-primOpTag (VecMulOp WordVec 8 W64) = 849-primOpTag (VecMulOp FloatVec 4 W32) = 850-primOpTag (VecMulOp FloatVec 2 W64) = 851-primOpTag (VecMulOp FloatVec 8 W32) = 852-primOpTag (VecMulOp FloatVec 4 W64) = 853-primOpTag (VecMulOp FloatVec 16 W32) = 854-primOpTag (VecMulOp FloatVec 8 W64) = 855-primOpTag (VecDivOp FloatVec 4 W32) = 856-primOpTag (VecDivOp FloatVec 2 W64) = 857-primOpTag (VecDivOp FloatVec 8 W32) = 858-primOpTag (VecDivOp FloatVec 4 W64) = 859-primOpTag (VecDivOp FloatVec 16 W32) = 860-primOpTag (VecDivOp FloatVec 8 W64) = 861-primOpTag (VecQuotOp IntVec 16 W8) = 862-primOpTag (VecQuotOp IntVec 8 W16) = 863-primOpTag (VecQuotOp IntVec 4 W32) = 864-primOpTag (VecQuotOp IntVec 2 W64) = 865-primOpTag (VecQuotOp IntVec 32 W8) = 866-primOpTag (VecQuotOp IntVec 16 W16) = 867-primOpTag (VecQuotOp IntVec 8 W32) = 868-primOpTag (VecQuotOp IntVec 4 W64) = 869-primOpTag (VecQuotOp IntVec 64 W8) = 870-primOpTag (VecQuotOp IntVec 32 W16) = 871-primOpTag (VecQuotOp IntVec 16 W32) = 872-primOpTag (VecQuotOp IntVec 8 W64) = 873-primOpTag (VecQuotOp WordVec 16 W8) = 874-primOpTag (VecQuotOp WordVec 8 W16) = 875-primOpTag (VecQuotOp WordVec 4 W32) = 876-primOpTag (VecQuotOp WordVec 2 W64) = 877-primOpTag (VecQuotOp WordVec 32 W8) = 878-primOpTag (VecQuotOp WordVec 16 W16) = 879-primOpTag (VecQuotOp WordVec 8 W32) = 880-primOpTag (VecQuotOp WordVec 4 W64) = 881-primOpTag (VecQuotOp WordVec 64 W8) = 882-primOpTag (VecQuotOp WordVec 32 W16) = 883-primOpTag (VecQuotOp WordVec 16 W32) = 884-primOpTag (VecQuotOp WordVec 8 W64) = 885-primOpTag (VecRemOp IntVec 16 W8) = 886-primOpTag (VecRemOp IntVec 8 W16) = 887-primOpTag (VecRemOp IntVec 4 W32) = 888-primOpTag (VecRemOp IntVec 2 W64) = 889-primOpTag (VecRemOp IntVec 32 W8) = 890-primOpTag (VecRemOp IntVec 16 W16) = 891-primOpTag (VecRemOp IntVec 8 W32) = 892-primOpTag (VecRemOp IntVec 4 W64) = 893-primOpTag (VecRemOp IntVec 64 W8) = 894-primOpTag (VecRemOp IntVec 32 W16) = 895-primOpTag (VecRemOp IntVec 16 W32) = 896-primOpTag (VecRemOp IntVec 8 W64) = 897-primOpTag (VecRemOp WordVec 16 W8) = 898-primOpTag (VecRemOp WordVec 8 W16) = 899-primOpTag (VecRemOp WordVec 4 W32) = 900-primOpTag (VecRemOp WordVec 2 W64) = 901-primOpTag (VecRemOp WordVec 32 W8) = 902-primOpTag (VecRemOp WordVec 16 W16) = 903-primOpTag (VecRemOp WordVec 8 W32) = 904-primOpTag (VecRemOp WordVec 4 W64) = 905-primOpTag (VecRemOp WordVec 64 W8) = 906-primOpTag (VecRemOp WordVec 32 W16) = 907-primOpTag (VecRemOp WordVec 16 W32) = 908-primOpTag (VecRemOp WordVec 8 W64) = 909-primOpTag (VecNegOp IntVec 16 W8) = 910-primOpTag (VecNegOp IntVec 8 W16) = 911-primOpTag (VecNegOp IntVec 4 W32) = 912-primOpTag (VecNegOp IntVec 2 W64) = 913-primOpTag (VecNegOp IntVec 32 W8) = 914-primOpTag (VecNegOp IntVec 16 W16) = 915-primOpTag (VecNegOp IntVec 8 W32) = 916-primOpTag (VecNegOp IntVec 4 W64) = 917-primOpTag (VecNegOp IntVec 64 W8) = 918-primOpTag (VecNegOp IntVec 32 W16) = 919-primOpTag (VecNegOp IntVec 16 W32) = 920-primOpTag (VecNegOp IntVec 8 W64) = 921-primOpTag (VecNegOp FloatVec 4 W32) = 922-primOpTag (VecNegOp FloatVec 2 W64) = 923-primOpTag (VecNegOp FloatVec 8 W32) = 924-primOpTag (VecNegOp FloatVec 4 W64) = 925-primOpTag (VecNegOp FloatVec 16 W32) = 926-primOpTag (VecNegOp FloatVec 8 W64) = 927-primOpTag (VecIndexByteArrayOp IntVec 16 W8) = 928-primOpTag (VecIndexByteArrayOp IntVec 8 W16) = 929-primOpTag (VecIndexByteArrayOp IntVec 4 W32) = 930-primOpTag (VecIndexByteArrayOp IntVec 2 W64) = 931-primOpTag (VecIndexByteArrayOp IntVec 32 W8) = 932-primOpTag (VecIndexByteArrayOp IntVec 16 W16) = 933-primOpTag (VecIndexByteArrayOp IntVec 8 W32) = 934-primOpTag (VecIndexByteArrayOp IntVec 4 W64) = 935-primOpTag (VecIndexByteArrayOp IntVec 64 W8) = 936-primOpTag (VecIndexByteArrayOp IntVec 32 W16) = 937-primOpTag (VecIndexByteArrayOp IntVec 16 W32) = 938-primOpTag (VecIndexByteArrayOp IntVec 8 W64) = 939-primOpTag (VecIndexByteArrayOp WordVec 16 W8) = 940-primOpTag (VecIndexByteArrayOp WordVec 8 W16) = 941-primOpTag (VecIndexByteArrayOp WordVec 4 W32) = 942-primOpTag (VecIndexByteArrayOp WordVec 2 W64) = 943-primOpTag (VecIndexByteArrayOp WordVec 32 W8) = 944-primOpTag (VecIndexByteArrayOp WordVec 16 W16) = 945-primOpTag (VecIndexByteArrayOp WordVec 8 W32) = 946-primOpTag (VecIndexByteArrayOp WordVec 4 W64) = 947-primOpTag (VecIndexByteArrayOp WordVec 64 W8) = 948-primOpTag (VecIndexByteArrayOp WordVec 32 W16) = 949-primOpTag (VecIndexByteArrayOp WordVec 16 W32) = 950-primOpTag (VecIndexByteArrayOp WordVec 8 W64) = 951-primOpTag (VecIndexByteArrayOp FloatVec 4 W32) = 952-primOpTag (VecIndexByteArrayOp FloatVec 2 W64) = 953-primOpTag (VecIndexByteArrayOp FloatVec 8 W32) = 954-primOpTag (VecIndexByteArrayOp FloatVec 4 W64) = 955-primOpTag (VecIndexByteArrayOp FloatVec 16 W32) = 956-primOpTag (VecIndexByteArrayOp FloatVec 8 W64) = 957-primOpTag (VecReadByteArrayOp IntVec 16 W8) = 958-primOpTag (VecReadByteArrayOp IntVec 8 W16) = 959-primOpTag (VecReadByteArrayOp IntVec 4 W32) = 960-primOpTag (VecReadByteArrayOp IntVec 2 W64) = 961-primOpTag (VecReadByteArrayOp IntVec 32 W8) = 962-primOpTag (VecReadByteArrayOp IntVec 16 W16) = 963-primOpTag (VecReadByteArrayOp IntVec 8 W32) = 964-primOpTag (VecReadByteArrayOp IntVec 4 W64) = 965-primOpTag (VecReadByteArrayOp IntVec 64 W8) = 966-primOpTag (VecReadByteArrayOp IntVec 32 W16) = 967-primOpTag (VecReadByteArrayOp IntVec 16 W32) = 968-primOpTag (VecReadByteArrayOp IntVec 8 W64) = 969-primOpTag (VecReadByteArrayOp WordVec 16 W8) = 970-primOpTag (VecReadByteArrayOp WordVec 8 W16) = 971-primOpTag (VecReadByteArrayOp WordVec 4 W32) = 972-primOpTag (VecReadByteArrayOp WordVec 2 W64) = 973-primOpTag (VecReadByteArrayOp WordVec 32 W8) = 974-primOpTag (VecReadByteArrayOp WordVec 16 W16) = 975-primOpTag (VecReadByteArrayOp WordVec 8 W32) = 976-primOpTag (VecReadByteArrayOp WordVec 4 W64) = 977-primOpTag (VecReadByteArrayOp WordVec 64 W8) = 978-primOpTag (VecReadByteArrayOp WordVec 32 W16) = 979-primOpTag (VecReadByteArrayOp WordVec 16 W32) = 980-primOpTag (VecReadByteArrayOp WordVec 8 W64) = 981-primOpTag (VecReadByteArrayOp FloatVec 4 W32) = 982-primOpTag (VecReadByteArrayOp FloatVec 2 W64) = 983-primOpTag (VecReadByteArrayOp FloatVec 8 W32) = 984-primOpTag (VecReadByteArrayOp FloatVec 4 W64) = 985-primOpTag (VecReadByteArrayOp FloatVec 16 W32) = 986-primOpTag (VecReadByteArrayOp FloatVec 8 W64) = 987-primOpTag (VecWriteByteArrayOp IntVec 16 W8) = 988-primOpTag (VecWriteByteArrayOp IntVec 8 W16) = 989-primOpTag (VecWriteByteArrayOp IntVec 4 W32) = 990-primOpTag (VecWriteByteArrayOp IntVec 2 W64) = 991-primOpTag (VecWriteByteArrayOp IntVec 32 W8) = 992-primOpTag (VecWriteByteArrayOp IntVec 16 W16) = 993-primOpTag (VecWriteByteArrayOp IntVec 8 W32) = 994-primOpTag (VecWriteByteArrayOp IntVec 4 W64) = 995-primOpTag (VecWriteByteArrayOp IntVec 64 W8) = 996-primOpTag (VecWriteByteArrayOp IntVec 32 W16) = 997-primOpTag (VecWriteByteArrayOp IntVec 16 W32) = 998-primOpTag (VecWriteByteArrayOp IntVec 8 W64) = 999-primOpTag (VecWriteByteArrayOp WordVec 16 W8) = 1000-primOpTag (VecWriteByteArrayOp WordVec 8 W16) = 1001-primOpTag (VecWriteByteArrayOp WordVec 4 W32) = 1002-primOpTag (VecWriteByteArrayOp WordVec 2 W64) = 1003-primOpTag (VecWriteByteArrayOp WordVec 32 W8) = 1004-primOpTag (VecWriteByteArrayOp WordVec 16 W16) = 1005-primOpTag (VecWriteByteArrayOp WordVec 8 W32) = 1006-primOpTag (VecWriteByteArrayOp WordVec 4 W64) = 1007-primOpTag (VecWriteByteArrayOp WordVec 64 W8) = 1008-primOpTag (VecWriteByteArrayOp WordVec 32 W16) = 1009-primOpTag (VecWriteByteArrayOp WordVec 16 W32) = 1010-primOpTag (VecWriteByteArrayOp WordVec 8 W64) = 1011-primOpTag (VecWriteByteArrayOp FloatVec 4 W32) = 1012-primOpTag (VecWriteByteArrayOp FloatVec 2 W64) = 1013-primOpTag (VecWriteByteArrayOp FloatVec 8 W32) = 1014-primOpTag (VecWriteByteArrayOp FloatVec 4 W64) = 1015-primOpTag (VecWriteByteArrayOp FloatVec 16 W32) = 1016-primOpTag (VecWriteByteArrayOp FloatVec 8 W64) = 1017-primOpTag (VecIndexOffAddrOp IntVec 16 W8) = 1018-primOpTag (VecIndexOffAddrOp IntVec 8 W16) = 1019-primOpTag (VecIndexOffAddrOp IntVec 4 W32) = 1020-primOpTag (VecIndexOffAddrOp IntVec 2 W64) = 1021-primOpTag (VecIndexOffAddrOp IntVec 32 W8) = 1022-primOpTag (VecIndexOffAddrOp IntVec 16 W16) = 1023-primOpTag (VecIndexOffAddrOp IntVec 8 W32) = 1024-primOpTag (VecIndexOffAddrOp IntVec 4 W64) = 1025-primOpTag (VecIndexOffAddrOp IntVec 64 W8) = 1026-primOpTag (VecIndexOffAddrOp IntVec 32 W16) = 1027-primOpTag (VecIndexOffAddrOp IntVec 16 W32) = 1028-primOpTag (VecIndexOffAddrOp IntVec 8 W64) = 1029-primOpTag (VecIndexOffAddrOp WordVec 16 W8) = 1030-primOpTag (VecIndexOffAddrOp WordVec 8 W16) = 1031-primOpTag (VecIndexOffAddrOp WordVec 4 W32) = 1032-primOpTag (VecIndexOffAddrOp WordVec 2 W64) = 1033-primOpTag (VecIndexOffAddrOp WordVec 32 W8) = 1034-primOpTag (VecIndexOffAddrOp WordVec 16 W16) = 1035-primOpTag (VecIndexOffAddrOp WordVec 8 W32) = 1036-primOpTag (VecIndexOffAddrOp WordVec 4 W64) = 1037-primOpTag (VecIndexOffAddrOp WordVec 64 W8) = 1038-primOpTag (VecIndexOffAddrOp WordVec 32 W16) = 1039-primOpTag (VecIndexOffAddrOp WordVec 16 W32) = 1040-primOpTag (VecIndexOffAddrOp WordVec 8 W64) = 1041-primOpTag (VecIndexOffAddrOp FloatVec 4 W32) = 1042-primOpTag (VecIndexOffAddrOp FloatVec 2 W64) = 1043-primOpTag (VecIndexOffAddrOp FloatVec 8 W32) = 1044-primOpTag (VecIndexOffAddrOp FloatVec 4 W64) = 1045-primOpTag (VecIndexOffAddrOp FloatVec 16 W32) = 1046-primOpTag (VecIndexOffAddrOp FloatVec 8 W64) = 1047-primOpTag (VecReadOffAddrOp IntVec 16 W8) = 1048-primOpTag (VecReadOffAddrOp IntVec 8 W16) = 1049-primOpTag (VecReadOffAddrOp IntVec 4 W32) = 1050-primOpTag (VecReadOffAddrOp IntVec 2 W64) = 1051-primOpTag (VecReadOffAddrOp IntVec 32 W8) = 1052-primOpTag (VecReadOffAddrOp IntVec 16 W16) = 1053-primOpTag (VecReadOffAddrOp IntVec 8 W32) = 1054-primOpTag (VecReadOffAddrOp IntVec 4 W64) = 1055-primOpTag (VecReadOffAddrOp IntVec 64 W8) = 1056-primOpTag (VecReadOffAddrOp IntVec 32 W16) = 1057-primOpTag (VecReadOffAddrOp IntVec 16 W32) = 1058-primOpTag (VecReadOffAddrOp IntVec 8 W64) = 1059-primOpTag (VecReadOffAddrOp WordVec 16 W8) = 1060-primOpTag (VecReadOffAddrOp WordVec 8 W16) = 1061-primOpTag (VecReadOffAddrOp WordVec 4 W32) = 1062-primOpTag (VecReadOffAddrOp WordVec 2 W64) = 1063-primOpTag (VecReadOffAddrOp WordVec 32 W8) = 1064-primOpTag (VecReadOffAddrOp WordVec 16 W16) = 1065-primOpTag (VecReadOffAddrOp WordVec 8 W32) = 1066-primOpTag (VecReadOffAddrOp WordVec 4 W64) = 1067-primOpTag (VecReadOffAddrOp WordVec 64 W8) = 1068-primOpTag (VecReadOffAddrOp WordVec 32 W16) = 1069-primOpTag (VecReadOffAddrOp WordVec 16 W32) = 1070-primOpTag (VecReadOffAddrOp WordVec 8 W64) = 1071-primOpTag (VecReadOffAddrOp FloatVec 4 W32) = 1072-primOpTag (VecReadOffAddrOp FloatVec 2 W64) = 1073-primOpTag (VecReadOffAddrOp FloatVec 8 W32) = 1074-primOpTag (VecReadOffAddrOp FloatVec 4 W64) = 1075-primOpTag (VecReadOffAddrOp FloatVec 16 W32) = 1076-primOpTag (VecReadOffAddrOp FloatVec 8 W64) = 1077-primOpTag (VecWriteOffAddrOp IntVec 16 W8) = 1078-primOpTag (VecWriteOffAddrOp IntVec 8 W16) = 1079-primOpTag (VecWriteOffAddrOp IntVec 4 W32) = 1080-primOpTag (VecWriteOffAddrOp IntVec 2 W64) = 1081-primOpTag (VecWriteOffAddrOp IntVec 32 W8) = 1082-primOpTag (VecWriteOffAddrOp IntVec 16 W16) = 1083-primOpTag (VecWriteOffAddrOp IntVec 8 W32) = 1084-primOpTag (VecWriteOffAddrOp IntVec 4 W64) = 1085-primOpTag (VecWriteOffAddrOp IntVec 64 W8) = 1086-primOpTag (VecWriteOffAddrOp IntVec 32 W16) = 1087-primOpTag (VecWriteOffAddrOp IntVec 16 W32) = 1088-primOpTag (VecWriteOffAddrOp IntVec 8 W64) = 1089-primOpTag (VecWriteOffAddrOp WordVec 16 W8) = 1090-primOpTag (VecWriteOffAddrOp WordVec 8 W16) = 1091-primOpTag (VecWriteOffAddrOp WordVec 4 W32) = 1092-primOpTag (VecWriteOffAddrOp WordVec 2 W64) = 1093-primOpTag (VecWriteOffAddrOp WordVec 32 W8) = 1094-primOpTag (VecWriteOffAddrOp WordVec 16 W16) = 1095-primOpTag (VecWriteOffAddrOp WordVec 8 W32) = 1096-primOpTag (VecWriteOffAddrOp WordVec 4 W64) = 1097-primOpTag (VecWriteOffAddrOp WordVec 64 W8) = 1098-primOpTag (VecWriteOffAddrOp WordVec 32 W16) = 1099-primOpTag (VecWriteOffAddrOp WordVec 16 W32) = 1100-primOpTag (VecWriteOffAddrOp WordVec 8 W64) = 1101-primOpTag (VecWriteOffAddrOp FloatVec 4 W32) = 1102-primOpTag (VecWriteOffAddrOp FloatVec 2 W64) = 1103-primOpTag (VecWriteOffAddrOp FloatVec 8 W32) = 1104-primOpTag (VecWriteOffAddrOp FloatVec 4 W64) = 1105-primOpTag (VecWriteOffAddrOp FloatVec 16 W32) = 1106-primOpTag (VecWriteOffAddrOp FloatVec 8 W64) = 1107-primOpTag (VecIndexScalarByteArrayOp IntVec 16 W8) = 1108-primOpTag (VecIndexScalarByteArrayOp IntVec 8 W16) = 1109-primOpTag (VecIndexScalarByteArrayOp IntVec 4 W32) = 1110-primOpTag (VecIndexScalarByteArrayOp IntVec 2 W64) = 1111-primOpTag (VecIndexScalarByteArrayOp IntVec 32 W8) = 1112-primOpTag (VecIndexScalarByteArrayOp IntVec 16 W16) = 1113-primOpTag (VecIndexScalarByteArrayOp IntVec 8 W32) = 1114-primOpTag (VecIndexScalarByteArrayOp IntVec 4 W64) = 1115-primOpTag (VecIndexScalarByteArrayOp IntVec 64 W8) = 1116-primOpTag (VecIndexScalarByteArrayOp IntVec 32 W16) = 1117-primOpTag (VecIndexScalarByteArrayOp IntVec 16 W32) = 1118-primOpTag (VecIndexScalarByteArrayOp IntVec 8 W64) = 1119-primOpTag (VecIndexScalarByteArrayOp WordVec 16 W8) = 1120-primOpTag (VecIndexScalarByteArrayOp WordVec 8 W16) = 1121-primOpTag (VecIndexScalarByteArrayOp WordVec 4 W32) = 1122-primOpTag (VecIndexScalarByteArrayOp WordVec 2 W64) = 1123-primOpTag (VecIndexScalarByteArrayOp WordVec 32 W8) = 1124-primOpTag (VecIndexScalarByteArrayOp WordVec 16 W16) = 1125-primOpTag (VecIndexScalarByteArrayOp WordVec 8 W32) = 1126-primOpTag (VecIndexScalarByteArrayOp WordVec 4 W64) = 1127-primOpTag (VecIndexScalarByteArrayOp WordVec 64 W8) = 1128-primOpTag (VecIndexScalarByteArrayOp WordVec 32 W16) = 1129-primOpTag (VecIndexScalarByteArrayOp WordVec 16 W32) = 1130-primOpTag (VecIndexScalarByteArrayOp WordVec 8 W64) = 1131-primOpTag (VecIndexScalarByteArrayOp FloatVec 4 W32) = 1132-primOpTag (VecIndexScalarByteArrayOp FloatVec 2 W64) = 1133-primOpTag (VecIndexScalarByteArrayOp FloatVec 8 W32) = 1134-primOpTag (VecIndexScalarByteArrayOp FloatVec 4 W64) = 1135-primOpTag (VecIndexScalarByteArrayOp FloatVec 16 W32) = 1136-primOpTag (VecIndexScalarByteArrayOp FloatVec 8 W64) = 1137-primOpTag (VecReadScalarByteArrayOp IntVec 16 W8) = 1138-primOpTag (VecReadScalarByteArrayOp IntVec 8 W16) = 1139-primOpTag (VecReadScalarByteArrayOp IntVec 4 W32) = 1140-primOpTag (VecReadScalarByteArrayOp IntVec 2 W64) = 1141-primOpTag (VecReadScalarByteArrayOp IntVec 32 W8) = 1142-primOpTag (VecReadScalarByteArrayOp IntVec 16 W16) = 1143-primOpTag (VecReadScalarByteArrayOp IntVec 8 W32) = 1144-primOpTag (VecReadScalarByteArrayOp IntVec 4 W64) = 1145-primOpTag (VecReadScalarByteArrayOp IntVec 64 W8) = 1146-primOpTag (VecReadScalarByteArrayOp IntVec 32 W16) = 1147-primOpTag (VecReadScalarByteArrayOp IntVec 16 W32) = 1148-primOpTag (VecReadScalarByteArrayOp IntVec 8 W64) = 1149-primOpTag (VecReadScalarByteArrayOp WordVec 16 W8) = 1150-primOpTag (VecReadScalarByteArrayOp WordVec 8 W16) = 1151-primOpTag (VecReadScalarByteArrayOp WordVec 4 W32) = 1152-primOpTag (VecReadScalarByteArrayOp WordVec 2 W64) = 1153-primOpTag (VecReadScalarByteArrayOp WordVec 32 W8) = 1154-primOpTag (VecReadScalarByteArrayOp WordVec 16 W16) = 1155-primOpTag (VecReadScalarByteArrayOp WordVec 8 W32) = 1156-primOpTag (VecReadScalarByteArrayOp WordVec 4 W64) = 1157-primOpTag (VecReadScalarByteArrayOp WordVec 64 W8) = 1158-primOpTag (VecReadScalarByteArrayOp WordVec 32 W16) = 1159-primOpTag (VecReadScalarByteArrayOp WordVec 16 W32) = 1160-primOpTag (VecReadScalarByteArrayOp WordVec 8 W64) = 1161-primOpTag (VecReadScalarByteArrayOp FloatVec 4 W32) = 1162-primOpTag (VecReadScalarByteArrayOp FloatVec 2 W64) = 1163-primOpTag (VecReadScalarByteArrayOp FloatVec 8 W32) = 1164-primOpTag (VecReadScalarByteArrayOp FloatVec 4 W64) = 1165-primOpTag (VecReadScalarByteArrayOp FloatVec 16 W32) = 1166-primOpTag (VecReadScalarByteArrayOp FloatVec 8 W64) = 1167-primOpTag (VecWriteScalarByteArrayOp IntVec 16 W8) = 1168-primOpTag (VecWriteScalarByteArrayOp IntVec 8 W16) = 1169-primOpTag (VecWriteScalarByteArrayOp IntVec 4 W32) = 1170-primOpTag (VecWriteScalarByteArrayOp IntVec 2 W64) = 1171-primOpTag (VecWriteScalarByteArrayOp IntVec 32 W8) = 1172-primOpTag (VecWriteScalarByteArrayOp IntVec 16 W16) = 1173-primOpTag (VecWriteScalarByteArrayOp IntVec 8 W32) = 1174-primOpTag (VecWriteScalarByteArrayOp IntVec 4 W64) = 1175-primOpTag (VecWriteScalarByteArrayOp IntVec 64 W8) = 1176-primOpTag (VecWriteScalarByteArrayOp IntVec 32 W16) = 1177-primOpTag (VecWriteScalarByteArrayOp IntVec 16 W32) = 1178-primOpTag (VecWriteScalarByteArrayOp IntVec 8 W64) = 1179-primOpTag (VecWriteScalarByteArrayOp WordVec 16 W8) = 1180-primOpTag (VecWriteScalarByteArrayOp WordVec 8 W16) = 1181-primOpTag (VecWriteScalarByteArrayOp WordVec 4 W32) = 1182-primOpTag (VecWriteScalarByteArrayOp WordVec 2 W64) = 1183-primOpTag (VecWriteScalarByteArrayOp WordVec 32 W8) = 1184-primOpTag (VecWriteScalarByteArrayOp WordVec 16 W16) = 1185-primOpTag (VecWriteScalarByteArrayOp WordVec 8 W32) = 1186-primOpTag (VecWriteScalarByteArrayOp WordVec 4 W64) = 1187-primOpTag (VecWriteScalarByteArrayOp WordVec 64 W8) = 1188-primOpTag (VecWriteScalarByteArrayOp WordVec 32 W16) = 1189-primOpTag (VecWriteScalarByteArrayOp WordVec 16 W32) = 1190-primOpTag (VecWriteScalarByteArrayOp WordVec 8 W64) = 1191-primOpTag (VecWriteScalarByteArrayOp FloatVec 4 W32) = 1192-primOpTag (VecWriteScalarByteArrayOp FloatVec 2 W64) = 1193-primOpTag (VecWriteScalarByteArrayOp FloatVec 8 W32) = 1194-primOpTag (VecWriteScalarByteArrayOp FloatVec 4 W64) = 1195-primOpTag (VecWriteScalarByteArrayOp FloatVec 16 W32) = 1196-primOpTag (VecWriteScalarByteArrayOp FloatVec 8 W64) = 1197-primOpTag (VecIndexScalarOffAddrOp IntVec 16 W8) = 1198-primOpTag (VecIndexScalarOffAddrOp IntVec 8 W16) = 1199-primOpTag (VecIndexScalarOffAddrOp IntVec 4 W32) = 1200-primOpTag (VecIndexScalarOffAddrOp IntVec 2 W64) = 1201-primOpTag (VecIndexScalarOffAddrOp IntVec 32 W8) = 1202-primOpTag (VecIndexScalarOffAddrOp IntVec 16 W16) = 1203-primOpTag (VecIndexScalarOffAddrOp IntVec 8 W32) = 1204-primOpTag (VecIndexScalarOffAddrOp IntVec 4 W64) = 1205-primOpTag (VecIndexScalarOffAddrOp IntVec 64 W8) = 1206-primOpTag (VecIndexScalarOffAddrOp IntVec 32 W16) = 1207-primOpTag (VecIndexScalarOffAddrOp IntVec 16 W32) = 1208-primOpTag (VecIndexScalarOffAddrOp IntVec 8 W64) = 1209-primOpTag (VecIndexScalarOffAddrOp WordVec 16 W8) = 1210-primOpTag (VecIndexScalarOffAddrOp WordVec 8 W16) = 1211-primOpTag (VecIndexScalarOffAddrOp WordVec 4 W32) = 1212-primOpTag (VecIndexScalarOffAddrOp WordVec 2 W64) = 1213-primOpTag (VecIndexScalarOffAddrOp WordVec 32 W8) = 1214-primOpTag (VecIndexScalarOffAddrOp WordVec 16 W16) = 1215-primOpTag (VecIndexScalarOffAddrOp WordVec 8 W32) = 1216-primOpTag (VecIndexScalarOffAddrOp WordVec 4 W64) = 1217-primOpTag (VecIndexScalarOffAddrOp WordVec 64 W8) = 1218-primOpTag (VecIndexScalarOffAddrOp WordVec 32 W16) = 1219-primOpTag (VecIndexScalarOffAddrOp WordVec 16 W32) = 1220-primOpTag (VecIndexScalarOffAddrOp WordVec 8 W64) = 1221-primOpTag (VecIndexScalarOffAddrOp FloatVec 4 W32) = 1222-primOpTag (VecIndexScalarOffAddrOp FloatVec 2 W64) = 1223-primOpTag (VecIndexScalarOffAddrOp FloatVec 8 W32) = 1224-primOpTag (VecIndexScalarOffAddrOp FloatVec 4 W64) = 1225-primOpTag (VecIndexScalarOffAddrOp FloatVec 16 W32) = 1226-primOpTag (VecIndexScalarOffAddrOp FloatVec 8 W64) = 1227-primOpTag (VecReadScalarOffAddrOp IntVec 16 W8) = 1228-primOpTag (VecReadScalarOffAddrOp IntVec 8 W16) = 1229-primOpTag (VecReadScalarOffAddrOp IntVec 4 W32) = 1230-primOpTag (VecReadScalarOffAddrOp IntVec 2 W64) = 1231-primOpTag (VecReadScalarOffAddrOp IntVec 32 W8) = 1232-primOpTag (VecReadScalarOffAddrOp IntVec 16 W16) = 1233-primOpTag (VecReadScalarOffAddrOp IntVec 8 W32) = 1234-primOpTag (VecReadScalarOffAddrOp IntVec 4 W64) = 1235-primOpTag (VecReadScalarOffAddrOp IntVec 64 W8) = 1236-primOpTag (VecReadScalarOffAddrOp IntVec 32 W16) = 1237-primOpTag (VecReadScalarOffAddrOp IntVec 16 W32) = 1238-primOpTag (VecReadScalarOffAddrOp IntVec 8 W64) = 1239-primOpTag (VecReadScalarOffAddrOp WordVec 16 W8) = 1240-primOpTag (VecReadScalarOffAddrOp WordVec 8 W16) = 1241-primOpTag (VecReadScalarOffAddrOp WordVec 4 W32) = 1242-primOpTag (VecReadScalarOffAddrOp WordVec 2 W64) = 1243-primOpTag (VecReadScalarOffAddrOp WordVec 32 W8) = 1244-primOpTag (VecReadScalarOffAddrOp WordVec 16 W16) = 1245-primOpTag (VecReadScalarOffAddrOp WordVec 8 W32) = 1246-primOpTag (VecReadScalarOffAddrOp WordVec 4 W64) = 1247-primOpTag (VecReadScalarOffAddrOp WordVec 64 W8) = 1248-primOpTag (VecReadScalarOffAddrOp WordVec 32 W16) = 1249-primOpTag (VecReadScalarOffAddrOp WordVec 16 W32) = 1250-primOpTag (VecReadScalarOffAddrOp WordVec 8 W64) = 1251-primOpTag (VecReadScalarOffAddrOp FloatVec 4 W32) = 1252-primOpTag (VecReadScalarOffAddrOp FloatVec 2 W64) = 1253-primOpTag (VecReadScalarOffAddrOp FloatVec 8 W32) = 1254-primOpTag (VecReadScalarOffAddrOp FloatVec 4 W64) = 1255-primOpTag (VecReadScalarOffAddrOp FloatVec 16 W32) = 1256-primOpTag (VecReadScalarOffAddrOp FloatVec 8 W64) = 1257-primOpTag (VecWriteScalarOffAddrOp IntVec 16 W8) = 1258-primOpTag (VecWriteScalarOffAddrOp IntVec 8 W16) = 1259-primOpTag (VecWriteScalarOffAddrOp IntVec 4 W32) = 1260-primOpTag (VecWriteScalarOffAddrOp IntVec 2 W64) = 1261-primOpTag (VecWriteScalarOffAddrOp IntVec 32 W8) = 1262-primOpTag (VecWriteScalarOffAddrOp IntVec 16 W16) = 1263-primOpTag (VecWriteScalarOffAddrOp IntVec 8 W32) = 1264-primOpTag (VecWriteScalarOffAddrOp IntVec 4 W64) = 1265-primOpTag (VecWriteScalarOffAddrOp IntVec 64 W8) = 1266-primOpTag (VecWriteScalarOffAddrOp IntVec 32 W16) = 1267-primOpTag (VecWriteScalarOffAddrOp IntVec 16 W32) = 1268-primOpTag (VecWriteScalarOffAddrOp IntVec 8 W64) = 1269-primOpTag (VecWriteScalarOffAddrOp WordVec 16 W8) = 1270-primOpTag (VecWriteScalarOffAddrOp WordVec 8 W16) = 1271-primOpTag (VecWriteScalarOffAddrOp WordVec 4 W32) = 1272-primOpTag (VecWriteScalarOffAddrOp WordVec 2 W64) = 1273-primOpTag (VecWriteScalarOffAddrOp WordVec 32 W8) = 1274-primOpTag (VecWriteScalarOffAddrOp WordVec 16 W16) = 1275-primOpTag (VecWriteScalarOffAddrOp WordVec 8 W32) = 1276-primOpTag (VecWriteScalarOffAddrOp WordVec 4 W64) = 1277-primOpTag (VecWriteScalarOffAddrOp WordVec 64 W8) = 1278-primOpTag (VecWriteScalarOffAddrOp WordVec 32 W16) = 1279-primOpTag (VecWriteScalarOffAddrOp WordVec 16 W32) = 1280-primOpTag (VecWriteScalarOffAddrOp WordVec 8 W64) = 1281-primOpTag (VecWriteScalarOffAddrOp FloatVec 4 W32) = 1282-primOpTag (VecWriteScalarOffAddrOp FloatVec 2 W64) = 1283-primOpTag (VecWriteScalarOffAddrOp FloatVec 8 W32) = 1284-primOpTag (VecWriteScalarOffAddrOp FloatVec 4 W64) = 1285-primOpTag (VecWriteScalarOffAddrOp FloatVec 16 W32) = 1286-primOpTag (VecWriteScalarOffAddrOp FloatVec 8 W64) = 1287-primOpTag PrefetchByteArrayOp3 = 1288-primOpTag PrefetchMutableByteArrayOp3 = 1289-primOpTag PrefetchAddrOp3 = 1290-primOpTag PrefetchValueOp3 = 1291-primOpTag PrefetchByteArrayOp2 = 1292-primOpTag PrefetchMutableByteArrayOp2 = 1293-primOpTag PrefetchAddrOp2 = 1294-primOpTag PrefetchValueOp2 = 1295-primOpTag PrefetchByteArrayOp1 = 1296-primOpTag PrefetchMutableByteArrayOp1 = 1297-primOpTag PrefetchAddrOp1 = 1298-primOpTag PrefetchValueOp1 = 1299-primOpTag PrefetchByteArrayOp0 = 1300-primOpTag PrefetchMutableByteArrayOp0 = 1301-primOpTag PrefetchAddrOp0 = 1302-primOpTag PrefetchValueOp0 = 1303+maxPrimOpTag = 1305+primOpTag :: PrimOp -> Int+primOpTag CharGtOp = 0+primOpTag CharGeOp = 1+primOpTag CharEqOp = 2+primOpTag CharNeOp = 3+primOpTag CharLtOp = 4+primOpTag CharLeOp = 5+primOpTag OrdOp = 6+primOpTag Int8ToIntOp = 7+primOpTag IntToInt8Op = 8+primOpTag Int8NegOp = 9+primOpTag Int8AddOp = 10+primOpTag Int8SubOp = 11+primOpTag Int8MulOp = 12+primOpTag Int8QuotOp = 13+primOpTag Int8RemOp = 14+primOpTag Int8QuotRemOp = 15+primOpTag Int8SllOp = 16+primOpTag Int8SraOp = 17+primOpTag Int8SrlOp = 18+primOpTag Int8ToWord8Op = 19+primOpTag Int8EqOp = 20+primOpTag Int8GeOp = 21+primOpTag Int8GtOp = 22+primOpTag Int8LeOp = 23+primOpTag Int8LtOp = 24+primOpTag Int8NeOp = 25+primOpTag Word8ToWordOp = 26+primOpTag WordToWord8Op = 27+primOpTag Word8AddOp = 28+primOpTag Word8SubOp = 29+primOpTag Word8MulOp = 30+primOpTag Word8QuotOp = 31+primOpTag Word8RemOp = 32+primOpTag Word8QuotRemOp = 33+primOpTag Word8AndOp = 34+primOpTag Word8OrOp = 35+primOpTag Word8XorOp = 36+primOpTag Word8NotOp = 37+primOpTag Word8SllOp = 38+primOpTag Word8SrlOp = 39+primOpTag Word8ToInt8Op = 40+primOpTag Word8EqOp = 41+primOpTag Word8GeOp = 42+primOpTag Word8GtOp = 43+primOpTag Word8LeOp = 44+primOpTag Word8LtOp = 45+primOpTag Word8NeOp = 46+primOpTag Int16ToIntOp = 47+primOpTag IntToInt16Op = 48+primOpTag Int16NegOp = 49+primOpTag Int16AddOp = 50+primOpTag Int16SubOp = 51+primOpTag Int16MulOp = 52+primOpTag Int16QuotOp = 53+primOpTag Int16RemOp = 54+primOpTag Int16QuotRemOp = 55+primOpTag Int16SllOp = 56+primOpTag Int16SraOp = 57+primOpTag Int16SrlOp = 58+primOpTag Int16ToWord16Op = 59+primOpTag Int16EqOp = 60+primOpTag Int16GeOp = 61+primOpTag Int16GtOp = 62+primOpTag Int16LeOp = 63+primOpTag Int16LtOp = 64+primOpTag Int16NeOp = 65+primOpTag Word16ToWordOp = 66+primOpTag WordToWord16Op = 67+primOpTag Word16AddOp = 68+primOpTag Word16SubOp = 69+primOpTag Word16MulOp = 70+primOpTag Word16QuotOp = 71+primOpTag Word16RemOp = 72+primOpTag Word16QuotRemOp = 73+primOpTag Word16AndOp = 74+primOpTag Word16OrOp = 75+primOpTag Word16XorOp = 76+primOpTag Word16NotOp = 77+primOpTag Word16SllOp = 78+primOpTag Word16SrlOp = 79+primOpTag Word16ToInt16Op = 80+primOpTag Word16EqOp = 81+primOpTag Word16GeOp = 82+primOpTag Word16GtOp = 83+primOpTag Word16LeOp = 84+primOpTag Word16LtOp = 85+primOpTag Word16NeOp = 86+primOpTag Int32ToIntOp = 87+primOpTag IntToInt32Op = 88+primOpTag Int32NegOp = 89+primOpTag Int32AddOp = 90+primOpTag Int32SubOp = 91+primOpTag Int32MulOp = 92+primOpTag Int32QuotOp = 93+primOpTag Int32RemOp = 94+primOpTag Int32QuotRemOp = 95+primOpTag Int32SllOp = 96+primOpTag Int32SraOp = 97+primOpTag Int32SrlOp = 98+primOpTag Int32ToWord32Op = 99+primOpTag Int32EqOp = 100+primOpTag Int32GeOp = 101+primOpTag Int32GtOp = 102+primOpTag Int32LeOp = 103+primOpTag Int32LtOp = 104+primOpTag Int32NeOp = 105+primOpTag Word32ToWordOp = 106+primOpTag WordToWord32Op = 107+primOpTag Word32AddOp = 108+primOpTag Word32SubOp = 109+primOpTag Word32MulOp = 110+primOpTag Word32QuotOp = 111+primOpTag Word32RemOp = 112+primOpTag Word32QuotRemOp = 113+primOpTag Word32AndOp = 114+primOpTag Word32OrOp = 115+primOpTag Word32XorOp = 116+primOpTag Word32NotOp = 117+primOpTag Word32SllOp = 118+primOpTag Word32SrlOp = 119+primOpTag Word32ToInt32Op = 120+primOpTag Word32EqOp = 121+primOpTag Word32GeOp = 122+primOpTag Word32GtOp = 123+primOpTag Word32LeOp = 124+primOpTag Word32LtOp = 125+primOpTag Word32NeOp = 126+primOpTag Int64ToIntOp = 127+primOpTag IntToInt64Op = 128+primOpTag Int64NegOp = 129+primOpTag Int64AddOp = 130+primOpTag Int64SubOp = 131+primOpTag Int64MulOp = 132+primOpTag Int64QuotOp = 133+primOpTag Int64RemOp = 134+primOpTag Int64SllOp = 135+primOpTag Int64SraOp = 136+primOpTag Int64SrlOp = 137+primOpTag Int64ToWord64Op = 138+primOpTag Int64EqOp = 139+primOpTag Int64GeOp = 140+primOpTag Int64GtOp = 141+primOpTag Int64LeOp = 142+primOpTag Int64LtOp = 143+primOpTag Int64NeOp = 144+primOpTag Word64ToWordOp = 145+primOpTag WordToWord64Op = 146+primOpTag Word64AddOp = 147+primOpTag Word64SubOp = 148+primOpTag Word64MulOp = 149+primOpTag Word64QuotOp = 150+primOpTag Word64RemOp = 151+primOpTag Word64AndOp = 152+primOpTag Word64OrOp = 153+primOpTag Word64XorOp = 154+primOpTag Word64NotOp = 155+primOpTag Word64SllOp = 156+primOpTag Word64SrlOp = 157+primOpTag Word64ToInt64Op = 158+primOpTag Word64EqOp = 159+primOpTag Word64GeOp = 160+primOpTag Word64GtOp = 161+primOpTag Word64LeOp = 162+primOpTag Word64LtOp = 163+primOpTag Word64NeOp = 164+primOpTag IntAddOp = 165+primOpTag IntSubOp = 166+primOpTag IntMulOp = 167+primOpTag IntMul2Op = 168+primOpTag IntMulMayOfloOp = 169+primOpTag IntQuotOp = 170+primOpTag IntRemOp = 171+primOpTag IntQuotRemOp = 172+primOpTag IntAndOp = 173+primOpTag IntOrOp = 174+primOpTag IntXorOp = 175+primOpTag IntNotOp = 176+primOpTag IntNegOp = 177+primOpTag IntAddCOp = 178+primOpTag IntSubCOp = 179+primOpTag IntGtOp = 180+primOpTag IntGeOp = 181+primOpTag IntEqOp = 182+primOpTag IntNeOp = 183+primOpTag IntLtOp = 184+primOpTag IntLeOp = 185+primOpTag ChrOp = 186+primOpTag IntToWordOp = 187+primOpTag IntToFloatOp = 188+primOpTag IntToDoubleOp = 189+primOpTag WordToFloatOp = 190+primOpTag WordToDoubleOp = 191+primOpTag IntSllOp = 192+primOpTag IntSraOp = 193+primOpTag IntSrlOp = 194+primOpTag WordAddOp = 195+primOpTag WordAddCOp = 196+primOpTag WordSubCOp = 197+primOpTag WordAdd2Op = 198+primOpTag WordSubOp = 199+primOpTag WordMulOp = 200+primOpTag WordMul2Op = 201+primOpTag WordQuotOp = 202+primOpTag WordRemOp = 203+primOpTag WordQuotRemOp = 204+primOpTag WordQuotRem2Op = 205+primOpTag WordAndOp = 206+primOpTag WordOrOp = 207+primOpTag WordXorOp = 208+primOpTag WordNotOp = 209+primOpTag WordSllOp = 210+primOpTag WordSrlOp = 211+primOpTag WordToIntOp = 212+primOpTag WordGtOp = 213+primOpTag WordGeOp = 214+primOpTag WordEqOp = 215+primOpTag WordNeOp = 216+primOpTag WordLtOp = 217+primOpTag WordLeOp = 218+primOpTag PopCnt8Op = 219+primOpTag PopCnt16Op = 220+primOpTag PopCnt32Op = 221+primOpTag PopCnt64Op = 222+primOpTag PopCntOp = 223+primOpTag Pdep8Op = 224+primOpTag Pdep16Op = 225+primOpTag Pdep32Op = 226+primOpTag Pdep64Op = 227+primOpTag PdepOp = 228+primOpTag Pext8Op = 229+primOpTag Pext16Op = 230+primOpTag Pext32Op = 231+primOpTag Pext64Op = 232+primOpTag PextOp = 233+primOpTag Clz8Op = 234+primOpTag Clz16Op = 235+primOpTag Clz32Op = 236+primOpTag Clz64Op = 237+primOpTag ClzOp = 238+primOpTag Ctz8Op = 239+primOpTag Ctz16Op = 240+primOpTag Ctz32Op = 241+primOpTag Ctz64Op = 242+primOpTag CtzOp = 243+primOpTag BSwap16Op = 244+primOpTag BSwap32Op = 245+primOpTag BSwap64Op = 246+primOpTag BSwapOp = 247+primOpTag BRev8Op = 248+primOpTag BRev16Op = 249+primOpTag BRev32Op = 250+primOpTag BRev64Op = 251+primOpTag BRevOp = 252+primOpTag Narrow8IntOp = 253+primOpTag Narrow16IntOp = 254+primOpTag Narrow32IntOp = 255+primOpTag Narrow8WordOp = 256+primOpTag Narrow16WordOp = 257+primOpTag Narrow32WordOp = 258+primOpTag DoubleGtOp = 259+primOpTag DoubleGeOp = 260+primOpTag DoubleEqOp = 261+primOpTag DoubleNeOp = 262+primOpTag DoubleLtOp = 263+primOpTag DoubleLeOp = 264+primOpTag DoubleAddOp = 265+primOpTag DoubleSubOp = 266+primOpTag DoubleMulOp = 267+primOpTag DoubleDivOp = 268+primOpTag DoubleNegOp = 269+primOpTag DoubleFabsOp = 270+primOpTag DoubleToIntOp = 271+primOpTag DoubleToFloatOp = 272+primOpTag DoubleExpOp = 273+primOpTag DoubleExpM1Op = 274+primOpTag DoubleLogOp = 275+primOpTag DoubleLog1POp = 276+primOpTag DoubleSqrtOp = 277+primOpTag DoubleSinOp = 278+primOpTag DoubleCosOp = 279+primOpTag DoubleTanOp = 280+primOpTag DoubleAsinOp = 281+primOpTag DoubleAcosOp = 282+primOpTag DoubleAtanOp = 283+primOpTag DoubleSinhOp = 284+primOpTag DoubleCoshOp = 285+primOpTag DoubleTanhOp = 286+primOpTag DoubleAsinhOp = 287+primOpTag DoubleAcoshOp = 288+primOpTag DoubleAtanhOp = 289+primOpTag DoublePowerOp = 290+primOpTag DoubleDecode_2IntOp = 291+primOpTag DoubleDecode_Int64Op = 292+primOpTag FloatGtOp = 293+primOpTag FloatGeOp = 294+primOpTag FloatEqOp = 295+primOpTag FloatNeOp = 296+primOpTag FloatLtOp = 297+primOpTag FloatLeOp = 298+primOpTag FloatAddOp = 299+primOpTag FloatSubOp = 300+primOpTag FloatMulOp = 301+primOpTag FloatDivOp = 302+primOpTag FloatNegOp = 303+primOpTag FloatFabsOp = 304+primOpTag FloatToIntOp = 305+primOpTag FloatExpOp = 306+primOpTag FloatExpM1Op = 307+primOpTag FloatLogOp = 308+primOpTag FloatLog1POp = 309+primOpTag FloatSqrtOp = 310+primOpTag FloatSinOp = 311+primOpTag FloatCosOp = 312+primOpTag FloatTanOp = 313+primOpTag FloatAsinOp = 314+primOpTag FloatAcosOp = 315+primOpTag FloatAtanOp = 316+primOpTag FloatSinhOp = 317+primOpTag FloatCoshOp = 318+primOpTag FloatTanhOp = 319+primOpTag FloatAsinhOp = 320+primOpTag FloatAcoshOp = 321+primOpTag FloatAtanhOp = 322+primOpTag FloatPowerOp = 323+primOpTag FloatToDoubleOp = 324+primOpTag FloatDecode_IntOp = 325+primOpTag NewArrayOp = 326+primOpTag ReadArrayOp = 327+primOpTag WriteArrayOp = 328+primOpTag SizeofArrayOp = 329+primOpTag SizeofMutableArrayOp = 330+primOpTag IndexArrayOp = 331+primOpTag UnsafeFreezeArrayOp = 332+primOpTag UnsafeThawArrayOp = 333+primOpTag CopyArrayOp = 334+primOpTag CopyMutableArrayOp = 335+primOpTag CloneArrayOp = 336+primOpTag CloneMutableArrayOp = 337+primOpTag FreezeArrayOp = 338+primOpTag ThawArrayOp = 339+primOpTag CasArrayOp = 340+primOpTag NewSmallArrayOp = 341+primOpTag ShrinkSmallMutableArrayOp_Char = 342+primOpTag ReadSmallArrayOp = 343+primOpTag WriteSmallArrayOp = 344+primOpTag SizeofSmallArrayOp = 345+primOpTag SizeofSmallMutableArrayOp = 346+primOpTag GetSizeofSmallMutableArrayOp = 347+primOpTag IndexSmallArrayOp = 348+primOpTag UnsafeFreezeSmallArrayOp = 349+primOpTag UnsafeThawSmallArrayOp = 350+primOpTag CopySmallArrayOp = 351+primOpTag CopySmallMutableArrayOp = 352+primOpTag CloneSmallArrayOp = 353+primOpTag CloneSmallMutableArrayOp = 354+primOpTag FreezeSmallArrayOp = 355+primOpTag ThawSmallArrayOp = 356+primOpTag CasSmallArrayOp = 357+primOpTag NewByteArrayOp_Char = 358+primOpTag NewPinnedByteArrayOp_Char = 359+primOpTag NewAlignedPinnedByteArrayOp_Char = 360+primOpTag MutableByteArrayIsPinnedOp = 361+primOpTag ByteArrayIsPinnedOp = 362+primOpTag ByteArrayContents_Char = 363+primOpTag MutableByteArrayContents_Char = 364+primOpTag ShrinkMutableByteArrayOp_Char = 365+primOpTag ResizeMutableByteArrayOp_Char = 366+primOpTag UnsafeFreezeByteArrayOp = 367+primOpTag SizeofByteArrayOp = 368+primOpTag SizeofMutableByteArrayOp = 369+primOpTag GetSizeofMutableByteArrayOp = 370+primOpTag IndexByteArrayOp_Char = 371+primOpTag IndexByteArrayOp_WideChar = 372+primOpTag IndexByteArrayOp_Int = 373+primOpTag IndexByteArrayOp_Word = 374+primOpTag IndexByteArrayOp_Addr = 375+primOpTag IndexByteArrayOp_Float = 376+primOpTag IndexByteArrayOp_Double = 377+primOpTag IndexByteArrayOp_StablePtr = 378+primOpTag IndexByteArrayOp_Int8 = 379+primOpTag IndexByteArrayOp_Int16 = 380+primOpTag IndexByteArrayOp_Int32 = 381+primOpTag IndexByteArrayOp_Int64 = 382+primOpTag IndexByteArrayOp_Word8 = 383+primOpTag IndexByteArrayOp_Word16 = 384+primOpTag IndexByteArrayOp_Word32 = 385+primOpTag IndexByteArrayOp_Word64 = 386+primOpTag IndexByteArrayOp_Word8AsChar = 387+primOpTag IndexByteArrayOp_Word8AsWideChar = 388+primOpTag IndexByteArrayOp_Word8AsInt = 389+primOpTag IndexByteArrayOp_Word8AsWord = 390+primOpTag IndexByteArrayOp_Word8AsAddr = 391+primOpTag IndexByteArrayOp_Word8AsFloat = 392+primOpTag IndexByteArrayOp_Word8AsDouble = 393+primOpTag IndexByteArrayOp_Word8AsStablePtr = 394+primOpTag IndexByteArrayOp_Word8AsInt16 = 395+primOpTag IndexByteArrayOp_Word8AsInt32 = 396+primOpTag IndexByteArrayOp_Word8AsInt64 = 397+primOpTag IndexByteArrayOp_Word8AsWord16 = 398+primOpTag IndexByteArrayOp_Word8AsWord32 = 399+primOpTag IndexByteArrayOp_Word8AsWord64 = 400+primOpTag ReadByteArrayOp_Char = 401+primOpTag ReadByteArrayOp_WideChar = 402+primOpTag ReadByteArrayOp_Int = 403+primOpTag ReadByteArrayOp_Word = 404+primOpTag ReadByteArrayOp_Addr = 405+primOpTag ReadByteArrayOp_Float = 406+primOpTag ReadByteArrayOp_Double = 407+primOpTag ReadByteArrayOp_StablePtr = 408+primOpTag ReadByteArrayOp_Int8 = 409+primOpTag ReadByteArrayOp_Int16 = 410+primOpTag ReadByteArrayOp_Int32 = 411+primOpTag ReadByteArrayOp_Int64 = 412+primOpTag ReadByteArrayOp_Word8 = 413+primOpTag ReadByteArrayOp_Word16 = 414+primOpTag ReadByteArrayOp_Word32 = 415+primOpTag ReadByteArrayOp_Word64 = 416+primOpTag ReadByteArrayOp_Word8AsChar = 417+primOpTag ReadByteArrayOp_Word8AsWideChar = 418+primOpTag ReadByteArrayOp_Word8AsInt = 419+primOpTag ReadByteArrayOp_Word8AsWord = 420+primOpTag ReadByteArrayOp_Word8AsAddr = 421+primOpTag ReadByteArrayOp_Word8AsFloat = 422+primOpTag ReadByteArrayOp_Word8AsDouble = 423+primOpTag ReadByteArrayOp_Word8AsStablePtr = 424+primOpTag ReadByteArrayOp_Word8AsInt16 = 425+primOpTag ReadByteArrayOp_Word8AsInt32 = 426+primOpTag ReadByteArrayOp_Word8AsInt64 = 427+primOpTag ReadByteArrayOp_Word8AsWord16 = 428+primOpTag ReadByteArrayOp_Word8AsWord32 = 429+primOpTag ReadByteArrayOp_Word8AsWord64 = 430+primOpTag WriteByteArrayOp_Char = 431+primOpTag WriteByteArrayOp_WideChar = 432+primOpTag WriteByteArrayOp_Int = 433+primOpTag WriteByteArrayOp_Word = 434+primOpTag WriteByteArrayOp_Addr = 435+primOpTag WriteByteArrayOp_Float = 436+primOpTag WriteByteArrayOp_Double = 437+primOpTag WriteByteArrayOp_StablePtr = 438+primOpTag WriteByteArrayOp_Int8 = 439+primOpTag WriteByteArrayOp_Int16 = 440+primOpTag WriteByteArrayOp_Int32 = 441+primOpTag WriteByteArrayOp_Int64 = 442+primOpTag WriteByteArrayOp_Word8 = 443+primOpTag WriteByteArrayOp_Word16 = 444+primOpTag WriteByteArrayOp_Word32 = 445+primOpTag WriteByteArrayOp_Word64 = 446+primOpTag WriteByteArrayOp_Word8AsChar = 447+primOpTag WriteByteArrayOp_Word8AsWideChar = 448+primOpTag WriteByteArrayOp_Word8AsInt = 449+primOpTag WriteByteArrayOp_Word8AsWord = 450+primOpTag WriteByteArrayOp_Word8AsAddr = 451+primOpTag WriteByteArrayOp_Word8AsFloat = 452+primOpTag WriteByteArrayOp_Word8AsDouble = 453+primOpTag WriteByteArrayOp_Word8AsStablePtr = 454+primOpTag WriteByteArrayOp_Word8AsInt16 = 455+primOpTag WriteByteArrayOp_Word8AsInt32 = 456+primOpTag WriteByteArrayOp_Word8AsInt64 = 457+primOpTag WriteByteArrayOp_Word8AsWord16 = 458+primOpTag WriteByteArrayOp_Word8AsWord32 = 459+primOpTag WriteByteArrayOp_Word8AsWord64 = 460+primOpTag CompareByteArraysOp = 461+primOpTag CopyByteArrayOp = 462+primOpTag CopyMutableByteArrayOp = 463+primOpTag CopyByteArrayToAddrOp = 464+primOpTag CopyMutableByteArrayToAddrOp = 465+primOpTag CopyAddrToByteArrayOp = 466+primOpTag SetByteArrayOp = 467+primOpTag AtomicReadByteArrayOp_Int = 468+primOpTag AtomicWriteByteArrayOp_Int = 469+primOpTag CasByteArrayOp_Int = 470+primOpTag CasByteArrayOp_Int8 = 471+primOpTag CasByteArrayOp_Int16 = 472+primOpTag CasByteArrayOp_Int32 = 473+primOpTag CasByteArrayOp_Int64 = 474+primOpTag FetchAddByteArrayOp_Int = 475+primOpTag FetchSubByteArrayOp_Int = 476+primOpTag FetchAndByteArrayOp_Int = 477+primOpTag FetchNandByteArrayOp_Int = 478+primOpTag FetchOrByteArrayOp_Int = 479+primOpTag FetchXorByteArrayOp_Int = 480+primOpTag AddrAddOp = 481+primOpTag AddrSubOp = 482+primOpTag AddrRemOp = 483+primOpTag AddrToIntOp = 484+primOpTag IntToAddrOp = 485+primOpTag AddrGtOp = 486+primOpTag AddrGeOp = 487+primOpTag AddrEqOp = 488+primOpTag AddrNeOp = 489+primOpTag AddrLtOp = 490+primOpTag AddrLeOp = 491+primOpTag IndexOffAddrOp_Char = 492+primOpTag IndexOffAddrOp_WideChar = 493+primOpTag IndexOffAddrOp_Int = 494+primOpTag IndexOffAddrOp_Word = 495+primOpTag IndexOffAddrOp_Addr = 496+primOpTag IndexOffAddrOp_Float = 497+primOpTag IndexOffAddrOp_Double = 498+primOpTag IndexOffAddrOp_StablePtr = 499+primOpTag IndexOffAddrOp_Int8 = 500+primOpTag IndexOffAddrOp_Int16 = 501+primOpTag IndexOffAddrOp_Int32 = 502+primOpTag IndexOffAddrOp_Int64 = 503+primOpTag IndexOffAddrOp_Word8 = 504+primOpTag IndexOffAddrOp_Word16 = 505+primOpTag IndexOffAddrOp_Word32 = 506+primOpTag IndexOffAddrOp_Word64 = 507+primOpTag ReadOffAddrOp_Char = 508+primOpTag ReadOffAddrOp_WideChar = 509+primOpTag ReadOffAddrOp_Int = 510+primOpTag ReadOffAddrOp_Word = 511+primOpTag ReadOffAddrOp_Addr = 512+primOpTag ReadOffAddrOp_Float = 513+primOpTag ReadOffAddrOp_Double = 514+primOpTag ReadOffAddrOp_StablePtr = 515+primOpTag ReadOffAddrOp_Int8 = 516+primOpTag ReadOffAddrOp_Int16 = 517+primOpTag ReadOffAddrOp_Int32 = 518+primOpTag ReadOffAddrOp_Int64 = 519+primOpTag ReadOffAddrOp_Word8 = 520+primOpTag ReadOffAddrOp_Word16 = 521+primOpTag ReadOffAddrOp_Word32 = 522+primOpTag ReadOffAddrOp_Word64 = 523+primOpTag WriteOffAddrOp_Char = 524+primOpTag WriteOffAddrOp_WideChar = 525+primOpTag WriteOffAddrOp_Int = 526+primOpTag WriteOffAddrOp_Word = 527+primOpTag WriteOffAddrOp_Addr = 528+primOpTag WriteOffAddrOp_Float = 529+primOpTag WriteOffAddrOp_Double = 530+primOpTag WriteOffAddrOp_StablePtr = 531+primOpTag WriteOffAddrOp_Int8 = 532+primOpTag WriteOffAddrOp_Int16 = 533+primOpTag WriteOffAddrOp_Int32 = 534+primOpTag WriteOffAddrOp_Int64 = 535+primOpTag WriteOffAddrOp_Word8 = 536+primOpTag WriteOffAddrOp_Word16 = 537+primOpTag WriteOffAddrOp_Word32 = 538+primOpTag WriteOffAddrOp_Word64 = 539+primOpTag InterlockedExchange_Addr = 540+primOpTag InterlockedExchange_Word = 541+primOpTag CasAddrOp_Addr = 542+primOpTag CasAddrOp_Word = 543+primOpTag CasAddrOp_Word8 = 544+primOpTag CasAddrOp_Word16 = 545+primOpTag CasAddrOp_Word32 = 546+primOpTag CasAddrOp_Word64 = 547+primOpTag FetchAddAddrOp_Word = 548+primOpTag FetchSubAddrOp_Word = 549+primOpTag FetchAndAddrOp_Word = 550+primOpTag FetchNandAddrOp_Word = 551+primOpTag FetchOrAddrOp_Word = 552+primOpTag FetchXorAddrOp_Word = 553+primOpTag AtomicReadAddrOp_Word = 554+primOpTag AtomicWriteAddrOp_Word = 555+primOpTag NewMutVarOp = 556+primOpTag ReadMutVarOp = 557+primOpTag WriteMutVarOp = 558+primOpTag AtomicModifyMutVar2Op = 559+primOpTag AtomicModifyMutVar_Op = 560+primOpTag CasMutVarOp = 561+primOpTag CatchOp = 562+primOpTag RaiseOp = 563+primOpTag RaiseIOOp = 564+primOpTag MaskAsyncExceptionsOp = 565+primOpTag MaskUninterruptibleOp = 566+primOpTag UnmaskAsyncExceptionsOp = 567+primOpTag MaskStatus = 568+primOpTag AtomicallyOp = 569+primOpTag RetryOp = 570+primOpTag CatchRetryOp = 571+primOpTag CatchSTMOp = 572+primOpTag NewTVarOp = 573+primOpTag ReadTVarOp = 574+primOpTag ReadTVarIOOp = 575+primOpTag WriteTVarOp = 576+primOpTag NewMVarOp = 577+primOpTag TakeMVarOp = 578+primOpTag TryTakeMVarOp = 579+primOpTag PutMVarOp = 580+primOpTag TryPutMVarOp = 581+primOpTag ReadMVarOp = 582+primOpTag TryReadMVarOp = 583+primOpTag IsEmptyMVarOp = 584+primOpTag NewIOPortOp = 585+primOpTag ReadIOPortOp = 586+primOpTag WriteIOPortOp = 587+primOpTag DelayOp = 588+primOpTag WaitReadOp = 589+primOpTag WaitWriteOp = 590+primOpTag ForkOp = 591+primOpTag ForkOnOp = 592+primOpTag KillThreadOp = 593+primOpTag YieldOp = 594+primOpTag MyThreadIdOp = 595+primOpTag LabelThreadOp = 596+primOpTag IsCurrentThreadBoundOp = 597+primOpTag NoDuplicateOp = 598+primOpTag GetThreadLabelOp = 599+primOpTag ThreadStatusOp = 600+primOpTag ListThreadsOp = 601+primOpTag MkWeakOp = 602+primOpTag MkWeakNoFinalizerOp = 603+primOpTag AddCFinalizerToWeakOp = 604+primOpTag DeRefWeakOp = 605+primOpTag FinalizeWeakOp = 606+primOpTag TouchOp = 607+primOpTag MakeStablePtrOp = 608+primOpTag DeRefStablePtrOp = 609+primOpTag EqStablePtrOp = 610+primOpTag MakeStableNameOp = 611+primOpTag StableNameToIntOp = 612+primOpTag CompactNewOp = 613+primOpTag CompactResizeOp = 614+primOpTag CompactContainsOp = 615+primOpTag CompactContainsAnyOp = 616+primOpTag CompactGetFirstBlockOp = 617+primOpTag CompactGetNextBlockOp = 618+primOpTag CompactAllocateBlockOp = 619+primOpTag CompactFixupPointersOp = 620+primOpTag CompactAdd = 621+primOpTag CompactAddWithSharing = 622+primOpTag CompactSize = 623+primOpTag ReallyUnsafePtrEqualityOp = 624+primOpTag ParOp = 625+primOpTag SparkOp = 626+primOpTag SeqOp = 627+primOpTag GetSparkOp = 628+primOpTag NumSparks = 629+primOpTag KeepAliveOp = 630+primOpTag DataToTagOp = 631+primOpTag TagToEnumOp = 632+primOpTag AddrToAnyOp = 633+primOpTag AnyToAddrOp = 634+primOpTag MkApUpd0_Op = 635+primOpTag NewBCOOp = 636+primOpTag UnpackClosureOp = 637+primOpTag ClosureSizeOp = 638+primOpTag GetApStackValOp = 639+primOpTag GetCCSOfOp = 640+primOpTag GetCurrentCCSOp = 641+primOpTag ClearCCSOp = 642+primOpTag WhereFromOp = 643+primOpTag TraceEventOp = 644+primOpTag TraceEventBinaryOp = 645+primOpTag TraceMarkerOp = 646+primOpTag SetThreadAllocationCounter = 647+primOpTag (VecBroadcastOp IntVec 16 W8) = 648+primOpTag (VecBroadcastOp IntVec 8 W16) = 649+primOpTag (VecBroadcastOp IntVec 4 W32) = 650+primOpTag (VecBroadcastOp IntVec 2 W64) = 651+primOpTag (VecBroadcastOp IntVec 32 W8) = 652+primOpTag (VecBroadcastOp IntVec 16 W16) = 653+primOpTag (VecBroadcastOp IntVec 8 W32) = 654+primOpTag (VecBroadcastOp IntVec 4 W64) = 655+primOpTag (VecBroadcastOp IntVec 64 W8) = 656+primOpTag (VecBroadcastOp IntVec 32 W16) = 657+primOpTag (VecBroadcastOp IntVec 16 W32) = 658+primOpTag (VecBroadcastOp IntVec 8 W64) = 659+primOpTag (VecBroadcastOp WordVec 16 W8) = 660+primOpTag (VecBroadcastOp WordVec 8 W16) = 661+primOpTag (VecBroadcastOp WordVec 4 W32) = 662+primOpTag (VecBroadcastOp WordVec 2 W64) = 663+primOpTag (VecBroadcastOp WordVec 32 W8) = 664+primOpTag (VecBroadcastOp WordVec 16 W16) = 665+primOpTag (VecBroadcastOp WordVec 8 W32) = 666+primOpTag (VecBroadcastOp WordVec 4 W64) = 667+primOpTag (VecBroadcastOp WordVec 64 W8) = 668+primOpTag (VecBroadcastOp WordVec 32 W16) = 669+primOpTag (VecBroadcastOp WordVec 16 W32) = 670+primOpTag (VecBroadcastOp WordVec 8 W64) = 671+primOpTag (VecBroadcastOp FloatVec 4 W32) = 672+primOpTag (VecBroadcastOp FloatVec 2 W64) = 673+primOpTag (VecBroadcastOp FloatVec 8 W32) = 674+primOpTag (VecBroadcastOp FloatVec 4 W64) = 675+primOpTag (VecBroadcastOp FloatVec 16 W32) = 676+primOpTag (VecBroadcastOp FloatVec 8 W64) = 677+primOpTag (VecPackOp IntVec 16 W8) = 678+primOpTag (VecPackOp IntVec 8 W16) = 679+primOpTag (VecPackOp IntVec 4 W32) = 680+primOpTag (VecPackOp IntVec 2 W64) = 681+primOpTag (VecPackOp IntVec 32 W8) = 682+primOpTag (VecPackOp IntVec 16 W16) = 683+primOpTag (VecPackOp IntVec 8 W32) = 684+primOpTag (VecPackOp IntVec 4 W64) = 685+primOpTag (VecPackOp IntVec 64 W8) = 686+primOpTag (VecPackOp IntVec 32 W16) = 687+primOpTag (VecPackOp IntVec 16 W32) = 688+primOpTag (VecPackOp IntVec 8 W64) = 689+primOpTag (VecPackOp WordVec 16 W8) = 690+primOpTag (VecPackOp WordVec 8 W16) = 691+primOpTag (VecPackOp WordVec 4 W32) = 692+primOpTag (VecPackOp WordVec 2 W64) = 693+primOpTag (VecPackOp WordVec 32 W8) = 694+primOpTag (VecPackOp WordVec 16 W16) = 695+primOpTag (VecPackOp WordVec 8 W32) = 696+primOpTag (VecPackOp WordVec 4 W64) = 697+primOpTag (VecPackOp WordVec 64 W8) = 698+primOpTag (VecPackOp WordVec 32 W16) = 699+primOpTag (VecPackOp WordVec 16 W32) = 700+primOpTag (VecPackOp WordVec 8 W64) = 701+primOpTag (VecPackOp FloatVec 4 W32) = 702+primOpTag (VecPackOp FloatVec 2 W64) = 703+primOpTag (VecPackOp FloatVec 8 W32) = 704+primOpTag (VecPackOp FloatVec 4 W64) = 705+primOpTag (VecPackOp FloatVec 16 W32) = 706+primOpTag (VecPackOp FloatVec 8 W64) = 707+primOpTag (VecUnpackOp IntVec 16 W8) = 708+primOpTag (VecUnpackOp IntVec 8 W16) = 709+primOpTag (VecUnpackOp IntVec 4 W32) = 710+primOpTag (VecUnpackOp IntVec 2 W64) = 711+primOpTag (VecUnpackOp IntVec 32 W8) = 712+primOpTag (VecUnpackOp IntVec 16 W16) = 713+primOpTag (VecUnpackOp IntVec 8 W32) = 714+primOpTag (VecUnpackOp IntVec 4 W64) = 715+primOpTag (VecUnpackOp IntVec 64 W8) = 716+primOpTag (VecUnpackOp IntVec 32 W16) = 717+primOpTag (VecUnpackOp IntVec 16 W32) = 718+primOpTag (VecUnpackOp IntVec 8 W64) = 719+primOpTag (VecUnpackOp WordVec 16 W8) = 720+primOpTag (VecUnpackOp WordVec 8 W16) = 721+primOpTag (VecUnpackOp WordVec 4 W32) = 722+primOpTag (VecUnpackOp WordVec 2 W64) = 723+primOpTag (VecUnpackOp WordVec 32 W8) = 724+primOpTag (VecUnpackOp WordVec 16 W16) = 725+primOpTag (VecUnpackOp WordVec 8 W32) = 726+primOpTag (VecUnpackOp WordVec 4 W64) = 727+primOpTag (VecUnpackOp WordVec 64 W8) = 728+primOpTag (VecUnpackOp WordVec 32 W16) = 729+primOpTag (VecUnpackOp WordVec 16 W32) = 730+primOpTag (VecUnpackOp WordVec 8 W64) = 731+primOpTag (VecUnpackOp FloatVec 4 W32) = 732+primOpTag (VecUnpackOp FloatVec 2 W64) = 733+primOpTag (VecUnpackOp FloatVec 8 W32) = 734+primOpTag (VecUnpackOp FloatVec 4 W64) = 735+primOpTag (VecUnpackOp FloatVec 16 W32) = 736+primOpTag (VecUnpackOp FloatVec 8 W64) = 737+primOpTag (VecInsertOp IntVec 16 W8) = 738+primOpTag (VecInsertOp IntVec 8 W16) = 739+primOpTag (VecInsertOp IntVec 4 W32) = 740+primOpTag (VecInsertOp IntVec 2 W64) = 741+primOpTag (VecInsertOp IntVec 32 W8) = 742+primOpTag (VecInsertOp IntVec 16 W16) = 743+primOpTag (VecInsertOp IntVec 8 W32) = 744+primOpTag (VecInsertOp IntVec 4 W64) = 745+primOpTag (VecInsertOp IntVec 64 W8) = 746+primOpTag (VecInsertOp IntVec 32 W16) = 747+primOpTag (VecInsertOp IntVec 16 W32) = 748+primOpTag (VecInsertOp IntVec 8 W64) = 749+primOpTag (VecInsertOp WordVec 16 W8) = 750+primOpTag (VecInsertOp WordVec 8 W16) = 751+primOpTag (VecInsertOp WordVec 4 W32) = 752+primOpTag (VecInsertOp WordVec 2 W64) = 753+primOpTag (VecInsertOp WordVec 32 W8) = 754+primOpTag (VecInsertOp WordVec 16 W16) = 755+primOpTag (VecInsertOp WordVec 8 W32) = 756+primOpTag (VecInsertOp WordVec 4 W64) = 757+primOpTag (VecInsertOp WordVec 64 W8) = 758+primOpTag (VecInsertOp WordVec 32 W16) = 759+primOpTag (VecInsertOp WordVec 16 W32) = 760+primOpTag (VecInsertOp WordVec 8 W64) = 761+primOpTag (VecInsertOp FloatVec 4 W32) = 762+primOpTag (VecInsertOp FloatVec 2 W64) = 763+primOpTag (VecInsertOp FloatVec 8 W32) = 764+primOpTag (VecInsertOp FloatVec 4 W64) = 765+primOpTag (VecInsertOp FloatVec 16 W32) = 766+primOpTag (VecInsertOp FloatVec 8 W64) = 767+primOpTag (VecAddOp IntVec 16 W8) = 768+primOpTag (VecAddOp IntVec 8 W16) = 769+primOpTag (VecAddOp IntVec 4 W32) = 770+primOpTag (VecAddOp IntVec 2 W64) = 771+primOpTag (VecAddOp IntVec 32 W8) = 772+primOpTag (VecAddOp IntVec 16 W16) = 773+primOpTag (VecAddOp IntVec 8 W32) = 774+primOpTag (VecAddOp IntVec 4 W64) = 775+primOpTag (VecAddOp IntVec 64 W8) = 776+primOpTag (VecAddOp IntVec 32 W16) = 777+primOpTag (VecAddOp IntVec 16 W32) = 778+primOpTag (VecAddOp IntVec 8 W64) = 779+primOpTag (VecAddOp WordVec 16 W8) = 780+primOpTag (VecAddOp WordVec 8 W16) = 781+primOpTag (VecAddOp WordVec 4 W32) = 782+primOpTag (VecAddOp WordVec 2 W64) = 783+primOpTag (VecAddOp WordVec 32 W8) = 784+primOpTag (VecAddOp WordVec 16 W16) = 785+primOpTag (VecAddOp WordVec 8 W32) = 786+primOpTag (VecAddOp WordVec 4 W64) = 787+primOpTag (VecAddOp WordVec 64 W8) = 788+primOpTag (VecAddOp WordVec 32 W16) = 789+primOpTag (VecAddOp WordVec 16 W32) = 790+primOpTag (VecAddOp WordVec 8 W64) = 791+primOpTag (VecAddOp FloatVec 4 W32) = 792+primOpTag (VecAddOp FloatVec 2 W64) = 793+primOpTag (VecAddOp FloatVec 8 W32) = 794+primOpTag (VecAddOp FloatVec 4 W64) = 795+primOpTag (VecAddOp FloatVec 16 W32) = 796+primOpTag (VecAddOp FloatVec 8 W64) = 797+primOpTag (VecSubOp IntVec 16 W8) = 798+primOpTag (VecSubOp IntVec 8 W16) = 799+primOpTag (VecSubOp IntVec 4 W32) = 800+primOpTag (VecSubOp IntVec 2 W64) = 801+primOpTag (VecSubOp IntVec 32 W8) = 802+primOpTag (VecSubOp IntVec 16 W16) = 803+primOpTag (VecSubOp IntVec 8 W32) = 804+primOpTag (VecSubOp IntVec 4 W64) = 805+primOpTag (VecSubOp IntVec 64 W8) = 806+primOpTag (VecSubOp IntVec 32 W16) = 807+primOpTag (VecSubOp IntVec 16 W32) = 808+primOpTag (VecSubOp IntVec 8 W64) = 809+primOpTag (VecSubOp WordVec 16 W8) = 810+primOpTag (VecSubOp WordVec 8 W16) = 811+primOpTag (VecSubOp WordVec 4 W32) = 812+primOpTag (VecSubOp WordVec 2 W64) = 813+primOpTag (VecSubOp WordVec 32 W8) = 814+primOpTag (VecSubOp WordVec 16 W16) = 815+primOpTag (VecSubOp WordVec 8 W32) = 816+primOpTag (VecSubOp WordVec 4 W64) = 817+primOpTag (VecSubOp WordVec 64 W8) = 818+primOpTag (VecSubOp WordVec 32 W16) = 819+primOpTag (VecSubOp WordVec 16 W32) = 820+primOpTag (VecSubOp WordVec 8 W64) = 821+primOpTag (VecSubOp FloatVec 4 W32) = 822+primOpTag (VecSubOp FloatVec 2 W64) = 823+primOpTag (VecSubOp FloatVec 8 W32) = 824+primOpTag (VecSubOp FloatVec 4 W64) = 825+primOpTag (VecSubOp FloatVec 16 W32) = 826+primOpTag (VecSubOp FloatVec 8 W64) = 827+primOpTag (VecMulOp IntVec 16 W8) = 828+primOpTag (VecMulOp IntVec 8 W16) = 829+primOpTag (VecMulOp IntVec 4 W32) = 830+primOpTag (VecMulOp IntVec 2 W64) = 831+primOpTag (VecMulOp IntVec 32 W8) = 832+primOpTag (VecMulOp IntVec 16 W16) = 833+primOpTag (VecMulOp IntVec 8 W32) = 834+primOpTag (VecMulOp IntVec 4 W64) = 835+primOpTag (VecMulOp IntVec 64 W8) = 836+primOpTag (VecMulOp IntVec 32 W16) = 837+primOpTag (VecMulOp IntVec 16 W32) = 838+primOpTag (VecMulOp IntVec 8 W64) = 839+primOpTag (VecMulOp WordVec 16 W8) = 840+primOpTag (VecMulOp WordVec 8 W16) = 841+primOpTag (VecMulOp WordVec 4 W32) = 842+primOpTag (VecMulOp WordVec 2 W64) = 843+primOpTag (VecMulOp WordVec 32 W8) = 844+primOpTag (VecMulOp WordVec 16 W16) = 845+primOpTag (VecMulOp WordVec 8 W32) = 846+primOpTag (VecMulOp WordVec 4 W64) = 847+primOpTag (VecMulOp WordVec 64 W8) = 848+primOpTag (VecMulOp WordVec 32 W16) = 849+primOpTag (VecMulOp WordVec 16 W32) = 850+primOpTag (VecMulOp WordVec 8 W64) = 851+primOpTag (VecMulOp FloatVec 4 W32) = 852+primOpTag (VecMulOp FloatVec 2 W64) = 853+primOpTag (VecMulOp FloatVec 8 W32) = 854+primOpTag (VecMulOp FloatVec 4 W64) = 855+primOpTag (VecMulOp FloatVec 16 W32) = 856+primOpTag (VecMulOp FloatVec 8 W64) = 857+primOpTag (VecDivOp FloatVec 4 W32) = 858+primOpTag (VecDivOp FloatVec 2 W64) = 859+primOpTag (VecDivOp FloatVec 8 W32) = 860+primOpTag (VecDivOp FloatVec 4 W64) = 861+primOpTag (VecDivOp FloatVec 16 W32) = 862+primOpTag (VecDivOp FloatVec 8 W64) = 863+primOpTag (VecQuotOp IntVec 16 W8) = 864+primOpTag (VecQuotOp IntVec 8 W16) = 865+primOpTag (VecQuotOp IntVec 4 W32) = 866+primOpTag (VecQuotOp IntVec 2 W64) = 867+primOpTag (VecQuotOp IntVec 32 W8) = 868+primOpTag (VecQuotOp IntVec 16 W16) = 869+primOpTag (VecQuotOp IntVec 8 W32) = 870+primOpTag (VecQuotOp IntVec 4 W64) = 871+primOpTag (VecQuotOp IntVec 64 W8) = 872+primOpTag (VecQuotOp IntVec 32 W16) = 873+primOpTag (VecQuotOp IntVec 16 W32) = 874+primOpTag (VecQuotOp IntVec 8 W64) = 875+primOpTag (VecQuotOp WordVec 16 W8) = 876+primOpTag (VecQuotOp WordVec 8 W16) = 877+primOpTag (VecQuotOp WordVec 4 W32) = 878+primOpTag (VecQuotOp WordVec 2 W64) = 879+primOpTag (VecQuotOp WordVec 32 W8) = 880+primOpTag (VecQuotOp WordVec 16 W16) = 881+primOpTag (VecQuotOp WordVec 8 W32) = 882+primOpTag (VecQuotOp WordVec 4 W64) = 883+primOpTag (VecQuotOp WordVec 64 W8) = 884+primOpTag (VecQuotOp WordVec 32 W16) = 885+primOpTag (VecQuotOp WordVec 16 W32) = 886+primOpTag (VecQuotOp WordVec 8 W64) = 887+primOpTag (VecRemOp IntVec 16 W8) = 888+primOpTag (VecRemOp IntVec 8 W16) = 889+primOpTag (VecRemOp IntVec 4 W32) = 890+primOpTag (VecRemOp IntVec 2 W64) = 891+primOpTag (VecRemOp IntVec 32 W8) = 892+primOpTag (VecRemOp IntVec 16 W16) = 893+primOpTag (VecRemOp IntVec 8 W32) = 894+primOpTag (VecRemOp IntVec 4 W64) = 895+primOpTag (VecRemOp IntVec 64 W8) = 896+primOpTag (VecRemOp IntVec 32 W16) = 897+primOpTag (VecRemOp IntVec 16 W32) = 898+primOpTag (VecRemOp IntVec 8 W64) = 899+primOpTag (VecRemOp WordVec 16 W8) = 900+primOpTag (VecRemOp WordVec 8 W16) = 901+primOpTag (VecRemOp WordVec 4 W32) = 902+primOpTag (VecRemOp WordVec 2 W64) = 903+primOpTag (VecRemOp WordVec 32 W8) = 904+primOpTag (VecRemOp WordVec 16 W16) = 905+primOpTag (VecRemOp WordVec 8 W32) = 906+primOpTag (VecRemOp WordVec 4 W64) = 907+primOpTag (VecRemOp WordVec 64 W8) = 908+primOpTag (VecRemOp WordVec 32 W16) = 909+primOpTag (VecRemOp WordVec 16 W32) = 910+primOpTag (VecRemOp WordVec 8 W64) = 911+primOpTag (VecNegOp IntVec 16 W8) = 912+primOpTag (VecNegOp IntVec 8 W16) = 913+primOpTag (VecNegOp IntVec 4 W32) = 914+primOpTag (VecNegOp IntVec 2 W64) = 915+primOpTag (VecNegOp IntVec 32 W8) = 916+primOpTag (VecNegOp IntVec 16 W16) = 917+primOpTag (VecNegOp IntVec 8 W32) = 918+primOpTag (VecNegOp IntVec 4 W64) = 919+primOpTag (VecNegOp IntVec 64 W8) = 920+primOpTag (VecNegOp IntVec 32 W16) = 921+primOpTag (VecNegOp IntVec 16 W32) = 922+primOpTag (VecNegOp IntVec 8 W64) = 923+primOpTag (VecNegOp FloatVec 4 W32) = 924+primOpTag (VecNegOp FloatVec 2 W64) = 925+primOpTag (VecNegOp FloatVec 8 W32) = 926+primOpTag (VecNegOp FloatVec 4 W64) = 927+primOpTag (VecNegOp FloatVec 16 W32) = 928+primOpTag (VecNegOp FloatVec 8 W64) = 929+primOpTag (VecIndexByteArrayOp IntVec 16 W8) = 930+primOpTag (VecIndexByteArrayOp IntVec 8 W16) = 931+primOpTag (VecIndexByteArrayOp IntVec 4 W32) = 932+primOpTag (VecIndexByteArrayOp IntVec 2 W64) = 933+primOpTag (VecIndexByteArrayOp IntVec 32 W8) = 934+primOpTag (VecIndexByteArrayOp IntVec 16 W16) = 935+primOpTag (VecIndexByteArrayOp IntVec 8 W32) = 936+primOpTag (VecIndexByteArrayOp IntVec 4 W64) = 937+primOpTag (VecIndexByteArrayOp IntVec 64 W8) = 938+primOpTag (VecIndexByteArrayOp IntVec 32 W16) = 939+primOpTag (VecIndexByteArrayOp IntVec 16 W32) = 940+primOpTag (VecIndexByteArrayOp IntVec 8 W64) = 941+primOpTag (VecIndexByteArrayOp WordVec 16 W8) = 942+primOpTag (VecIndexByteArrayOp WordVec 8 W16) = 943+primOpTag (VecIndexByteArrayOp WordVec 4 W32) = 944+primOpTag (VecIndexByteArrayOp WordVec 2 W64) = 945+primOpTag (VecIndexByteArrayOp WordVec 32 W8) = 946+primOpTag (VecIndexByteArrayOp WordVec 16 W16) = 947+primOpTag (VecIndexByteArrayOp WordVec 8 W32) = 948+primOpTag (VecIndexByteArrayOp WordVec 4 W64) = 949+primOpTag (VecIndexByteArrayOp WordVec 64 W8) = 950+primOpTag (VecIndexByteArrayOp WordVec 32 W16) = 951+primOpTag (VecIndexByteArrayOp WordVec 16 W32) = 952+primOpTag (VecIndexByteArrayOp WordVec 8 W64) = 953+primOpTag (VecIndexByteArrayOp FloatVec 4 W32) = 954+primOpTag (VecIndexByteArrayOp FloatVec 2 W64) = 955+primOpTag (VecIndexByteArrayOp FloatVec 8 W32) = 956+primOpTag (VecIndexByteArrayOp FloatVec 4 W64) = 957+primOpTag (VecIndexByteArrayOp FloatVec 16 W32) = 958+primOpTag (VecIndexByteArrayOp FloatVec 8 W64) = 959+primOpTag (VecReadByteArrayOp IntVec 16 W8) = 960+primOpTag (VecReadByteArrayOp IntVec 8 W16) = 961+primOpTag (VecReadByteArrayOp IntVec 4 W32) = 962+primOpTag (VecReadByteArrayOp IntVec 2 W64) = 963+primOpTag (VecReadByteArrayOp IntVec 32 W8) = 964+primOpTag (VecReadByteArrayOp IntVec 16 W16) = 965+primOpTag (VecReadByteArrayOp IntVec 8 W32) = 966+primOpTag (VecReadByteArrayOp IntVec 4 W64) = 967+primOpTag (VecReadByteArrayOp IntVec 64 W8) = 968+primOpTag (VecReadByteArrayOp IntVec 32 W16) = 969+primOpTag (VecReadByteArrayOp IntVec 16 W32) = 970+primOpTag (VecReadByteArrayOp IntVec 8 W64) = 971+primOpTag (VecReadByteArrayOp WordVec 16 W8) = 972+primOpTag (VecReadByteArrayOp WordVec 8 W16) = 973+primOpTag (VecReadByteArrayOp WordVec 4 W32) = 974+primOpTag (VecReadByteArrayOp WordVec 2 W64) = 975+primOpTag (VecReadByteArrayOp WordVec 32 W8) = 976+primOpTag (VecReadByteArrayOp WordVec 16 W16) = 977+primOpTag (VecReadByteArrayOp WordVec 8 W32) = 978+primOpTag (VecReadByteArrayOp WordVec 4 W64) = 979+primOpTag (VecReadByteArrayOp WordVec 64 W8) = 980+primOpTag (VecReadByteArrayOp WordVec 32 W16) = 981+primOpTag (VecReadByteArrayOp WordVec 16 W32) = 982+primOpTag (VecReadByteArrayOp WordVec 8 W64) = 983+primOpTag (VecReadByteArrayOp FloatVec 4 W32) = 984+primOpTag (VecReadByteArrayOp FloatVec 2 W64) = 985+primOpTag (VecReadByteArrayOp FloatVec 8 W32) = 986+primOpTag (VecReadByteArrayOp FloatVec 4 W64) = 987+primOpTag (VecReadByteArrayOp FloatVec 16 W32) = 988+primOpTag (VecReadByteArrayOp FloatVec 8 W64) = 989+primOpTag (VecWriteByteArrayOp IntVec 16 W8) = 990+primOpTag (VecWriteByteArrayOp IntVec 8 W16) = 991+primOpTag (VecWriteByteArrayOp IntVec 4 W32) = 992+primOpTag (VecWriteByteArrayOp IntVec 2 W64) = 993+primOpTag (VecWriteByteArrayOp IntVec 32 W8) = 994+primOpTag (VecWriteByteArrayOp IntVec 16 W16) = 995+primOpTag (VecWriteByteArrayOp IntVec 8 W32) = 996+primOpTag (VecWriteByteArrayOp IntVec 4 W64) = 997+primOpTag (VecWriteByteArrayOp IntVec 64 W8) = 998+primOpTag (VecWriteByteArrayOp IntVec 32 W16) = 999+primOpTag (VecWriteByteArrayOp IntVec 16 W32) = 1000+primOpTag (VecWriteByteArrayOp IntVec 8 W64) = 1001+primOpTag (VecWriteByteArrayOp WordVec 16 W8) = 1002+primOpTag (VecWriteByteArrayOp WordVec 8 W16) = 1003+primOpTag (VecWriteByteArrayOp WordVec 4 W32) = 1004+primOpTag (VecWriteByteArrayOp WordVec 2 W64) = 1005+primOpTag (VecWriteByteArrayOp WordVec 32 W8) = 1006+primOpTag (VecWriteByteArrayOp WordVec 16 W16) = 1007+primOpTag (VecWriteByteArrayOp WordVec 8 W32) = 1008+primOpTag (VecWriteByteArrayOp WordVec 4 W64) = 1009+primOpTag (VecWriteByteArrayOp WordVec 64 W8) = 1010+primOpTag (VecWriteByteArrayOp WordVec 32 W16) = 1011+primOpTag (VecWriteByteArrayOp WordVec 16 W32) = 1012+primOpTag (VecWriteByteArrayOp WordVec 8 W64) = 1013+primOpTag (VecWriteByteArrayOp FloatVec 4 W32) = 1014+primOpTag (VecWriteByteArrayOp FloatVec 2 W64) = 1015+primOpTag (VecWriteByteArrayOp FloatVec 8 W32) = 1016+primOpTag (VecWriteByteArrayOp FloatVec 4 W64) = 1017+primOpTag (VecWriteByteArrayOp FloatVec 16 W32) = 1018+primOpTag (VecWriteByteArrayOp FloatVec 8 W64) = 1019+primOpTag (VecIndexOffAddrOp IntVec 16 W8) = 1020+primOpTag (VecIndexOffAddrOp IntVec 8 W16) = 1021+primOpTag (VecIndexOffAddrOp IntVec 4 W32) = 1022+primOpTag (VecIndexOffAddrOp IntVec 2 W64) = 1023+primOpTag (VecIndexOffAddrOp IntVec 32 W8) = 1024+primOpTag (VecIndexOffAddrOp IntVec 16 W16) = 1025+primOpTag (VecIndexOffAddrOp IntVec 8 W32) = 1026+primOpTag (VecIndexOffAddrOp IntVec 4 W64) = 1027+primOpTag (VecIndexOffAddrOp IntVec 64 W8) = 1028+primOpTag (VecIndexOffAddrOp IntVec 32 W16) = 1029+primOpTag (VecIndexOffAddrOp IntVec 16 W32) = 1030+primOpTag (VecIndexOffAddrOp IntVec 8 W64) = 1031+primOpTag (VecIndexOffAddrOp WordVec 16 W8) = 1032+primOpTag (VecIndexOffAddrOp WordVec 8 W16) = 1033+primOpTag (VecIndexOffAddrOp WordVec 4 W32) = 1034+primOpTag (VecIndexOffAddrOp WordVec 2 W64) = 1035+primOpTag (VecIndexOffAddrOp WordVec 32 W8) = 1036+primOpTag (VecIndexOffAddrOp WordVec 16 W16) = 1037+primOpTag (VecIndexOffAddrOp WordVec 8 W32) = 1038+primOpTag (VecIndexOffAddrOp WordVec 4 W64) = 1039+primOpTag (VecIndexOffAddrOp WordVec 64 W8) = 1040+primOpTag (VecIndexOffAddrOp WordVec 32 W16) = 1041+primOpTag (VecIndexOffAddrOp WordVec 16 W32) = 1042+primOpTag (VecIndexOffAddrOp WordVec 8 W64) = 1043+primOpTag (VecIndexOffAddrOp FloatVec 4 W32) = 1044+primOpTag (VecIndexOffAddrOp FloatVec 2 W64) = 1045+primOpTag (VecIndexOffAddrOp FloatVec 8 W32) = 1046+primOpTag (VecIndexOffAddrOp FloatVec 4 W64) = 1047+primOpTag (VecIndexOffAddrOp FloatVec 16 W32) = 1048+primOpTag (VecIndexOffAddrOp FloatVec 8 W64) = 1049+primOpTag (VecReadOffAddrOp IntVec 16 W8) = 1050+primOpTag (VecReadOffAddrOp IntVec 8 W16) = 1051+primOpTag (VecReadOffAddrOp IntVec 4 W32) = 1052+primOpTag (VecReadOffAddrOp IntVec 2 W64) = 1053+primOpTag (VecReadOffAddrOp IntVec 32 W8) = 1054+primOpTag (VecReadOffAddrOp IntVec 16 W16) = 1055+primOpTag (VecReadOffAddrOp IntVec 8 W32) = 1056+primOpTag (VecReadOffAddrOp IntVec 4 W64) = 1057+primOpTag (VecReadOffAddrOp IntVec 64 W8) = 1058+primOpTag (VecReadOffAddrOp IntVec 32 W16) = 1059+primOpTag (VecReadOffAddrOp IntVec 16 W32) = 1060+primOpTag (VecReadOffAddrOp IntVec 8 W64) = 1061+primOpTag (VecReadOffAddrOp WordVec 16 W8) = 1062+primOpTag (VecReadOffAddrOp WordVec 8 W16) = 1063+primOpTag (VecReadOffAddrOp WordVec 4 W32) = 1064+primOpTag (VecReadOffAddrOp WordVec 2 W64) = 1065+primOpTag (VecReadOffAddrOp WordVec 32 W8) = 1066+primOpTag (VecReadOffAddrOp WordVec 16 W16) = 1067+primOpTag (VecReadOffAddrOp WordVec 8 W32) = 1068+primOpTag (VecReadOffAddrOp WordVec 4 W64) = 1069+primOpTag (VecReadOffAddrOp WordVec 64 W8) = 1070+primOpTag (VecReadOffAddrOp WordVec 32 W16) = 1071+primOpTag (VecReadOffAddrOp WordVec 16 W32) = 1072+primOpTag (VecReadOffAddrOp WordVec 8 W64) = 1073+primOpTag (VecReadOffAddrOp FloatVec 4 W32) = 1074+primOpTag (VecReadOffAddrOp FloatVec 2 W64) = 1075+primOpTag (VecReadOffAddrOp FloatVec 8 W32) = 1076+primOpTag (VecReadOffAddrOp FloatVec 4 W64) = 1077+primOpTag (VecReadOffAddrOp FloatVec 16 W32) = 1078+primOpTag (VecReadOffAddrOp FloatVec 8 W64) = 1079+primOpTag (VecWriteOffAddrOp IntVec 16 W8) = 1080+primOpTag (VecWriteOffAddrOp IntVec 8 W16) = 1081+primOpTag (VecWriteOffAddrOp IntVec 4 W32) = 1082+primOpTag (VecWriteOffAddrOp IntVec 2 W64) = 1083+primOpTag (VecWriteOffAddrOp IntVec 32 W8) = 1084+primOpTag (VecWriteOffAddrOp IntVec 16 W16) = 1085+primOpTag (VecWriteOffAddrOp IntVec 8 W32) = 1086+primOpTag (VecWriteOffAddrOp IntVec 4 W64) = 1087+primOpTag (VecWriteOffAddrOp IntVec 64 W8) = 1088+primOpTag (VecWriteOffAddrOp IntVec 32 W16) = 1089+primOpTag (VecWriteOffAddrOp IntVec 16 W32) = 1090+primOpTag (VecWriteOffAddrOp IntVec 8 W64) = 1091+primOpTag (VecWriteOffAddrOp WordVec 16 W8) = 1092+primOpTag (VecWriteOffAddrOp WordVec 8 W16) = 1093+primOpTag (VecWriteOffAddrOp WordVec 4 W32) = 1094+primOpTag (VecWriteOffAddrOp WordVec 2 W64) = 1095+primOpTag (VecWriteOffAddrOp WordVec 32 W8) = 1096+primOpTag (VecWriteOffAddrOp WordVec 16 W16) = 1097+primOpTag (VecWriteOffAddrOp WordVec 8 W32) = 1098+primOpTag (VecWriteOffAddrOp WordVec 4 W64) = 1099+primOpTag (VecWriteOffAddrOp WordVec 64 W8) = 1100+primOpTag (VecWriteOffAddrOp WordVec 32 W16) = 1101+primOpTag (VecWriteOffAddrOp WordVec 16 W32) = 1102+primOpTag (VecWriteOffAddrOp WordVec 8 W64) = 1103+primOpTag (VecWriteOffAddrOp FloatVec 4 W32) = 1104+primOpTag (VecWriteOffAddrOp FloatVec 2 W64) = 1105+primOpTag (VecWriteOffAddrOp FloatVec 8 W32) = 1106+primOpTag (VecWriteOffAddrOp FloatVec 4 W64) = 1107+primOpTag (VecWriteOffAddrOp FloatVec 16 W32) = 1108+primOpTag (VecWriteOffAddrOp FloatVec 8 W64) = 1109+primOpTag (VecIndexScalarByteArrayOp IntVec 16 W8) = 1110+primOpTag (VecIndexScalarByteArrayOp IntVec 8 W16) = 1111+primOpTag (VecIndexScalarByteArrayOp IntVec 4 W32) = 1112+primOpTag (VecIndexScalarByteArrayOp IntVec 2 W64) = 1113+primOpTag (VecIndexScalarByteArrayOp IntVec 32 W8) = 1114+primOpTag (VecIndexScalarByteArrayOp IntVec 16 W16) = 1115+primOpTag (VecIndexScalarByteArrayOp IntVec 8 W32) = 1116+primOpTag (VecIndexScalarByteArrayOp IntVec 4 W64) = 1117+primOpTag (VecIndexScalarByteArrayOp IntVec 64 W8) = 1118+primOpTag (VecIndexScalarByteArrayOp IntVec 32 W16) = 1119+primOpTag (VecIndexScalarByteArrayOp IntVec 16 W32) = 1120+primOpTag (VecIndexScalarByteArrayOp IntVec 8 W64) = 1121+primOpTag (VecIndexScalarByteArrayOp WordVec 16 W8) = 1122+primOpTag (VecIndexScalarByteArrayOp WordVec 8 W16) = 1123+primOpTag (VecIndexScalarByteArrayOp WordVec 4 W32) = 1124+primOpTag (VecIndexScalarByteArrayOp WordVec 2 W64) = 1125+primOpTag (VecIndexScalarByteArrayOp WordVec 32 W8) = 1126+primOpTag (VecIndexScalarByteArrayOp WordVec 16 W16) = 1127+primOpTag (VecIndexScalarByteArrayOp WordVec 8 W32) = 1128+primOpTag (VecIndexScalarByteArrayOp WordVec 4 W64) = 1129+primOpTag (VecIndexScalarByteArrayOp WordVec 64 W8) = 1130+primOpTag (VecIndexScalarByteArrayOp WordVec 32 W16) = 1131+primOpTag (VecIndexScalarByteArrayOp WordVec 16 W32) = 1132+primOpTag (VecIndexScalarByteArrayOp WordVec 8 W64) = 1133+primOpTag (VecIndexScalarByteArrayOp FloatVec 4 W32) = 1134+primOpTag (VecIndexScalarByteArrayOp FloatVec 2 W64) = 1135+primOpTag (VecIndexScalarByteArrayOp FloatVec 8 W32) = 1136+primOpTag (VecIndexScalarByteArrayOp FloatVec 4 W64) = 1137+primOpTag (VecIndexScalarByteArrayOp FloatVec 16 W32) = 1138+primOpTag (VecIndexScalarByteArrayOp FloatVec 8 W64) = 1139+primOpTag (VecReadScalarByteArrayOp IntVec 16 W8) = 1140+primOpTag (VecReadScalarByteArrayOp IntVec 8 W16) = 1141+primOpTag (VecReadScalarByteArrayOp IntVec 4 W32) = 1142+primOpTag (VecReadScalarByteArrayOp IntVec 2 W64) = 1143+primOpTag (VecReadScalarByteArrayOp IntVec 32 W8) = 1144+primOpTag (VecReadScalarByteArrayOp IntVec 16 W16) = 1145+primOpTag (VecReadScalarByteArrayOp IntVec 8 W32) = 1146+primOpTag (VecReadScalarByteArrayOp IntVec 4 W64) = 1147+primOpTag (VecReadScalarByteArrayOp IntVec 64 W8) = 1148+primOpTag (VecReadScalarByteArrayOp IntVec 32 W16) = 1149+primOpTag (VecReadScalarByteArrayOp IntVec 16 W32) = 1150+primOpTag (VecReadScalarByteArrayOp IntVec 8 W64) = 1151+primOpTag (VecReadScalarByteArrayOp WordVec 16 W8) = 1152+primOpTag (VecReadScalarByteArrayOp WordVec 8 W16) = 1153+primOpTag (VecReadScalarByteArrayOp WordVec 4 W32) = 1154+primOpTag (VecReadScalarByteArrayOp WordVec 2 W64) = 1155+primOpTag (VecReadScalarByteArrayOp WordVec 32 W8) = 1156+primOpTag (VecReadScalarByteArrayOp WordVec 16 W16) = 1157+primOpTag (VecReadScalarByteArrayOp WordVec 8 W32) = 1158+primOpTag (VecReadScalarByteArrayOp WordVec 4 W64) = 1159+primOpTag (VecReadScalarByteArrayOp WordVec 64 W8) = 1160+primOpTag (VecReadScalarByteArrayOp WordVec 32 W16) = 1161+primOpTag (VecReadScalarByteArrayOp WordVec 16 W32) = 1162+primOpTag (VecReadScalarByteArrayOp WordVec 8 W64) = 1163+primOpTag (VecReadScalarByteArrayOp FloatVec 4 W32) = 1164+primOpTag (VecReadScalarByteArrayOp FloatVec 2 W64) = 1165+primOpTag (VecReadScalarByteArrayOp FloatVec 8 W32) = 1166+primOpTag (VecReadScalarByteArrayOp FloatVec 4 W64) = 1167+primOpTag (VecReadScalarByteArrayOp FloatVec 16 W32) = 1168+primOpTag (VecReadScalarByteArrayOp FloatVec 8 W64) = 1169+primOpTag (VecWriteScalarByteArrayOp IntVec 16 W8) = 1170+primOpTag (VecWriteScalarByteArrayOp IntVec 8 W16) = 1171+primOpTag (VecWriteScalarByteArrayOp IntVec 4 W32) = 1172+primOpTag (VecWriteScalarByteArrayOp IntVec 2 W64) = 1173+primOpTag (VecWriteScalarByteArrayOp IntVec 32 W8) = 1174+primOpTag (VecWriteScalarByteArrayOp IntVec 16 W16) = 1175+primOpTag (VecWriteScalarByteArrayOp IntVec 8 W32) = 1176+primOpTag (VecWriteScalarByteArrayOp IntVec 4 W64) = 1177+primOpTag (VecWriteScalarByteArrayOp IntVec 64 W8) = 1178+primOpTag (VecWriteScalarByteArrayOp IntVec 32 W16) = 1179+primOpTag (VecWriteScalarByteArrayOp IntVec 16 W32) = 1180+primOpTag (VecWriteScalarByteArrayOp IntVec 8 W64) = 1181+primOpTag (VecWriteScalarByteArrayOp WordVec 16 W8) = 1182+primOpTag (VecWriteScalarByteArrayOp WordVec 8 W16) = 1183+primOpTag (VecWriteScalarByteArrayOp WordVec 4 W32) = 1184+primOpTag (VecWriteScalarByteArrayOp WordVec 2 W64) = 1185+primOpTag (VecWriteScalarByteArrayOp WordVec 32 W8) = 1186+primOpTag (VecWriteScalarByteArrayOp WordVec 16 W16) = 1187+primOpTag (VecWriteScalarByteArrayOp WordVec 8 W32) = 1188+primOpTag (VecWriteScalarByteArrayOp WordVec 4 W64) = 1189+primOpTag (VecWriteScalarByteArrayOp WordVec 64 W8) = 1190+primOpTag (VecWriteScalarByteArrayOp WordVec 32 W16) = 1191+primOpTag (VecWriteScalarByteArrayOp WordVec 16 W32) = 1192+primOpTag (VecWriteScalarByteArrayOp WordVec 8 W64) = 1193+primOpTag (VecWriteScalarByteArrayOp FloatVec 4 W32) = 1194+primOpTag (VecWriteScalarByteArrayOp FloatVec 2 W64) = 1195+primOpTag (VecWriteScalarByteArrayOp FloatVec 8 W32) = 1196+primOpTag (VecWriteScalarByteArrayOp FloatVec 4 W64) = 1197+primOpTag (VecWriteScalarByteArrayOp FloatVec 16 W32) = 1198+primOpTag (VecWriteScalarByteArrayOp FloatVec 8 W64) = 1199+primOpTag (VecIndexScalarOffAddrOp IntVec 16 W8) = 1200+primOpTag (VecIndexScalarOffAddrOp IntVec 8 W16) = 1201+primOpTag (VecIndexScalarOffAddrOp IntVec 4 W32) = 1202+primOpTag (VecIndexScalarOffAddrOp IntVec 2 W64) = 1203+primOpTag (VecIndexScalarOffAddrOp IntVec 32 W8) = 1204+primOpTag (VecIndexScalarOffAddrOp IntVec 16 W16) = 1205+primOpTag (VecIndexScalarOffAddrOp IntVec 8 W32) = 1206+primOpTag (VecIndexScalarOffAddrOp IntVec 4 W64) = 1207+primOpTag (VecIndexScalarOffAddrOp IntVec 64 W8) = 1208+primOpTag (VecIndexScalarOffAddrOp IntVec 32 W16) = 1209+primOpTag (VecIndexScalarOffAddrOp IntVec 16 W32) = 1210+primOpTag (VecIndexScalarOffAddrOp IntVec 8 W64) = 1211+primOpTag (VecIndexScalarOffAddrOp WordVec 16 W8) = 1212+primOpTag (VecIndexScalarOffAddrOp WordVec 8 W16) = 1213+primOpTag (VecIndexScalarOffAddrOp WordVec 4 W32) = 1214+primOpTag (VecIndexScalarOffAddrOp WordVec 2 W64) = 1215+primOpTag (VecIndexScalarOffAddrOp WordVec 32 W8) = 1216+primOpTag (VecIndexScalarOffAddrOp WordVec 16 W16) = 1217+primOpTag (VecIndexScalarOffAddrOp WordVec 8 W32) = 1218+primOpTag (VecIndexScalarOffAddrOp WordVec 4 W64) = 1219+primOpTag (VecIndexScalarOffAddrOp WordVec 64 W8) = 1220+primOpTag (VecIndexScalarOffAddrOp WordVec 32 W16) = 1221+primOpTag (VecIndexScalarOffAddrOp WordVec 16 W32) = 1222+primOpTag (VecIndexScalarOffAddrOp WordVec 8 W64) = 1223+primOpTag (VecIndexScalarOffAddrOp FloatVec 4 W32) = 1224+primOpTag (VecIndexScalarOffAddrOp FloatVec 2 W64) = 1225+primOpTag (VecIndexScalarOffAddrOp FloatVec 8 W32) = 1226+primOpTag (VecIndexScalarOffAddrOp FloatVec 4 W64) = 1227+primOpTag (VecIndexScalarOffAddrOp FloatVec 16 W32) = 1228+primOpTag (VecIndexScalarOffAddrOp FloatVec 8 W64) = 1229+primOpTag (VecReadScalarOffAddrOp IntVec 16 W8) = 1230+primOpTag (VecReadScalarOffAddrOp IntVec 8 W16) = 1231+primOpTag (VecReadScalarOffAddrOp IntVec 4 W32) = 1232+primOpTag (VecReadScalarOffAddrOp IntVec 2 W64) = 1233+primOpTag (VecReadScalarOffAddrOp IntVec 32 W8) = 1234+primOpTag (VecReadScalarOffAddrOp IntVec 16 W16) = 1235+primOpTag (VecReadScalarOffAddrOp IntVec 8 W32) = 1236+primOpTag (VecReadScalarOffAddrOp IntVec 4 W64) = 1237+primOpTag (VecReadScalarOffAddrOp IntVec 64 W8) = 1238+primOpTag (VecReadScalarOffAddrOp IntVec 32 W16) = 1239+primOpTag (VecReadScalarOffAddrOp IntVec 16 W32) = 1240+primOpTag (VecReadScalarOffAddrOp IntVec 8 W64) = 1241+primOpTag (VecReadScalarOffAddrOp WordVec 16 W8) = 1242+primOpTag (VecReadScalarOffAddrOp WordVec 8 W16) = 1243+primOpTag (VecReadScalarOffAddrOp WordVec 4 W32) = 1244+primOpTag (VecReadScalarOffAddrOp WordVec 2 W64) = 1245+primOpTag (VecReadScalarOffAddrOp WordVec 32 W8) = 1246+primOpTag (VecReadScalarOffAddrOp WordVec 16 W16) = 1247+primOpTag (VecReadScalarOffAddrOp WordVec 8 W32) = 1248+primOpTag (VecReadScalarOffAddrOp WordVec 4 W64) = 1249+primOpTag (VecReadScalarOffAddrOp WordVec 64 W8) = 1250+primOpTag (VecReadScalarOffAddrOp WordVec 32 W16) = 1251+primOpTag (VecReadScalarOffAddrOp WordVec 16 W32) = 1252+primOpTag (VecReadScalarOffAddrOp WordVec 8 W64) = 1253+primOpTag (VecReadScalarOffAddrOp FloatVec 4 W32) = 1254+primOpTag (VecReadScalarOffAddrOp FloatVec 2 W64) = 1255+primOpTag (VecReadScalarOffAddrOp FloatVec 8 W32) = 1256+primOpTag (VecReadScalarOffAddrOp FloatVec 4 W64) = 1257+primOpTag (VecReadScalarOffAddrOp FloatVec 16 W32) = 1258+primOpTag (VecReadScalarOffAddrOp FloatVec 8 W64) = 1259+primOpTag (VecWriteScalarOffAddrOp IntVec 16 W8) = 1260+primOpTag (VecWriteScalarOffAddrOp IntVec 8 W16) = 1261+primOpTag (VecWriteScalarOffAddrOp IntVec 4 W32) = 1262+primOpTag (VecWriteScalarOffAddrOp IntVec 2 W64) = 1263+primOpTag (VecWriteScalarOffAddrOp IntVec 32 W8) = 1264+primOpTag (VecWriteScalarOffAddrOp IntVec 16 W16) = 1265+primOpTag (VecWriteScalarOffAddrOp IntVec 8 W32) = 1266+primOpTag (VecWriteScalarOffAddrOp IntVec 4 W64) = 1267+primOpTag (VecWriteScalarOffAddrOp IntVec 64 W8) = 1268+primOpTag (VecWriteScalarOffAddrOp IntVec 32 W16) = 1269+primOpTag (VecWriteScalarOffAddrOp IntVec 16 W32) = 1270+primOpTag (VecWriteScalarOffAddrOp IntVec 8 W64) = 1271+primOpTag (VecWriteScalarOffAddrOp WordVec 16 W8) = 1272+primOpTag (VecWriteScalarOffAddrOp WordVec 8 W16) = 1273+primOpTag (VecWriteScalarOffAddrOp WordVec 4 W32) = 1274+primOpTag (VecWriteScalarOffAddrOp WordVec 2 W64) = 1275+primOpTag (VecWriteScalarOffAddrOp WordVec 32 W8) = 1276+primOpTag (VecWriteScalarOffAddrOp WordVec 16 W16) = 1277+primOpTag (VecWriteScalarOffAddrOp WordVec 8 W32) = 1278+primOpTag (VecWriteScalarOffAddrOp WordVec 4 W64) = 1279+primOpTag (VecWriteScalarOffAddrOp WordVec 64 W8) = 1280+primOpTag (VecWriteScalarOffAddrOp WordVec 32 W16) = 1281+primOpTag (VecWriteScalarOffAddrOp WordVec 16 W32) = 1282+primOpTag (VecWriteScalarOffAddrOp WordVec 8 W64) = 1283+primOpTag (VecWriteScalarOffAddrOp FloatVec 4 W32) = 1284+primOpTag (VecWriteScalarOffAddrOp FloatVec 2 W64) = 1285+primOpTag (VecWriteScalarOffAddrOp FloatVec 8 W32) = 1286+primOpTag (VecWriteScalarOffAddrOp FloatVec 4 W64) = 1287+primOpTag (VecWriteScalarOffAddrOp FloatVec 16 W32) = 1288+primOpTag (VecWriteScalarOffAddrOp FloatVec 8 W64) = 1289+primOpTag PrefetchByteArrayOp3 = 1290+primOpTag PrefetchMutableByteArrayOp3 = 1291+primOpTag PrefetchAddrOp3 = 1292+primOpTag PrefetchValueOp3 = 1293+primOpTag PrefetchByteArrayOp2 = 1294+primOpTag PrefetchMutableByteArrayOp2 = 1295+primOpTag PrefetchAddrOp2 = 1296+primOpTag PrefetchValueOp2 = 1297+primOpTag PrefetchByteArrayOp1 = 1298+primOpTag PrefetchMutableByteArrayOp1 = 1299+primOpTag PrefetchAddrOp1 = 1300+primOpTag PrefetchValueOp1 = 1301+primOpTag PrefetchByteArrayOp0 = 1302+primOpTag PrefetchMutableByteArrayOp0 = 1303+primOpTag PrefetchAddrOp0 = 1304+primOpTag PrefetchValueOp0 = 1305
ghc-lib/stage0/lib/settings view
@@ -10,7 +10,6 @@ ,("ld command", "ld") ,("ld flags", "") ,("ld supports compact unwind", "YES")-,("ld supports build-id", "NO") ,("ld supports filelist", "YES") ,("ld is GNU ld", "NO") ,("Merge objects command", "ld")
ghc-lib/stage0/rts/build/include/GhclibDerivedConstants.h view
@@ -1,6 +1,6 @@ /* This file is created automatically. Do not edit by hand.*/ -#define HS_CONSTANTS "291,1,2,4096,252,9,0,8,16,24,32,40,48,56,64,72,80,84,88,92,96,100,104,112,120,128,136,144,152,168,184,200,216,232,248,280,312,344,376,408,440,504,568,632,696,760,824,832,840,848,856,864,872,888,904,-24,-16,-8,24,0,8,48,46,96,72,8,48,8,8,16,8,64,8,16,8,0,72,56,8,16,0,8,8,0,8,0,96,112,16,8,16,0,4,4,24,20,4,15,7,1,-16,255,0,255,7,10,6,6,1,6,6,6,6,6,0,16384,21,1024,8,4,8,8,6,3,30,1152921503533105152,0,1152921504606846976,1"+#define HS_CONSTANTS "291,1,2,4096,252,9,0,8,16,24,32,40,48,56,64,72,80,84,88,92,96,100,104,112,120,128,136,144,152,168,184,200,216,232,248,280,312,344,376,408,440,504,568,632,696,760,824,832,840,848,856,864,872,888,904,-24,-16,-8,24,0,8,48,46,96,72,8,48,8,8,16,8,64,8,16,8,0,72,56,8,16,0,8,8,0,8,0,104,120,16,8,16,0,4,4,24,20,4,15,7,1,-16,255,0,255,7,10,6,6,1,6,6,6,6,6,0,16384,21,1024,8,4,8,8,6,3,30,1152921503533105152,0,1152921504606846976,1" #define CONTROL_GROUP_CONST_291 291 #define STD_HDR_SIZE 1 #define PROF_HDR_SIZE 2@@ -210,7 +210,7 @@ #define OFFSET_StgTSO_block_info 32 #define REP_StgTSO_block_info b64 #define StgTSO_block_info(__ptr__) REP_StgTSO_block_info[__ptr__+SIZEOF_StgHeader+OFFSET_StgTSO_block_info]-#define OFFSET_StgTSO_blocked_exceptions 80+#define OFFSET_StgTSO_blocked_exceptions 88 #define REP_StgTSO_blocked_exceptions b64 #define StgTSO_blocked_exceptions(__ptr__) REP_StgTSO_blocked_exceptions[__ptr__+SIZEOF_StgHeader+OFFSET_StgTSO_blocked_exceptions] #define OFFSET_StgTSO_id 40@@ -231,13 +231,16 @@ #define OFFSET_StgTSO_dirty 52 #define REP_StgTSO_dirty b32 #define StgTSO_dirty(__ptr__) REP_StgTSO_dirty[__ptr__+SIZEOF_StgHeader+OFFSET_StgTSO_dirty]-#define OFFSET_StgTSO_bq 88+#define OFFSET_StgTSO_bq 96 #define REP_StgTSO_bq b64 #define StgTSO_bq(__ptr__) REP_StgTSO_bq[__ptr__+SIZEOF_StgHeader+OFFSET_StgTSO_bq]-#define OFFSET_StgTSO_alloc_limit 96+#define OFFSET_StgTSO_label 80+#define REP_StgTSO_label b64+#define StgTSO_label(__ptr__) REP_StgTSO_label[__ptr__+SIZEOF_StgHeader+OFFSET_StgTSO_label]+#define OFFSET_StgTSO_alloc_limit 104 #define REP_StgTSO_alloc_limit b64 #define StgTSO_alloc_limit(__ptr__) REP_StgTSO_alloc_limit[__ptr__+SIZEOF_StgHeader+OFFSET_StgTSO_alloc_limit]-#define OFFSET_StgTSO_cccs 112+#define OFFSET_StgTSO_cccs 120 #define REP_StgTSO_cccs b64 #define StgTSO_cccs(__ptr__) REP_StgTSO_cccs[__ptr__+SIZEOF_StgHeader+OFFSET_StgTSO_cccs] #define OFFSET_StgTSO_stackobj 16