emit_ bci_BRK_FUN [ Op p1, Op info_addr, Op info_unitid_addr

                       , SmallOp ix_hi, SmallOp ix_lo, Op np ]

 #if MIN_VERSION_rts(1,0,3)

   BCO_NAME name            -> do np <- lit1 (BCONPtrStr name)

                                  emit_ bci_BCO_NAME [Op np]

 import GHC.Cmm.Type (Width)

 import GHC.StgToCmm.Layout     ( ArgRep(..) )

 import GHC.Utils.Outputable

 import GHC.Types.Name

 import GHC.Types.Literal

 import GHC.Types.Unique

    -- Breakpoints

    | BRK_FUN          !InternalBreakpointId

 #if MIN_VERSION_rts(1,0,3)

    -- | A "meta"-instruction for recording the name of a BCO for debugging purposes.

                              = text "BRK_FUN" <+> text "<breakarray>"

                                <+> ppr info_mod <+> ppr infox

                                <+> text "<cc>"

 #if MIN_VERSION_rts(1,0,3)

    ppr (BCO_NAME nm)         = text "BCO_NAME" <+> text (show nm)

 #endif

 bciStackUse SWIZZLE{}             = 0

 bciStackUse BRK_FUN{}             = 0

 -- These insns actually reduce stack use, but we need the high-tide level,

 -- so can't use this info.  Not that it matters much.

 backendSupportsHpc (Named LLVM)        = True

 backendSupportsHpc (Named ViaC)        = True

 backendSupportsHpc (Named JavaScript)  = False

 backendSupportsHpc (Named NoBackend)   = True

 -- | This flag says whether the back end supports foreign

      NoStubs ->

         return (False, Nothing)

         let

             stub_c_output_w = showSDoc dflags stub_c_output_d

             -- Header file protos for "foreign export"ed functions.

             stub_h_output_d = pprCode h_code

             stub_h_output_w = showSDoc dflags stub_h_output_d

         putDumpFileMaybe logger Opt_D_dump_foreign

                       "Foreign export header file"

    cplusplus_hdr = "#if defined(__cplusplus)\nextern \"C\" {\n#endif\n"

    cplusplus_ftr = "#if defined(__cplusplus)\n}\n#endif\n"

 -- It is more than likely that the stubs file will

 -- turn out to be empty, in which case no file should be created.

            pgmError (backendDescription (backend dflags) ++

                      " supports only unregisterised ABI but target platform doesn't use it.")

  | backendSwappableWithViaC (backend dflags) &&

    platformUnregisterised (targetPlatform dflags)

     = loop (dflags { backend = viaCBackend })

                                        export_set (typeEnvTyCons type_env) binds

                               else return (binds, Nothing)

         ; let modBreaks

                 , breakpointsAllowed dflags

                 | otherwise

                 = Nothing

         ; ds_hpc_info <- case m_tickInfo of

               | gopt Opt_Hpc $ hsc_dflags hsc_env

               -> do

               hashNo <- if gopt Opt_Hpc $ hsc_dflags hsc_env

                 else return 0 -- dummy hash when none are written

             _ -> pure $ emptyHpcInfo

         ; (msgs, mb_res) <- initDs hsc_env tcg_env $

                                 -- hasn't set it), so we have to work from this set.

         -> [TyCon]              -- ^ Type constructors in this module

         -> LHsBinds GhcTc

 addTicksToBinds logger cfg

                 mod mod_loc exports tyCons binds

           (binds1,st) = foldr tickPass (binds, initTTState) passes

      putDumpFileMaybe logger Opt_D_dump_ticked "HPC" FormatHaskell

        (pprLHsBinds binds1)

   | otherwise = return (binds, Nothing)

                 (addTickLHsExpr e2)

                 (addTickLHsExpr e3)

                          }

 initTTState :: TickTransState

                  }

   setState $ \st ->

   return c

 addRecSelTick :: Id -> CoreTickish -> TM ()

   env <- getEnv

   case tickishType env of

     ProfNotes -> do

       flavour <- mkHpcCCFlavour <$> getCCIndexM cc_name

       return $ ProfNote cc count True{-scopes-}

     Breakpoints -> do

       pure (Breakpoint noExtField (BreakpointId (this_mod env) i) ids)

     SourceNotes | RealSrcSpan pos' _ <- pos ->

 mkBinTickBoxHpc boxLabel pos e = do

   env <- getEnv

   binTick <- HsBinTick

                           , tick_path = declPath env

                           , tick_ids = []

                           , tick_label = boxLabel True

                           })

                           , tick_path = declPath env

                           , tick_ids = []

                           , tick_label = boxLabel False

                           })

     <*> pure e

   tick <- HpcTick (this_mod env)

                           , tick_path = declPath env

                           , tick_ids = []

                           , tick_label = ExpBox False

 import GHC.Cmm.CallConv

 import GHC.Cmm.Expr

 import GHC.Cmm.Reg ( GlobalArgRegs(..) )

 import GHC.Cmm.Node

 import GHC.Cmm.Utils

 import Foreign hiding (shiftL, shiftR)

 import Control.Monad

 import Data.Char

 import GHC.Unit.Module

    = pprPanic "schemeE: Breakpoint without let binding:"

         (ppr bp_id <+> text "forgot to run bcPrep?")

 -- ignore other kinds of tick

 schemeE d s p (StgTick _ rhs) = schemeE d s p rhs

 tickFS :: FastString

 tickFS = fsLit "ticked"

 -- Dehydrating CgBreakInfo

 dehydrateCgBreakInfo :: [TyVar] -> [Maybe (Id, Word)] -> Type -> Either InternalBreakLoc BreakpointId -> CgBreakInfo

          }

          debugBelch("\n");

          break; }

       case bci_SWIZZLE: {

          W_     stkoff = BCO_GET_LARGE_ARG;

          StgInt by     = BCO_GET_LARGE_ARG;

   HpcModuleInfo *tmpModule;

   uint32_t i;

   if (moduleHash == NULL) {

       moduleHash = allocStrHashTable();

   }

       }

       tmpModule->from_file = false;

   }

 }

 static void

             &&lbl_bci_TESTEQ_W8 - &&lbl_bci_DEFAULT,

             &&lbl_bci_PRIMCALL - &&lbl_bci_DEFAULT,

             &&lbl_bci_BCO_NAME - &&lbl_bci_DEFAULT,

             &&lbl_bci_DEFAULT - &&lbl_bci_DEFAULT,

             &&lbl_bci_OP_ADD_64 - &&lbl_bci_DEFAULT,

             &&lbl_bci_OP_SUB_64 - &&lbl_bci_DEFAULT,

             NEXT_INSTRUCTION;

         }

         INSTRUCTION(bci_STKCHECK): {

             // Explicit stack check at the beginning of a function

             // *only* (stack checks in case alternatives are

 #define bci_PRIMCALL                    87

 #define bci_BCO_NAME                    88

 #define bci_OP_ADD_64                   90

 #define bci_OP_SUB_64                   91

 	'$(TEST_HC)' $(TEST_HC_OPTS) -fhpc -c A.hs

 	echo b | '$(TEST_HC)' $(TEST_HC_OPTS_INTERACTIVE) B.hs

      [extra_files(['A.hs', 'B.hs']),

       only_ways(['normal']), when(compiler_profiled(), skip), req_interp],

      run_command, ['$MAKE -s --no-print-directory hpc_ghc_ghci'])