git config user.email "ghc-ci@gitlab-haskell.org"

   git config user.name "GHC GitLab CI"

   info "====================================================="

   info "Toolchain versions"

   info "====================================================="

 function pull() {

   local ref="refs/notes/$REF"

   echo "perf notes ref $ref is $(git rev-parse $ref)"

 }

   pull) pull ;;

   *) fail "Invalid mode $1" ;;

 esac

 -- the same comparison at the larger size.

 cmmMachOpFoldM platform cmp [CmmMachOp conv [x], CmmLit (CmmInt i _)]

     Just (rep, signed, narrow_fn) <- maybe_conversion conv,

         -- and this is a comparison operation:

     Just narrow_cmp <- maybe_comparison cmp rep signed,

         <td><code>ubsan</code></td>

         <td>Build all stage1+ C/C++ code with UndefinedBehaviorSanitizer support</td>

     </tr>

     <tr>

         <td><code>llvm</code></td>

         <td>Use GHC's LLVM backend (`-fllvm`) for all stage1+ compilation.</td>

   , splitSections

   , enableThreadSanitizer

   , enableUBSan

   , enableLateCCS

   , enableHashUnitIds

   , enableDebugInfo, enableTickyGhc

     , "thread_sanitizer" =: enableThreadSanitizer False

     , "thread_sanitizer_cmm" =: enableThreadSanitizer True

     , "ubsan"            =: enableUBSan

     , "llvm"             =: viaLlvmBackend

     , "profiled_ghc"     =: enableProfiledGhc

     , "no_dynamic_ghc"   =: disableDynamicGhcPrograms

           builder Testsuite ? arg "--config=have_ubsan=True"

         ]

 -- | Use the LLVM backend in stages 1 and later.

 viaLlvmBackend :: Flavour -> Flavour

 viaLlvmBackend = addArgs $ notStage0 ? builder Ghc ? arg "-fllvm"

     , description               :: String

     , packageDependencies       :: [Package]

     , genericPackageDescription :: GenericPackageDescription

 -- | Haskell package metadata obtained after resolving package configuration

 -- flags and associated conditionals according to the current build context.

     , contextLibdir    :: FilePath

     -- The location where dynamic libraries go

     , contextDynLibdir :: FilePath

 instance Binary   PackageData

 instance Hashable PackageData where hashWithSalt salt = hashWithSalt salt . show

   deriving Show

 newtype PkgHashKey = PkgHashKey (Stage, Package)

 type instance RuleResult PkgHashKey = String

 pkgHash :: Stage -> Package -> Action String

     void (askOracle $ ArgsHash hashedTarget :: Action Int)

 newtype ArgsHash c b = ArgsHash (Target c b)

 type instance RuleResult (ArgsHash c b) = Int

 -- | This oracle stores per-target argument list hashes in the Shake database,

 -- | This type of oracle key is used by 'Hadrian.Oracles.Cabal.readPackageData'

 -- to cache reading and parsing of 'Hadrian.Haskell.Cabal.Type.PackageData'.

 newtype PackageDataKey = PackageDataKey Package

 type instance RuleResult PackageDataKey = PackageData

 -- | This type of oracle key is used by 'Hadrian.Oracles.Cabal.readContextData'

 -- to cache reading and parsing of 'Hadrian.Haskell.Cabal.Type.ContextData'.

 newtype ContextDataKey = ContextDataKey Context

 type instance RuleResult ContextDataKey = ContextData

 -- TODO: Should @PackageConfiguration@ be simply @()@? Presumably the pair

 -- | The result of Cabal package configuration produced by the oracle

 -- 'Hadrian.Oracles.Cabal.configurePackageGHC'.

 newtype PackageConfiguration = PackageConfiguration (C.Compiler, C.Platform)

 instance NFData PackageConfiguration where

     rnf (PackageConfiguration (c, p)) =

 -- | This type of oracle key is used by 'Hadrian.Oracles.Cabal.configurePackageGHC'

 -- to cache configuration of a Cabal package.

 newtype PackageConfigurationKey = PackageConfigurationKey (Package, Stage)

 type instance RuleResult PackageConfigurationKey = PackageConfiguration

 import qualified System.Directory.Extra as IO

 data Match = Test FilePattern | Not Match | And [Match] | Or [Match]

 instance Binary   Match

 instance Hashable Match

     mapM_ cp =<< directoryContents expr source

 newtype DirectoryContents = DirectoryContents (Match, FilePath)

 type instance RuleResult DirectoryContents = [FilePath]

 -- | This oracle answers 'directoryContents' queries and tracks the results.

         return path

 newtype LookupInPath = LookupInPath String

 type instance RuleResult LookupInPath = String

 newtype WindowsPath = WindowsPath FilePath

 type instance RuleResult WindowsPath = String

 -- | Oracles for looking up paths. These are slow and require caching.

 queryTargetTarget f = f <$> getTargetTarget

 newtype KeyValue = KeyValue (FilePath, String)

 type instance RuleResult KeyValue = Maybe String

 newtype KeyValues = KeyValues (FilePath, String)

 type instance RuleResult KeyValues = Maybe [String]

 newtype TargetFile = TargetFile FilePath

 type instance RuleResult TargetFile = Toolchain.Target

 -- | These oracle rules are used to cache and track answers to the following

     extra <- shakeExtra <$> getShakeOptionsRules

     return $ lookupExtra defaultValue extra

 -- | All build results are put into the 'buildRoot' directory.

 buildRoot :: Action FilePath

         else putInfo msg

 newtype BuildProgressColour = BuildProgressColour String

 -- | By default, Hadrian tries to figure out if the current terminal

 --   supports colors using this function. The default can be overridden

     putColoured code msg

 newtype SuccessColour = SuccessColour String

 -- | Generate an encoded colour for successful output from names

 mkSuccessColour :: Colour -> SuccessColour

     putColoured code msg

 newtype FailureColour = FailureColour String

 -- | Generate an encoded colour for failure output messages

 mkFailureColour :: Colour -> FailureColour

   FailureColour code <- userSetting red

   putColoured code msg

 -- | Version of 'putBuild' controlled by @--progress-info@ command line argument.

 putProgressInfo :: String -> Action ()

 import Settings (flavour)

 newtype DynGhcPrograms =

 type instance RuleResult DynGhcPrograms = Bool

 newtype GhcProfiled =

 type instance RuleResult GhcProfiled = Bool

 oracles :: Rules ()

 type ModuleName = String

 newtype ModuleFiles = ModuleFiles (Stage, Package)

 type instance RuleResult ModuleFiles = [Maybe FilePath]

 newtype Generator = Generator (Stage, Package, FilePath)

 type instance RuleResult Generator = Maybe FilePath

 -- | We scan for the following Haskell source extensions when looking for module

 # libraries/text/cbits/measure_off.c:50:39: runtime left shift of 1 by 31 places cannot be represented in type 'int'

 shift-base:libraries/text/cbits/measure_off.c

 #include "stg/MachRegsForHost.h"

 #include "stg/Regs.h"

 #include "stg/Ticky.h"

 #include "rts/TSANUtils.h"

 #if IN_STG_CODE

     UndefinedBehaviorSanitizer.

   default: False

   manual: True

 flag shared-libsan

   description:

     Link with -shared-libsan, to guarantee only one copy of the

       if flag(ubsan)

         ld-options: -fsanitize=undefined

       if flag(shared-libsan)

         ld-options: -shared-libsan

                         -- ^ generated

                         rts/ghc_ffi.h

                         rts/Adjustor.h

                         rts/ExecPage.h

                         rts/BlockSignals.h

                         rts/Bytecodes.h

     ret = getCommittedMBlocks(n);

     debugTrace(DEBUG_gc, "allocated %d megablock(s) at %p",n,ret);

     mblocks_allocated += n;

     mblocks_allocated -= n;

     decommitMBlocks(addr, n);

 }

         # Are we running with UndefinedBehaviorSanitizer enabled?

         self.have_ubsan = False

         # Do symbols use leading underscores?

         self.leading_underscore = False

 def have_ubsan( ) -> bool:

     return config.have_ubsan

 def gcc_as_cmmp() -> bool:

     return config.cmm_cpp_is_gcc

      # Recent versions of osx report an error when running `ulimit -v`

      when(opsys('darwin'), skip),

      when(arch('powerpc64le'), skip),

      cmd_prefix('ulimit -v ' + str(8 * 1024 ** 2) + ' && '),

      ignore_stdout],

     run_command,