tag <- getEnv envTag

     liftUDSMT $! do

       uq <- DSM.getUniqueM

 -- | Lifting of IO actions. Not exported, as we want to encapsulate IO.

 liftIO :: IO a -> LlvmM a

 instance MonadUnique CoreM where

     getUniqueSupplyM = do

         tag <- read cr_uniq_tag

     getUniqueM = do

         tag <- read cr_uniq_tag

 runCoreM :: HscEnv

          -> RuleBase

                | otherwise       = unpackHObj res_hty

   header_bits = maybe mempty idTag maybe_target

             in  CHeader (char tag <> word64 u)

   normal_args = map (\(nm,_ty,_,_) -> nm) arg_info

                bin_symtab_next = symtab_next }

         bh name

   | isKnownKeyName name

   = -- assert (u < 2^(22 :: Int))

     put_ bh (0x80000000

              .|. (fromIntegral (ord c) `shiftL` 22)

 instance MonadUnique StgM where

   getUniqueSupplyM = StgM $ do { tag <- ask

   getUniqueM = StgM $ do { tag <- ask

 runStgM :: UniqueTag -> StgM a -> IO a

 runStgM mask (StgM m) = runReaderT m (uniqueTag mask)

         -- unique suffix for non-exported Ids

       , if exported

           then mempty

                in mconcat [BSC.pack ['_',c,'_'], word64BS u]

       ]

   0 -> return mempty

   1 -> decl <$> identForId i

   s -> mconcat <$> mapM (\n -> decl <$> identForIdN i n) [1..s]

 newUnique

  = do { env <- getEnv

       ; let tag = env_ut env

 newUniqueSupply :: TcRnIf gbl lcl UniqSupply

 newUniqueSupply

  = do { env <- getEnv

       ; let tag = env_ut env

 cloneLocalName :: Name -> TcM Name

 -- Make a fresh Internal name with the same OccName and SrcSpan

 type OrigNameCache   = ModuleEnv (OccEnv Name)

 takeUniqFromNameCache :: NameCache -> IO Unique

 lookupOrigNameCache :: OrigNameCache -> Module -> OccName -> Maybe Name

 lookupOrigNameCache nc mod occ = lookup_infinite <|> lookup_normal

         mkUniqueIntGrimily,

         getKey,

         mkUnique, unpkUnique,

         mkUniqueInt,

         eqUnique, ltUnique,

         incrUnique, stepUnique,

         nonDetCmpUnique,

         isValidKnownKeyUnique,

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

 The UniqueTag ADT is meant to be ephemeral and eliminated by the simplifier,

 so for long term storage (i.e. in monadic environments or data structures) we

 class of functions

 For instance, if we are generating a unique for a concrete tag, we should use

        ; liftIO $! uniqFromTag tag }

 Prefer `env_ut :: Char` and

 -}

 -}

 unpkUnique :: Unique -> (UniqueTag, Word64)        -- The reverse

 mkUniqueGrimily :: Word64 -> Unique                -- A trap-door for UniqSupply

 getKey          :: Unique -> Word64                -- for Var

 incrUnique   :: Unique -> Unique

 stepUnique   :: Unique -> Word64 -> Unique

 newTagUnique :: Unique -> UniqueTag -> Unique

 mkUniqueGrimily = MkUnique

 maxLocalUnique = mkLocalUnique uniqueMask

 -- newTagUnique changes the "domain" of a unique to a different char

 -- | Bitmask that has zeros for the tag bits and ones for the rest.

 uniqueMask :: Word64

 {-# INLINE mkUniqueIntGrimily #-}

   = let

         -- The potentially truncating use of fromIntegral here is safe

         -- because the argument is just the tag bits after shifting.

         i   = u .&. uniqueMask

     in

     (tag, i)

   (c, i) -> ( charToUniqueTag c, i)

 {-# INLINE unpkUnique #-}

 -- See Note [Symbol table representation of names] in "GHC.Iface.Binary" for details.

 isValidKnownKeyUnique :: Unique -> Bool

 isValidKnownKeyUnique u =

       (c, x) -> ord c < 0xff && x <= (1 `shiftL` 22)

 {-

 showUnique uniq

   = tagStr ++ w64ToBase62 u

   where

     -- Avoid emitting non-printable characters in pretty uniques.

     -- See #25989.

     tagStr

         -- ** Operations on supplies

         uniqFromSupply, uniqsFromSupply, -- basic ops

         takeUniqFromSupply,

         UniqueTag(..),

         splitUniqSupply, listSplitUniqSupply,

         -- * Unique supply monad and its abstraction

                                 -- when split => these two supplies

 mkSplitUniqSupply  :: UniqueTag -> IO UniqSupply

 {-# INLINE mkSplitUniqSupply #-}

 -- ^ Create a unique supply out of thin air.

 -- The "tag" (Char) supplied is mostly cosmetic, making it easier

 -- to figure out where a Unique was born. See Note [Uniques and tags].

 -- See Note [How the unique supply works]

 -- See Note [Optimising the unique supply]

   = unsafeDupableInterleaveIO (IO mk_supply)

   where

     poke ghc_unique_inc       inc

 uniqFromTag :: UniqueTag -> IO Unique

 {-# INLINE uniqFromTag #-}

   = do { uqNum <- genSym

        ; return $! mkUniqueGrimilyWithTag tag uqNum }

 splitUniqSupply :: UniqSupply -> (UniqSupply, UniqSupply)

 -- ^ Build two 'UniqSupply' from a single one, each of which