# excessive amounts of stack space. So we specifically set a low

      # stack limit and mark it as failing under a few conditions.

      [extra_run_opts('+RTS -K8m -RTS'),

      # JS doesn't support stack limit so the test sometimes passes just fine. Therefore the test is

      # marked as fragile.

      when(js_arch(), fragile(22921))],

     , getIPE

     , StgInfoTable

     , lookupIPE

     ) where

 import GHC.Internal.Base

 import GHC.Internal.Enum

 import GHC.Internal.Real (fromIntegral)

 import GHC.Internal.Show (Show)

 import GHC.Internal.Ptr (Ptr(..), plusPtr)

 import GHC.Internal.Foreign.C.String.Encoding (CString, peekCString)

 import GHC.Internal.Prim (whereFrom##)

 data InfoProv = InfoProv {

   ipName :: String,

   ipDesc :: ClosureType,

   ipTyDesc :: String,

     1 -> Just `fmap` peekInfoProv (ipeProv p)

     _ -> return Nothing

 getIPE :: a -> r -> (Ptr InfoProvEnt -> IO r) -> IO r

 getIPE obj fail k = allocaBytes (#size InfoProvEnt) $ \p -> IO $ \s ->

   case whereFrom## obj (unPtr p) s of

 peekIpDesc :: Ptr InfoProv -> IO Word32

 peekIpDesc p    =  (# peek InfoProv, closure_desc) p

 peekIpName, peekIpLabel, peekIpUnitId, peekIpModule, peekIpSrcFile, peekIpSrcSpan, peekIpTyDesc :: Ptr InfoProv -> IO CString

 peekIpName p    =  (# peek InfoProv, table_name) p

 peekIpLabel p   =  (# peek InfoProv, label) p

 peekInfoProv :: Ptr InfoProv -> IO InfoProv

 peekInfoProv infop = do

   name <- peekCString utf8 =<< peekIpName infop

   desc <- peekIpDesc infop

   tyDesc <- peekCString utf8 =<< peekIpTyDesc infop

   file <- peekCString utf8 =<< peekIpSrcFile infop

   span <- peekCString utf8 =<< peekIpSrcSpan infop

   return InfoProv {

       ipName = name,

       -- The INVALID_OBJECT case should be impossible as we

       -- control the C code generating these values.

 instance Binary Heap.PrimType

 instance Binary a => Binary (Heap.GenClosure a)

 instance Binary InfoProv where

   get = InfoProv <$> get <*> get <*> get <*> get <*> get <*> get <*> get <*> get

   put (InfoProv x1 x2 x3 x4 x5 x6 x7 x8)

     = put x1 >> put x2 >> put x3 >> put x4 >> put x5 >> put x6 >> put x7 >> put x8

     """

     req_interp(name, opts)

     if config.cross:

         opts.skip = True

 test('T20696', [extra_files(['A.hs', 'B.hs', 'C.hs'])

                , unless(ghc_dynamic(), skip)], multimod_compile, ['A', ''])

 test('T20696-static', [extra_files(['A.hs', 'B.hs', 'C.hs'])

                , when(ghc_dynamic(), skip)], multimod_compile, ['A', ''])

 # Check linking works when using -fbyte-code-and-object-code

 test('fat011', [req_th, extra_files(['FatMain.hs', 'FatTH.hs', 'FatQuote.hs'])], multimod_compile, ['FatMain', '-fbyte-code-and-object-code -fprefer-byte-code'])

 # Check that we use interpreter rather than enable dynamic-too if needed for TH

 # Check that no objects are generated if using -fno-code and -fprefer-byte-code

 test('fat013', [req_th, req_bco, extra_files(['FatTH.hs', 'FatQuote.hs'])], multimod_compile, ['FatTH', '-fno-code -fprefer-byte-code'])

 # When using interpreter should not produce objects

 test('fat014', [req_th, extra_files(['FatTH.hs', 'FatQuote.hs']), extra_run_opts('-fno-code')], ghci_script, ['fat014.script'])

 test('T22807', [req_th, unless(ghc_dynamic(), skip), extra_files(['T22807A.hs', 'T22807B.hs'])]

              , makefile_test, ['T22807'])

 test('T22807_ghci', [req_th, unless(ghc_dynamic(), skip), extra_files(['T22807_ghci.hs'])]

 test('SI04', [extra_files(["SI01A.hs"])], multimod_compile, ['SI04', '-v0'])

 test('SI05', [extra_files(["SI01A.hs"])], multimod_compile_fail, ['SI05', '-v0'])

 test('SI06', [extra_files(["SI01A.hs"])], multimod_compile, ['SI06', '-v0'])

 # Instance tests

 test('SI08', [extra_files(["ClassA.hs", "InstanceA.hs"])], multimod_compile_fail, ['SI08', '-v0'])

 test('SI09', [extra_files(["ClassA.hs", "InstanceA.hs"])], multimod_compile, ['SI09', '-v0'])