Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found

Target

Select target project
  • ghc/ghc
  • bgamari/ghc
  • syd/ghc
  • ggreif/ghc
  • watashi/ghc
  • RolandSenn/ghc
  • mpickering/ghc
  • DavidEichmann/ghc
  • carter/ghc
  • harpocrates/ghc
  • ethercrow/ghc
  • mijicd/ghc
  • adamse/ghc
  • alexbiehl/ghc
  • gridaphobe/ghc
  • trofi/ghc
  • supersven/ghc
  • ppk/ghc
  • ulysses4ever/ghc
  • AndreasK/ghc
  • ghuntley/ghc
  • shayne-fletcher-da/ghc
  • fgaz/ghc
  • yav/ghc
  • osa1/ghc
  • mbbx6spp/ghc
  • JulianLeviston/ghc
  • reactormonk/ghc
  • rae/ghc
  • takenobu-hs/ghc
  • michalt/ghc
  • andrewthad/ghc
  • hsyl20/ghc
  • scottgw/ghc
  • sjakobi/ghc
  • angerman/ghc
  • RyanGlScott/ghc
  • hvr/ghc
  • howtonotwin/ghc
  • chessai/ghc
  • m-renaud/ghc
  • brprice/ghc
  • stevehartdata/ghc
  • sighingnow/ghc
  • kgardas/ghc
  • ckoparkar/ghc
  • alp/ghc
  • smaeul/ghc
  • kakkun61/ghc
  • sykloid/ghc
  • newhoggy/ghc
  • toonn/ghc
  • nineonine/ghc
  • Phyx/ghc
  • ezyang/ghc
  • tweag/ghc
  • langston/ghc
  • ndmitchell/ghc
  • rockbmb/ghc
  • artempyanykh/ghc
  • mniip/ghc
  • mynguyenbmc/ghc
  • alexfmpe/ghc
  • crockeea/ghc
  • nh2/ghc
  • vaibhavsagar/ghc
  • phadej/ghc
  • Haskell-mouse/ghc
  • lolotp/ghc
  • spacekitteh/ghc
  • michaelpj/ghc
  • mgsloan/ghc
  • HPCohen/ghc
  • tmobile/ghc
  • radrow/ghc
  • simonmar/ghc
  • _deepfire/ghc
  • Ericson2314/ghc
  • leitao/ghc
  • fumieval/ghc
  • trac-isovector/ghc
  • cblp/ghc
  • xich/ghc
  • ciil/ghc
  • erthalion/ghc
  • xldenis/ghc
  • autotaker/ghc
  • haskell-wasm/ghc
  • kcsongor/ghc
  • agander/ghc
  • Baranowski/ghc
  • trac-dredozubov/ghc
  • 23Skidoo/ghc
  • iustin/ghc
  • ningning/ghc
  • josefs/ghc
  • kabuhr/ghc
  • gallais/ghc
  • dten/ghc
  • expipiplus1/ghc
  • Pluralia/ghc
  • rohanjr/ghc
  • intricate/ghc
  • kirelagin/ghc
  • Javran/ghc
  • DanielG/ghc
  • trac-mizunashi_mana/ghc
  • pparkkin/ghc
  • bollu/ghc
  • ntc2/ghc
  • jaspervdj/ghc
  • JoshMeredith/ghc
  • wz1000/ghc
  • zkourouma/ghc
  • code5hot/ghc
  • jdprice/ghc
  • tdammers/ghc
  • J-mie6/ghc
  • trac-lantti/ghc
  • ch1bo/ghc
  • cgohla/ghc
  • lucamolteni/ghc
  • acairncross/ghc
  • amerocu/ghc
  • chreekat/ghc
  • txsmith/ghc
  • trupill/ghc
  • typetetris/ghc
  • sergv/ghc
  • fryguybob/ghc
  • erikd/ghc
  • trac-roland/ghc
  • setupminimal/ghc
  • Friede80/ghc
  • SkyWriter/ghc
  • xplorld/ghc
  • abrar/ghc
  • obsidiansystems/ghc
  • Icelandjack/ghc
  • adinapoli/ghc
  • trac-matthewbauer/ghc
  • heatsink/ghc
  • dwijnand/ghc
  • Cmdv/ghc
  • alinab/ghc
  • pepeiborra/ghc
  • fommil/ghc
  • luochen1990/ghc
  • rlupton20/ghc
  • applePrincess/ghc
  • lehins/ghc
  • ronmrdechai/ghc
  • leeadam/ghc
  • harendra/ghc
  • mightymosquito1991/ghc
  • trac-gershomb/ghc
  • lucajulian/ghc
  • Rizary/ghc
  • VictorCMiraldo/ghc
  • jamesbrock/ghc
  • andrewdmeier/ghc
  • luke/ghc
  • pranaysashank/ghc
  • cocreature/ghc
  • hithroc/ghc
  • obreitwi/ghc
  • slrtbtfs/ghc
  • kaol/ghc
  • yairchu/ghc
  • Mathemagician98/ghc
  • trac-taylorfausak/ghc
  • leungbk/ghc
  • MichaWiedenmann/ghc
  • chris-martin/ghc
  • TDecki/ghc
  • adithyaov/ghc
  • trac-gelisam/ghc
  • Lysxia/ghc
  • complyue/ghc
  • bwignall/ghc
  • sternmull/ghc
  • sonika/ghc
  • leif/ghc
  • broadwaylamb/ghc
  • myszon/ghc
  • danbroooks/ghc
  • Mechachleopteryx/ghc
  • zardyh/ghc
  • trac-vdukhovni/ghc
  • OmarKhaledAbdo/ghc
  • arrowd/ghc
  • Bodigrim/ghc
  • matheus23/ghc
  • cardenaso11/ghc
  • trac-Athas/ghc
  • mb720/ghc
  • DylanZA/ghc
  • liff/ghc
  • typedrat/ghc
  • trac-claude/ghc
  • jbm/ghc
  • Gertjan423/ghc
  • PHO/ghc
  • JKTKops/ghc
  • kockahonza/ghc
  • msakai/ghc
  • Sir4ur0n/ghc
  • barambani/ghc
  • vishnu.c/ghc
  • dcoutts/ghc
  • trac-runeks/ghc
  • trac-MaxGabriel/ghc
  • lexi.lambda/ghc
  • strake/ghc
  • spavikevik/ghc
  • JakobBruenker/ghc
  • rmanne/ghc
  • gdziadkiewicz/ghc
  • ani/ghc
  • iliastsi/ghc
  • smunix/ghc
  • judah/ghc
  • blackgnezdo/ghc
  • emilypi/ghc
  • trac-bpfoley/ghc
  • muesli4/ghc
  • trac-gkaracha/ghc
  • Kleidukos/ghc
  • nek0/ghc
  • TristanCacqueray/ghc
  • dwulive/ghc
  • mbakke/ghc
  • arybczak/ghc
  • Yang123321/ghc
  • maksbotan/ghc
  • QuietMisdreavus/ghc
  • trac-olshanskydr/ghc
  • emekoi/ghc
  • samuela/ghc
  • josephcsible/ghc
  • dramforever/ghc
  • lpsmith/ghc
  • DenisFrezzato/ghc
  • michivi/ghc
  • jneira/ghc
  • jeffhappily/ghc
  • Ivan-Yudin/ghc
  • nakaji-dayo/ghc
  • gdevanla/ghc
  • galen/ghc
  • fendor/ghc
  • yaitskov/ghc
  • rcythr/ghc
  • awpr/ghc
  • jeremyschlatter/ghc
  • Aver1y/ghc
  • mitchellvitez/ghc
  • merijn/ghc
  • tomjaguarpaw1/ghc
  • trac-NoidedSuper/ghc
  • erewok/ghc
  • trac-junji.hashimoto/ghc
  • adamwespiser/ghc
  • bjaress/ghc
  • jhrcek/ghc
  • leonschoorl/ghc
  • lukasz-golebiewski/ghc
  • sheaf/ghc
  • last-g/ghc
  • carassius1014/ghc
  • eschwartz/ghc
  • dwincort/ghc
  • felixwiemuth/ghc
  • TimWSpence/ghc
  • marcusmonteirodesouza/ghc
  • WJWH/ghc
  • vtols/ghc
  • theobat/ghc
  • BinderDavid/ghc
  • ckoparkar0/ghc
  • alexander-kjeldaas/ghc
  • dme2/ghc
  • philderbeast/ghc
  • aaronallen8455/ghc
  • rayshih/ghc
  • benkard/ghc
  • mpardalos/ghc
  • saidelman/ghc
  • leiftw/ghc
  • ca333/ghc
  • bwroga/ghc
  • nmichael44/ghc
  • trac-crobbins/ghc
  • felixonmars/ghc
  • adityagupta1089/ghc
  • hgsipiere/ghc
  • treeowl/ghc
  • alexpeits/ghc
  • CraigFe/ghc
  • dnlkrgr/ghc
  • kerckhove_ts/ghc
  • cptwunderlich/ghc
  • eiais/ghc
  • hahohihu/ghc
  • sanchayan/ghc
  • lemmih/ghc
  • sehqlr/ghc
  • trac-dbeacham/ghc
  • luite/ghc
  • trac-f-a/ghc
  • vados/ghc
  • luntain/ghc
  • fatho/ghc
  • alexbiehl-gc/ghc
  • dcbdan/ghc
  • tvh/ghc
  • liam-ly/ghc
  • timbobbarnes/ghc
  • GovanifY/ghc
  • shanth2600/ghc
  • gliboc/ghc
  • duog/ghc
  • moxonsghost/ghc
  • zander/ghc
  • masaeedu/ghc
  • georgefst/ghc
  • guibou/ghc
  • nicuveo/ghc
  • mdebruijne/ghc
  • stjordanis/ghc
  • emiflake/ghc
  • wygulmage/ghc
  • frasertweedale/ghc
  • coot/ghc
  • aratamizuki/ghc
  • tsandstr/ghc
  • mrBliss/ghc
  • Anton-Latukha/ghc
  • tadfisher/ghc
  • vapourismo/ghc
  • Sorokin-Anton/ghc
  • basile-henry/ghc
  • trac-mightybyte/ghc
  • AbsoluteNikola/ghc
  • cobrien99/ghc
  • songzh/ghc
  • blamario/ghc
  • aj4ayushjain/ghc
  • trac-utdemir/ghc
  • tangcl/ghc
  • hdgarrood/ghc
  • maerwald/ghc
  • arjun/ghc
  • ratherforky/ghc
  • haskieLambda/ghc
  • EmilGedda/ghc
  • Bogicevic/ghc
  • eddiejessup/ghc
  • kozross/ghc
  • AlistairB/ghc
  • 3Rafal/ghc
  • christiaanb/ghc
  • trac-bit/ghc
  • matsumonkie/ghc
  • trac-parsonsmatt/ghc
  • chisui/ghc
  • jaro/ghc
  • trac-kmiyazato/ghc
  • davidsd/ghc
  • Tritlo/ghc
  • I-B-3/ghc
  • lykahb/ghc
  • AriFordsham/ghc
  • turion1/ghc
  • berberman/ghc
  • christiantakle/ghc
  • zyklotomic/ghc
  • trac-ocramz/ghc
  • CSEdd/ghc
  • doyougnu/ghc
  • mmhat/ghc
  • why-not-try-calmer/ghc
  • plutotulp/ghc
  • kjekac/ghc
  • Manvi07/ghc
  • teo/ghc
  • cactus/ghc
  • CarrieMY/ghc
  • abel/ghc
  • yihming/ghc
  • tsakki/ghc
  • jessicah/ghc
  • oliverbunting/ghc
  • meld/ghc
  • friedbrice/ghc
  • Joald/ghc
  • abarbu/ghc
  • DigitalBrains1/ghc
  • sterni/ghc
  • alexDarcy/ghc
  • hexchain/ghc
  • minimario/ghc
  • zliu41/ghc
  • tommd/ghc
  • jazcarate/ghc
  • peterbecich/ghc
  • alirezaghey/ghc
  • solomon/ghc
  • mikael.urankar/ghc
  • davjam/ghc
  • int-index/ghc
  • MorrowM/ghc
  • nrnrnr/ghc
  • Sonfamm/ghc-test-only
  • afzt1/ghc
  • nguyenhaibinh-tpc/ghc
  • trac-lierdakil/ghc
  • MichaWiedenmann1/ghc
  • jmorag/ghc
  • Ziharrk/ghc
  • trac-MitchellSalad/ghc
  • juampe/ghc
  • jwaldmann/ghc
  • snowleopard/ghc
  • juhp/ghc
  • normalcoder/ghc
  • ksqsf/ghc
  • trac-jberryman/ghc
  • roberth/ghc
  • 1ntEgr8/ghc
  • epworth/ghc
  • MrAdityaAlok/ghc
  • JunmingZhao42/ghc
  • jappeace/ghc
  • trac-Gabriel439/ghc
  • alt-romes/ghc
  • HugoPeters1024/ghc
  • 10ne1/ghc-fork
  • agentultra/ghc
  • Garfield1002/ghc
  • ChickenProp/ghc
  • clyring/ghc
  • MaxHearnden/ghc
  • jumper149/ghc
  • vem/ghc
  • ketzacoatl/ghc
  • Rosuavio/ghc
  • jackohughes/ghc
  • p4l1ly/ghc
  • konsumlamm/ghc
  • shlevy/ghc
  • torsten.schmits/ghc
  • andremarianiello/ghc
  • amesgen/ghc
  • googleson78/ghc
  • InfiniteVerma/ghc
  • uhbif19/ghc
  • yiyunliu/ghc
  • raehik/ghc
  • mrkun/ghc
  • telser/ghc
  • 1Jajen1/ghc
  • slotThe/ghc
  • WinstonHartnett/ghc
  • mpilgrem/ghc
  • dreamsmasher/ghc
  • schuelermine/ghc
  • trac-Viwor/ghc
  • undergroundquizscene/ghc
  • evertedsphere/ghc
  • coltenwebb/ghc
  • oberblastmeister/ghc
  • agrue/ghc
  • lf-/ghc
  • zacwood9/ghc
  • steshaw/ghc
  • high-cloud/ghc
  • SkamDart/ghc
  • PiDelport/ghc
  • maoif/ghc
  • RossPaterson/ghc
  • CharlesTaylor7/ghc
  • ribosomerocker/ghc
  • trac-ramirez7/ghc
  • daig/ghc
  • NicolasT/ghc
  • FinleyMcIlwaine/ghc
  • lawtonnichols/ghc
  • jmtd/ghc
  • ozkutuk/ghc
  • wildsebastian/ghc
  • nikshalark/ghc
  • lrzlin/ghc
  • tobias/ghc
  • fw/ghc
  • hawkinsw/ghc
  • type-dance/ghc
  • rui314/ghc
  • ocharles/ghc
  • wavewave/ghc
  • TheKK/ghc
  • nomeata/ghc
  • trac-csabahruska/ghc
  • jonathanjameswatson/ghc
  • L-as/ghc
  • Axman6/ghc
  • barracuda156/ghc
  • trac-jship/ghc
  • jake-87/ghc
  • meooow/ghc
  • rebeccat/ghc
  • hamana55/ghc
  • Enigmage/ghc
  • kokobd/ghc
  • agevelt/ghc
  • gshen42/ghc
  • chrismwendt/ghc
  • MangoIV/ghc
  • teto/ghc
  • Sookr1/ghc
  • trac-thomasjm/ghc
  • barci2/ghc-dev
  • trac-m4dc4p/ghc
  • dixonary/ghc
  • breakerzirconia/ghc
  • alexsio27444/ghc
  • glocq/ghc
  • sourabhxyz/ghc
  • ryantrinkle/ghc
  • Jade/ghc
  • scedfaliako/ghc
  • martijnbastiaan/ghc
  • trac-george.colpitts/ghc
  • ammarbinfaisal/ghc
  • mimi.vx/ghc
  • lortabac/ghc
  • trac-zyla/ghc
  • benbellick/ghc
  • aadaa-fgtaa/ghc
  • jvanbruegge/ghc
  • archbung/ghc
  • gilmi/ghc
  • mfonism/ghc
  • alex-mckenna/ghc
  • Ei30metry/ghc
  • DiegoDiverio/ghc
  • jorgecunhamendes/ghc
  • liesnikov/ghc
  • akrmn/ghc
  • trac-simplifierticks/ghc
  • jacco/ghc
  • rhendric/ghc
  • damhiya/ghc
  • ryndubei/ghc
  • DaveBarton/ghc
  • trac-Profpatsch/ghc
  • GZGavinZhao/ghc
  • ncfavier/ghc
  • jameshaydon/ghc
  • ajccosta/ghc
  • dschrempf/ghc
  • cydparser/ghc
  • LinuxUserGD/ghc
  • elodielander/ghc
  • facundominguez/ghc
  • psilospore/ghc
  • lachrimae/ghc
  • dylan-thinnes/ghc-type-errors-plugin
  • hamishmack/ghc
  • Leary/ghc
  • lzszt/ghc
  • lyokha/ghc
  • trac-glaubitz/ghc
  • Rewbert/ghc
  • andreabedini/ghc
  • Jasagredo/ghc
  • sol/ghc
  • OlegAlexander/ghc
  • trac-sthibaul/ghc
  • avdv/ghc
  • Wendaolee/ghc
  • ur4t/ghc
  • daylily/ghc
  • boltzmannrain/ghc
  • mmzk1526/ghc
  • trac-fizzixnerd/ghc
  • soulomoon/ghc
  • rwmjones/ghc
  • j14i/ghc
  • tracsis/ghc
  • gesh/ghc
  • flip101/ghc
  • eldritch-cookie/ghc
  • LemonjamesD/ghc
  • pgujjula/ghc
  • skeuchel/ghc
  • noteed/ghc
  • gulin.serge/ghc
  • Torrekie/ghc
  • jlwoodwa/ghc
  • ayanamists/ghc
  • husong998/ghc
  • trac-edmundnoble/ghc
  • josephf/ghc
  • contrun/ghc
  • baulig/ghc
  • edsko/ghc
  • mzschr/ghc-issue-24732
  • ulidtko/ghc
  • Arsen/ghc
  • trac-sjoerd_visscher/ghc
  • crumbtoo/ghc
  • L0neGamer/ghc
  • DrewFenwick/ghc
  • benz0li/ghc
  • MaciejWas/ghc
  • jordanrule/ghc
  • trac-qqwy/ghc
  • LiamGoodacre/ghc
  • isomorpheme/ghc
  • trac-danidiaz/ghc
  • Kariim/ghc
  • MTaimoorZaeem/ghc
  • hololeap/ghc
  • ticat-fp/ghc
  • meritamen/ghc
  • criskell/ghc
  • trac-kraai/ghc
  • aergus/ghc
  • jdral/ghc
  • SamB/ghc
  • Tristian/ghc
  • ywgrit/ghc
  • KatsuPatrick/ghc
  • OsePedro/ghc
  • mpscholten/ghc
  • fp/ghc
  • zaquest/ghc
  • fangyi-zhou/ghc
  • augyg/ghc
640 results
Show changes
Commits on Source (64)
  • Matthew Pickering's avatar
    Introduce GHCiMessage to wrap GhcMessage · f8ced241
    Matthew Pickering authored and Marge Bot's avatar Marge Bot committed
    By introducing a wrapped message type we can control how certain
    messages are printed in GHCi (to add extra information for example)
    f8ced241
  • Matthew Pickering's avatar
    Generalise UnknownDiagnostic to allow embedded diagnostics to access · 58e554c1
    Matthew Pickering authored and Marge Bot's avatar Marge Bot committed
    parent diagnostic options.
    
    * Split default diagnostic options from Diagnostic class into
      HasDefaultDiagnosticOpts class.
    * Generalise UnknownDiagnostic to allow embedded diagnostics to access
      options.
    
    The principle idea here is that when wrapping an error message (such as
    GHCMessage to make GHCiMessage) then we need to also be able to lift the
    configuration when overriding how messages are printed (see load' for an
    example).
    58e554c1
  • Matthew Pickering's avatar
    Allow API users to wrap error messages created during 'load' · b112546a
    Matthew Pickering authored and Marge Bot's avatar Marge Bot committed
    This allows API users to configure how messages are rendered when they
    are emitted from the load function. For an example see how
    'loadWithCache' is used in GHCi.
    b112546a
  • Matthew Pickering's avatar
    Abstract cantFindError and turn Opt_BuildingCabal into a print-time option · 2e4cf0ee
    Matthew Pickering authored and Marge Bot's avatar Marge Bot committed
    * cantFindError is abstracted so that the parts which mention specific
      things about ghc/ghci are parameters. The intention being that
      GHC/GHCi can specify the right values to put here but otherwise
      display the same error message.
    * The BuildingCabalPackage argument from GenericMissing is removed and
      turned into a print-time option. The reason for the error is not
      dependent on whether `-fbuilding-cabal-package` is passed, so we don't
      want to store that in the error message.
    2e4cf0ee
  • Matthew Pickering's avatar
    error messages: Don't display ghci specific hints for missing packages · 34b44f7d
    Matthew Pickering authored and Marge Bot's avatar Marge Bot committed
    Tickets like #22884 suggest that it is confusing that GHC used on the
    command line can suggest options which only work in GHCi.
    
    This ticket uses the error message infrastructure to override certain
    error messages which displayed GHCi specific information so that this
    information is only showed when using GHCi.
    
    The main annoyance is that we mostly want to display errors in the same
    way as before, but with some additional information. This means that the
    error rendering code has to be exported from the Iface/Errors/Ppr.hs
    module.
    
    I am unsure about whether the approach taken here is the best or most
    maintainable solution.
    
    Fixes #22884
    34b44f7d
  • Matthew Pickering's avatar
    ghcup-metadata: Don't override existing metadata if version already exists. · 05a1b626
    Matthew Pickering authored and Marge Bot's avatar Marge Bot committed
    If a nightly pipeline runs twice for some reason for the same version
    then we really don't want to override an existing entry with new
    bindists. This could cause ABI compatability issues for users or break
    ghcup's caching logic.
    05a1b626
  • Matthew Pickering's avatar
    ghcup-metadata: Use proper API url for bindist download · fcbcb3cc
    Matthew Pickering authored and Marge Bot's avatar Marge Bot committed
    Previously we were using links from the web interface, but it's more
    robust and future-proof to use the documented links to the artifacts.
    
    https://docs.gitlab.com/ee/api/job_artifacts.html
    fcbcb3cc
  • Matthew Pickering's avatar
    ghcup-metadata: Set Nightly and LatestNightly tags · 5b59c8fe
    Matthew Pickering authored and Marge Bot's avatar Marge Bot committed
    The latest nightly release needs the LatestNightly tag, and all other
    nightly releases need the Nightly tag. Therefore when the metadata is
    updated we need to replace all LatestNightly with Nightly.`
    5b59c8fe
  • Matthew Pickering's avatar
    ghcup-metadata: Download nightly metadata for correct date · 914e1468
    Matthew Pickering authored and Marge Bot's avatar Marge Bot committed
    The metadata now lives in https://gitlab.haskell.org/ghc/ghcup-metadata
    with one metadata file per year. When we update the metadata we download
    and update the right file for the current year.
    914e1468
  • Matthew Pickering's avatar
    ghcup-metadata: Download metadata and update for correct year · 16cf7d2e
    Matthew Pickering authored and Marge Bot's avatar Marge Bot committed
    something about pipeline date
    16cf7d2e
  • Matthew Pickering's avatar
    ghcup-metadata: Don't skip CI · 14792c4b
    Matthew Pickering authored and Marge Bot's avatar Marge Bot committed
    On a push we now have a CI job which updates gitlab pages with the
    metadata files.
    14792c4b
  • Matthew Pickering's avatar
    ghcup-metadata: Add --date flag to specify the release date · 1121bdd8
    Matthew Pickering authored and Marge Bot's avatar Marge Bot committed
    The ghcup-metadata now has a viReleaseDay field which needs to be
    populated with the day of the release.
    1121bdd8
  • Matthew Pickering's avatar
    ghcup-metadata: Add dlOutput field · bc478bee
    Matthew Pickering authored and Marge Bot's avatar Marge Bot committed
    ghcup now requires us to add this field which specifies where it should
    download the bindist to. See
    ghc/ghcup-metadata#1 for some more
    discussion.
    bc478bee
  • Josh Meredith's avatar
    JS: Convert rendering to use HLine instead of SDoc (#22455) · 2bdbd9da
    Josh Meredith authored and Marge Bot's avatar Marge Bot committed
    2bdbd9da
  • Norman Ramsey's avatar
    testsuite: add WasmControlFlow test · abd9e37c
    Norman Ramsey authored and Marge Bot's avatar Marge Bot committed
    This patch adds the WasmControlFlow test to test the wasm backend's
    relooper component.
    abd9e37c
  • Sylvain Henry's avatar
    Factorize getLinkDeps · 07f858eb
    Sylvain Henry authored and Marge Bot's avatar Marge Bot committed
    Prepare reuse of getLinkDeps for TH implementation in the JS backend
    (cf #22261 and review of !9779).
    07f858eb
  • Oleg Grenrus's avatar
    Change GHC.Driver.Session import to .DynFlags · fad9d092
    Oleg Grenrus authored and Marge Bot's avatar Marge Bot committed
    Also move targetPlatform selector
    
    Plenty of GHC needs just DynFlags.
    Even more can be made to use .DynFlags if more selectors is migrated.
    This is a low hanging fruit.
    fad9d092
  • Alan Zimmerman's avatar
    EPA: Better fix for #22919 · 69fdbece
    Alan Zimmerman authored and Marge Bot's avatar Marge Bot committed
    The original fix for #22919 simply removed the ability to match up
    prior comments with the first declaration in the file.
    
    Restore it, but add a check that the comment is on a single line, by
    ensuring that it comes immediately prior to the next thing (comment or
    start of declaration), and that the token preceding it is not on the
    same line.
    
    closes #22919
    69fdbece
  • Josh Meredith's avatar
  • Matthew Pickering's avatar
    testsuite: Pass -kb16k -kc128k for performance tests · b4816919
    Matthew Pickering authored and Marge Bot's avatar Marge Bot committed
    Setting a larger stack chunk size gives a greater protection
    from stack thrashing (where the repeated overflow/underflow allocates a lot of
    stack chunks which sigificantly impact allocations). This
    stabilises some tests against differences cause by more things being
    pushed onto the stack.
    
    The performance tests are generally testing work done by the compiler,
    using allocation as a proxy, so removing/stabilising the allocations due
    to the stack gives us more stable tests which are also more sensitive
    to actual changes in compiler performance.
    
    The tests which increase are ones where we compile a lot of modules, and
    for each module we spawn a thread to compile the module in. Therefore
    increasing these numbers has a multiplying effect on these tests because
    there are many more stacks which we can increase in size.
    
    The most significant improvements though are cases such as T8095 which
    reduce significantly in allocations (30%). This isn't a performance
    improvement really but just helps stabilise the test against this
    threshold set by the defaults.
    
    Fixes #23439
    
    -------------------------
    Metric Decrease:
        InstanceMatching
        T14683
        T8095
        T9872b_defer
        T9872d
        T9961
        hie002
        T19695
        T3064
    Metric Increase:
        MultiLayerModules
        T13701
        T14697
    -------------------------
    b4816919
  • Ben Gamari's avatar
    Move via-C flags into GHC · 6629f1c5
    Ben Gamari authored and Marge Bot's avatar Marge Bot committed
    These were previously hardcoded in configure (with no option for
    overriding them) and simply passed onto ghc through the settings file.
    
    Since configure already guarantees gcc supports those flags, we simply
    move them into GHC.
    6629f1c5
  • Arnaud Spiwack's avatar
    Allow CPR on unrestricted constructors · 981e5e11
    Arnaud Spiwack authored and Marge Bot's avatar Marge Bot committed
    Per the new `Note [Linting linearity]`, we want optimisations over
    trying to preserve linearity. This will allow CPR to handle `Ur`, in
    particular.
    981e5e11
  • Arnaud Spiwack's avatar
    Push coercions across multiplicity boundaries · bf9344d2
    Arnaud Spiwack authored and Marge Bot's avatar Marge Bot committed
    Per the new `Note [Linting linearity]`, we want optimisations over
    trying to preserve linearity. This will avoid preventing inlinings and
    reductions and make linear programs more efficient.
    bf9344d2
  • sheaf's avatar
    Data.Bag: add INLINEABLE to polymorphic functions · d56dd695
    sheaf authored and Marge Bot's avatar Marge Bot committed
    This commit allows polymorphic methods in GHC.Data.Bag to be
    specialised, avoiding having to pass explicit dictionaries when they
    are instantiated with e.g. a known monad.
    d56dd695
  • sheaf's avatar
    Split off TcBinderStack into its own module · 5366cd35
    sheaf authored and Marge Bot's avatar Marge Bot committed
    This commit splits off TcBinderStack into its own module,
    to avoid module cycles: we might want to refer to it without also
    pulling in the TcM monad.
    5366cd35
  • sheaf's avatar
    Split off TcRef into its own module · 09d4d307
    sheaf authored and Marge Bot's avatar Marge Bot committed
    This helps avoid pull in the full TcM monad when we just want access
    to mutable references in the typechecker. This facilitates later patches
    which introduce a slimmed down TcM monad for zonking.
    09d4d307
  • sheaf's avatar
    Introduce Codensity monad · 88cc19b3
    sheaf authored and Marge Bot's avatar Marge Bot committed
    The Codensity monad is useful to write state-passing computations in
    continuation-passing style, e.g. to implement a State monad as
    continuation-passing style over a Reader monad.
    88cc19b3
  • sheaf's avatar
    Restructure the zonker · f62d8195
    sheaf authored and Marge Bot's avatar Marge Bot committed
    This commit splits up the zonker into a few separate components, described
    in Note [The structure of the zonker] in `GHC.Tc.Zonk.Type`.
    
    1. `GHC.Tc.Zonk.Monad` introduces a pared-down `TcM` monad, `ZonkM`,
         which has enough information for zonking types.
         This allows us to refactor `ErrCtxt` to use `ZonkM` instead of `TcM`,
         which guarantees we don't throw an error while reporting an error.
    
    2. `GHC.Tc.Zonk.Env` is the new home of `ZonkEnv`, and also defines
        two zonking monad transformers, `ZonkT` and `ZonkBndrT`.
        `ZonkT` is a reader monad transformer over `ZonkEnv`.
        `ZonkBndrT m` is the codensity monad over `ZonkT m`.
    
         `ZonkBndrT` is used for computations that accumulate binders
         in the `ZonkEnv`.
    
    3. `GHC.Tc.Zonk.TcType` contains the code for zonking types, for use
        in the typechecker. It uses the `ZonkM` monad.
    
    4. `GHC.Tc.Zonk.Type` contains the code for final zonking to `Type`,
        which has been refactored to use `ZonkTcM = ZonkT TcM` and
        `ZonkBndrTcM = ZonkBndrT TcM`.
    
    Allocations slightly decrease on the whole due to using
    continuation-passing style instead of manual state passing of ZonkEnv
    in the final zonking to Type.
    
    -------------------------
    Metric Decrease:
        T4029
        T8095
        T14766
        T15304
        hard_hole_fits
        RecordUpdPerf
    Metric Increase:
        T10421
    -------------------------
    f62d8195
  • mimi.vx's avatar
    Update rdt-theme to latest upstream version · 70526f5b
    mimi.vx authored and Marge Bot's avatar Marge Bot committed
    Fixes #23444
    70526f5b
  • Finley McIlwaine's avatar
    Restructure IPE buffer layout · f3556d6c
    Finley McIlwaine authored and Marge Bot's avatar Marge Bot committed
    Reference ticket #21766
    
    This commit restructures IPE buffer list entries to not contain
    references to their corresponding info tables. IPE buffer list nodes now
    point to two lists of equal length, one holding the list of info table
    pointers and one holding the corresponding entries for each info table.
    This will allow the entry data to be compressed without losing the
    references to the info tables.
    f3556d6c
  • Finley McIlwaine's avatar
    Add IPE compression to configure · 5d1f2411
    Finley McIlwaine authored and Marge Bot's avatar Marge Bot committed
    Reference ticket #21766
    
    Adds an `--enable-ipe-data-compreesion` flag to the configure script
    which will check for libzstd and set the appropriate flags to allow for
    IPE data compression in the compiler
    5d1f2411
  • Finley McIlwaine's avatar
    IPE data compression · b7a640ac
    Finley McIlwaine authored and Marge Bot's avatar Marge Bot committed
    Reference ticket #21766
    
    When IPE data compression is enabled, compress the emitted IPE buffer
    entries and decompress them in the RTS.
    b7a640ac
  • Finley McIlwaine's avatar
    Fix libzstd detection in configure and RTS · 5aef5658
    Finley McIlwaine authored and Marge Bot's avatar Marge Bot committed
    Ensure that `HAVE_LIBZSTD` gets defined to either 0 or 1 in all cases
    and properly check that before IPE data decompression in the RTS. See
    ticket #21766.
    5aef5658
  • Finley McIlwaine's avatar
    Add note describing IPE data compression · 69563c97
    Finley McIlwaine authored and Marge Bot's avatar Marge Bot committed
    See ticket #21766
    69563c97
  • Finley McIlwaine's avatar
    Fix byte order of IPE data, fix IPE tests · 7872e2b6
    Finley McIlwaine authored and Marge Bot's avatar Marge Bot committed
    Make sure byte order of written IPE buffer entries matches target.
    
    Make sure the IPE-related tests properly access the fields of IPE buffer
    entry nodes with the new IPE layout.
    
    This commit also introduces checks to avoid importing modules if IPE
    compression is not enabled.
    
    See ticket #21766.
    7872e2b6
  • Finley McIlwaine's avatar
    Fix IPE data decompression buffer allocation · 0e85099b
    Finley McIlwaine authored and Marge Bot's avatar Marge Bot committed
    Capacity of buffers allocated for decompressed IPE data was
    incorrect due to a misuse of the `ZSTD_findFrameCompressedSize`
    function. Fix by always storing decompressed size of IPE data in IPE
    buffer list nodes and using `ZSTD_findFrameCompressedSize` to determine
    the size of the compressed data.
    
    See ticket #21766
    0e85099b
  • Finley McIlwaine's avatar
    Add optional dependencies to ./configure output · a0048866
    Finley McIlwaine authored and Marge Bot's avatar Marge Bot committed
    Changes the configure script to indicate whether libnuma, libzstd, or
    libdw are being used as dependencies due to their optional features
    being enabled.
    a0048866
  • Finley McIlwaine's avatar
    Add IPE-enabled builds to CI · 09d93bd0
    Finley McIlwaine authored and Marge Bot's avatar Marge Bot committed
    - Adds an IPE job to the CI pipeline which is triggered by the ~IPE label
    - Introduces CI logic to enable IPE data compression
    - Enables uncompressed IPE data on debug CI job
    - Regenerates jobs.yaml
    
    MR ci-images!112 on the
    images repository is meant to ensure that the proper images have
    libzstd-dev installed.
    09d93bd0
  • Finley McIlwaine's avatar
    Update user's guide and release notes, small fixes · 3ded9a1c
    Finley McIlwaine authored and Marge Bot's avatar Marge Bot committed
    Add mention of IPE data compression to user's guide and the release
    notes for 9.8.1. Also note the impact compression has on binary size in
    both places.
    
    Change IpeBufferListNode compression check so only the value `1`
    indicates compression.
    
    See ticket #21766
    3ded9a1c
  • Finley McIlwaine's avatar
    Remove IPE enabled builds from CI · 41b41577
    Finley McIlwaine authored and Marge Bot's avatar Marge Bot committed
    We don't need to explicitly specify the +ipe transformer to test IPE data
    since there are tests which manually enable IPE information. This commit does
    leave zstd IPE data compression enabled on the debian CI jobs.
    41b41577
  • Krzysztof Gogolewski's avatar
    Fix build with 9.2 · 982bef3a
    Krzysztof Gogolewski authored and Marge Bot's avatar Marge Bot committed
    GHC.Tc.Zonk.Type uses an equality constraint.
    ghc.nix currently provides 9.2.
    982bef3a
  • Krzysztof Gogolewski's avatar
    Output Lint errors to stderr instead of stdout · 1c96bc3d
    Krzysztof Gogolewski authored and Marge Bot's avatar Marge Bot committed
    This is a continuation of 7b095b99, which fixed warnings but not errors.
    
    Refs #13342
    1c96bc3d
  • sheaf's avatar
    Refactor lookupExactOrOrig & friends · 8e81f140
    sheaf authored and Marge Bot's avatar Marge Bot committed
    This refactors the panoply of renamer lookup functions relating to
    lookupExactOrOrig to more graciously handle Exact and Orig names.
    
    In particular, we avoid the situation in which we would add Exact/Orig
    GREs to the tcg_used_gres field, which could cause a panic in bestImport
    like in #23240.
    
    Fixes #23428
    8e81f140
  • Krzysztof Gogolewski's avatar
    Use the one-shot trick for UM and RewriteM functors · 5d415bfd
    Krzysztof Gogolewski authored and Marge Bot's avatar Marge Bot committed
    As described in Note [The one-shot state monad trick],
    we shouldn't use derived Functor instances for monads using
    one-shot. This was done for most of them, but UM and RewriteM
    were missed.
    5d415bfd
  • Krzysztof Gogolewski's avatar
    Fix testsuite skipping Lint · 2c38551e
    Krzysztof Gogolewski authored and Marge Bot's avatar Marge Bot committed
    setTestOpts() is used to modify the test options for an entire .T file,
    rather than a single test.
    If there was a test using collect_compiler_stats, all of the tests
    in the same file had lint disabled.
    
    Fixes #21247
    2c38551e
  • Krzysztof Gogolewski's avatar
    Add testcases for already fixed #16432 · 00a1e50b
    Krzysztof Gogolewski authored and Marge Bot's avatar Marge Bot committed
    They were fixed by 40c7daed.
    
    Fixes #16432
    00a1e50b
  • Krzysztof Gogolewski's avatar
    cleanup: Remove unused field from SelfBoot · f6e060cc
    Krzysztof Gogolewski authored and Marge Bot's avatar Marge Bot committed
    It is no longer needed since Note [Extra dependencies from .hs-boot files]
    was deleted in 69987720.
    
    I've also added tildes to Note headers, otherwise they're not detected
    by the linter.
    f6e060cc
  • sheaf's avatar
    Delete GHC.Tc.Utils.Zonk · 82eacab6
    sheaf authored and Marge Bot's avatar Marge Bot committed
    This module was split up into GHC.Tc.Zonk.Type and GHC.Tc.Zonk.TcType
    in commit f62d8195, but I forgot to delete the original module
    82eacab6
  • Ben Gamari's avatar
    base: Add build-order import of GHC.Types in GHC.IO.Handle.Types · 4a4eb761
    Ben Gamari authored and Marge Bot's avatar Marge Bot committed
    For reasons similar to those described in Note [Depend on
    GHC.Num.Integer].
    
    Fixes #23411.
    4a4eb761
  • Sylvain Henry's avatar
    JS: fix and enhance non-minimized code generation (#22455) · f53ac0ae
    Sylvain Henry authored and Marge Bot's avatar Marge Bot committed
    Flag -ddisable-js-minimizer was producing invalid code. Fix that and
    also a few other things to generate nicer JS code for debugging.
    
    The added test checks that we don't regress when using the flag.
    f53ac0ae
  • Andrey Mokhov's avatar
    [hadrian] Fix multiline synopsis rendering · f7744e8e
    Andrey Mokhov authored and Marge Bot's avatar Marge Bot committed
    f7744e8e
  • Bodigrim's avatar
    Elaborate on performance properties of Data.List.++ · b2c745db
    Bodigrim authored and Marge Bot's avatar Marge Bot committed
    b2c745db
  • Matthew Pickering's avatar
    Big TcLclEnv and CtLoc refactoring · 7cd8a61e
    Matthew Pickering authored
    The overall goal of this refactoring is to reduce the dependency
    footprint of the parser and syntax tree. Good reasons include:
    
    - Better module graph parallelisability
    - Make it easier to migrate error messages without introducing module loops
    - Philosophically, there's not reason for the AST to depend on half the
      compiler.
    
    One of the key edges which added this dependency was
    
    > GHC.Hs.Expr -> GHC.Tc.Types (TcLclEnv)
    
    As this in turn depending on TcM which depends on HscEnv and so on.
    
    Therefore the goal of this patch is to move `TcLclEnv` out of
    `GHC.Tc.Types` so that `GHC.Hs.Expr` can import TcLclEnv without
    incurring a huge dependency chain.
    
    The changes in this patch are:
    
    * Move TcLclEnv from GHC.Tc.Types to GHC.Tc.Types.LclEnv
    * Create new smaller modules for the types used in TcLclEnv
      New Modules:
      - GHC.Tc.Types.ErrCtxt
      - GHC.Tc.Types.BasicTypes
      - GHC.Tc.Types.TH
      - GHC.Tc.Types.LclEnv
      - GHC.Tc.Types.CtLocEnv
      - GHC.Tc.Errors.Types.PromotionErr
    
      Removed Boot File:
      - {-# SOURCE #-} GHC.Tc.Types
    
    * Introduce TcLclCtxt, the part of the TcLclEnv which doesn't
      participate in restoreLclEnv.
    
    * Replace TcLclEnv in CtLoc with specific CtLocEnv which is defined in
      GHC.Tc.Types.CtLocEnv. Use CtLocEnv in Implic and CtLoc to record the
      location of the implication and constraint.
    
    By splitting up TcLclEnv from GHC.Tc.Types we allow GHC.Hs.Expr to no
    longer depend on the TcM monad and all that entails.
    
    Fixes #23389 #23409
    7cd8a61e
  • Matthew Pickering's avatar
    Remove dependency of GHC.Tc.Utils.TcType on GHC.Driver.Session · 3d8d39d1
    Matthew Pickering authored
    This removes the usage of DynFlags from Tc.Utils.TcType  so that it no
    longer depends on GHC.Driver.Session. In general we don't want anything
    which is a dependency of Language.Haskell.Syntax to depend on
    GHC.Driver.Session and removing this edge gets us closer to that goal.
    3d8d39d1
  • Matthew Pickering's avatar
    Move isIrrefutableHsPat to GHC.Rename.Utils and rename to isIrrefutableHsPatRn · 18db5ada
    Matthew Pickering authored
    This removes edge from GHC.Hs.Pat to GHC.Driver.Session, which makes
    Language.Haskell.Syntax end up depending on GHC.Driver.Session.
    18db5ada
  • Matthew Pickering's avatar
  • Matthew Pickering's avatar
    hole fit plugins: Split definition into own module · eb852371
    Matthew Pickering authored
    The hole fit plugins are defined in terms of TcM, a type we want to
    avoid depending on from `GHC.Tc.Errors.Types`. By moving it into its own
    module we can remove this dependency. It also simplifies the necessary
    boot file.
    eb852371
  • Matthew Pickering's avatar
    Move GHC.Core.Opt.CallerCC Types into separate module · 9e5246d7
    Matthew Pickering authored
    This allows `GHC.Driver.DynFlags` to depend on these types without
    depending on CoreM and hence the entire simplifier pipeline.
    
    We can also remove a hs-boot file with this change.
    9e5246d7
  • Matthew Pickering's avatar
    Remove unecessary SOURCE import · 52d6a7d7
    Matthew Pickering authored
    52d6a7d7
  • Matthew Pickering's avatar
    testsuite: Accept new output for CountDepsAst and CountDepsParser tests · 698d160c
    Matthew Pickering authored
    These are in a separate commit as the improvement to these tests is the
    cumulative effect of the previous set of patches rather than just the
    responsibility of the last one in the patchset.
    698d160c
  • sheaf's avatar
    TTG: only allow VarBind at GhcTc · 58ccf02e
    sheaf authored and Marge Bot's avatar Marge Bot committed
    The VarBind constructor of HsBind is only used at the GhcTc stage.
    This commit makes that explicit by setting the extension field of
    VarBind to be DataConCantHappen at all other stages.
    
    This allows us to delete a dead code path in GHC.HsToCore.Quote.rep_bind,
    and remove some panics.
    58ccf02e
  • Matthew Craven's avatar
    Generate Addr# access ops programmatically · 54b83253
    Matthew Craven authored and Marge Bot's avatar Marge Bot committed
    The existing utils/genprimopcode/gen_bytearray_ops.py was
    relocated and extended for this purpose.  Additionally, hadrian
    now knows about this script and uses it when generating primops.txt
    54b83253
  • Matthew Pickering's avatar
    ghcup-metadata: Only add Nightly tag when replacing LatestNightly · ecadbc7e
    Matthew Pickering authored and Marge Bot's avatar Marge Bot committed
    Previously we were always adding the Nightly tag, but this led to all
    the previous builds getting an increasing number of nightly tags over
    time. Now we just add it once, when we remove the LatestNightly tag.
    ecadbc7e
  • Simon Peyton Jones's avatar
    Don't report redundant Givens from quantified constraints · 57f47497
    Simon Peyton Jones authored
    This fixes #23323
    
    See (RC4) in Note [Tracking redundant constraints]
    57f47497
Showing
with 558 additions and 1015 deletions
......@@ -998,8 +998,9 @@ project-version:
# Calculate the project version
- . ./version.sh
# Download existing ghcup metadata
- nix shell --extra-experimental-features nix-command --extra-experimental-features flakes nixpkgs#wget -c wget "https://gitlab.haskell.org/ghc/ghcup-metadata/-/raw/updates/ghcup-0.0.7.yaml"
# Download existing ghcup metadata for the correct year
- PipelineYear="$(date -d $CI_PIPELINE_CREATED_AT +%Y)"
- nix shell nixpkgs#wget -c wget "https://ghc.gitlab.haskell.org/ghcup-metadata/ghcup-nightlies-$PipelineYear-0.0.7.yaml" -O ghcup-0.0.7.yaml
- .gitlab/generate_job_metadata
......@@ -1044,7 +1045,7 @@ ghcup-metadata-nightly:
artifacts: false
- job: project-version
script:
- nix shell --extra-experimental-features nix-command -f .gitlab/rel_eng -c ghcup-metadata --metadata ghcup-0.0.7.yaml --pipeline-id="$CI_PIPELINE_ID" --version="$ProjectVersion" > "metadata_test.yaml"
- nix shell --extra-experimental-features nix-command -f .gitlab/rel_eng -c ghcup-metadata --metadata ghcup-0.0.7.yaml --date="$(date -d $CI_PIPELINE_CREATED_AT +%Y-%M-%d)" --pipeline-id="$CI_PIPELINE_ID" --version="$ProjectVersion" > "metadata_test.yaml"
rules:
- if: $NIGHTLY
......@@ -1063,14 +1064,15 @@ ghcup-metadata-nightly-push:
artifacts: true
script:
- git clone https://gitlab.haskell.org/ghc/ghcup-metadata.git
- cp metadata_test.yaml ghcup-metadata/ghcup-0.0.7.yaml
- PipelineYear="$(date -d $CI_PIPELINE_CREATED_AT +%Y)"
- cp metadata_test.yaml "ghcup-metadata/ghcup-nightlies-$PipelineYear-0.0.7.yaml"
- cd ghcup-metadata
- git config user.email "ghc-ci@gitlab-haskell.org"
- git config user.name "GHC GitLab CI"
- git remote add gitlab_origin https://oauth2:$PROJECT_PUSH_TOKEN@gitlab.haskell.org/ghc/ghcup-metadata.git
- git add .
- git commit -m "Update metadata"
- git push gitlab_origin HEAD:updates -o ci.skip
- git push gitlab_origin HEAD:updates
rules:
# Only run the update on scheduled nightly pipelines, ie once a day
- if: $NIGHTLY && $CI_PIPELINE_SOURCE == "schedule" && $CI_COMMIT_BRANCH == "master"
......@@ -1080,7 +1082,7 @@ ghcup-metadata-release:
# No explicit needs for release pipeline as we assume we need everything and everything will pass.
extends: .ghcup-metadata
script:
- nix shell --extra-experimental-features nix-command -f .gitlab/rel_eng -c ghcup-metadata --release-mode --metadata ghcup-0.0.7.yaml --pipeline-id="$CI_PIPELINE_ID" --version="$ProjectVersion" > "metadata_test.yaml"
- nix shell --extra-experimental-features nix-command -f .gitlab/rel_eng -c ghcup-metadata --release-mode --metadata ghcup-0.0.7.yaml --date="$(date -d $CI_PIPELINE_CREATED_AT +%Y-%M-%d)" --pipeline-id="$CI_PIPELINE_ID" --version="$ProjectVersion" > "metadata_test.yaml"
rules:
- if: '$RELEASE_JOB == "yes"'
......
......@@ -141,6 +141,7 @@ data BuildConfig
, llvmBootstrap :: Bool
, withAssertions :: Bool
, withNuma :: Bool
, withZstd :: Bool
, crossTarget :: Maybe String
, crossEmulator :: CrossEmulator
, configureWrapper :: Maybe String
......@@ -154,10 +155,11 @@ data BuildConfig
-- Extra arguments to pass to ./configure due to the BuildConfig
configureArgsStr :: BuildConfig -> String
configureArgsStr bc = unwords $
["--enable-unregisterised"| unregisterised bc ]
["--enable-unregisterised"| unregisterised bc ]
++ ["--disable-tables-next-to-code" | not (tablesNextToCode bc) ]
++ ["--with-intree-gmp" | Just _ <- pure (crossTarget bc) ]
++ ["--with-system-libffi" | crossTarget bc == Just "wasm32-wasi" ]
++ ["--enable-ipe-data-compression" | withZstd bc ]
-- Compute the hadrian flavour from the BuildConfig
mkJobFlavour :: BuildConfig -> Flavour
......@@ -172,8 +174,12 @@ mkJobFlavour BuildConfig{..} = Flavour buildFlavour opts
data Flavour = Flavour BaseFlavour [FlavourTrans]
data FlavourTrans
= Llvm | Dwarf | FullyStatic | ThreadSanitiser | NoSplitSections
data FlavourTrans =
Llvm
| Dwarf
| FullyStatic
| ThreadSanitiser
| NoSplitSections
| BootNonmovingGc
data BaseFlavour = Release | Validate | SlowValidate deriving Eq
......@@ -192,6 +198,7 @@ vanilla = BuildConfig
, llvmBootstrap = False
, withAssertions = False
, withNuma = False
, withZstd = False
, crossTarget = Nothing
, crossEmulator = NoEmulator
, configureWrapper = Nothing
......@@ -224,6 +231,9 @@ debug = vanilla { buildFlavour = SlowValidate
, withNuma = True
}
zstdIpe :: BuildConfig
zstdIpe = vanilla { withZstd = True }
static :: BuildConfig
static = vanilla { fullyStatic = True }
......@@ -313,18 +323,18 @@ testEnv arch opsys bc = intercalate "-" $
-- | The hadrian flavour string we are going to use for this build
flavourString :: Flavour -> String
flavourString (Flavour base trans) = baseString base ++ concatMap (("+" ++) . flavourString) trans
flavourString (Flavour base trans) = base_string base ++ concatMap (("+" ++) . flavour_string) trans
where
baseString Release = "release"
baseString Validate = "validate"
baseString SlowValidate = "slow-validate"
base_string Release = "release"
base_string Validate = "validate"
base_string SlowValidate = "slow-validate"
flavourString Llvm = "llvm"
flavourString Dwarf = "debug_info"
flavourString FullyStatic = "fully_static"
flavourString ThreadSanitiser = "thread_sanitizer"
flavourString NoSplitSections = "no_split_sections"
flavourString BootNonmovingGc = "boot_nonmoving_gc"
flavour_string Llvm = "llvm"
flavour_string Dwarf = "debug_info"
flavour_string FullyStatic = "fully_static"
flavour_string ThreadSanitiser = "thread_sanitizer"
flavour_string NoSplitSections = "no_split_sections"
flavour_string BootNonmovingGc = "boot_nonmoving_gc"
-- The path to the docker image (just for linux builders)
dockerImage :: Arch -> Opsys -> Maybe String
......@@ -517,7 +527,7 @@ manualRule rules = rules { when = Manual }
-- For example, even if you don't explicitly disable a rule it will end up in the
-- rule list with the OFF state.
enumRules :: OnOffRules -> [OnOffRule]
enumRules o = map lkup rules
enumRules o = map lkup rulesList
where
enabled_rules = rule_set o
lkup r = OnOffRule (if S.member r enabled_rules then On else Off) r
......@@ -553,6 +563,7 @@ data Rule = FastCI -- ^ Run this job when the fast-ci label is set
| LLVMBackend -- ^ Only run this job when the "LLVM backend" label is present
| FreeBSDLabel -- ^ Only run this job when the "FreeBSD" label is set.
| NonmovingGc -- ^ Only run this job when the "non-moving GC" label is set.
| IpeData -- ^ Only run this job when the "IPE" label is set
| Disable -- ^ Don't run this job.
deriving (Bounded, Enum, Ord, Eq)
......@@ -579,12 +590,14 @@ ruleString On ReleaseOnly = "$RELEASE_JOB == \"yes\""
ruleString Off ReleaseOnly = "$RELEASE_JOB != \"yes\""
ruleString On Nightly = "$NIGHTLY"
ruleString Off Nightly = "$NIGHTLY == null"
ruleString On IpeData = "$CI_MERGE_REQUEST_LABELS =~ /.*IPE.*/"
ruleString Off IpeData = true
ruleString On Disable = false
ruleString Off Disable = true
-- Enumeration of all the rules
rules :: [Rule]
rules = [minBound .. maxBound]
rulesList :: [Rule]
rulesList = [minBound .. maxBound]
-- | A 'Job' is the description of a single job in a gitlab pipeline. The
-- job contains all the information about how to do the build but can be further
......@@ -873,6 +886,7 @@ job_groups =
, validateBuilds Amd64 (Linux Debian10) nativeInt
, fastCI (validateBuilds Amd64 (Linux Debian10) unreg)
, fastCI (validateBuilds Amd64 (Linux Debian10) debug)
, disableValidate (validateBuilds Amd64 (Linux Debian10) zstdIpe)
, -- Nightly allowed to fail: #22520
modifyNightlyJobs allowFailure
(modifyValidateJobs manual tsan_jobs)
......@@ -880,7 +894,7 @@ job_groups =
modifyNightlyJobs allowFailure
(modifyValidateJobs manual (validateBuilds Amd64 (Linux Debian10) noTntc))
, addValidateRule LLVMBackend (validateBuilds Amd64 (Linux Debian10) llvm)
, addValidateRule IpeData (validateBuilds Amd64 (Linux Debian10) zstdIpe)
, disableValidate (standardBuilds Amd64 (Linux Debian11))
-- We still build Deb9 bindists for now due to Ubuntu 18 and Linux Mint 19
-- not being at EOL until April 2023 and they still need tinfo5.
......
......@@ -35,7 +35,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -97,7 +97,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -155,7 +155,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -213,7 +213,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -276,7 +276,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -335,7 +335,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -394,7 +394,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -453,7 +453,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -518,7 +518,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -579,7 +579,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -641,7 +641,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -703,7 +703,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -765,7 +765,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -826,7 +826,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -887,7 +887,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -948,7 +948,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -1008,7 +1008,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -1067,7 +1067,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -1126,7 +1126,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -1186,7 +1186,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -1245,7 +1245,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -1264,7 +1264,7 @@
"BIGNUM_BACKEND": "gmp",
"BIN_DIST_NAME": "ghc-x86_64-linux-deb10-validate",
"BUILD_FLAVOUR": "validate",
"CONFIGURE_ARGS": "",
"CONFIGURE_ARGS": "--enable-ipe-data-compression",
"TEST_ENV": "x86_64-linux-deb10-validate",
"XZ_OPT": "-9"
}
......@@ -1304,7 +1304,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -1363,7 +1363,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -1422,7 +1422,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -1483,7 +1483,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -1544,7 +1544,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -1606,7 +1606,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -1665,7 +1665,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -1725,7 +1725,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -1784,7 +1784,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -1845,7 +1845,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -1907,7 +1907,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -1968,7 +1968,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -2028,7 +2028,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -2087,7 +2087,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -2142,7 +2142,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -2201,7 +2201,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -2264,7 +2264,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -2328,7 +2328,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -2389,7 +2389,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -2450,7 +2450,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -2516,7 +2516,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -2579,7 +2579,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -2642,7 +2642,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -2705,7 +2705,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -2766,7 +2766,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -2827,7 +2827,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -2888,7 +2888,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -2949,7 +2949,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -3011,7 +3011,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -3072,7 +3072,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -3135,7 +3135,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -3198,7 +3198,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -3261,7 +3261,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -3322,7 +3322,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -3383,7 +3383,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -3440,7 +3440,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -3500,7 +3500,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -3564,7 +3564,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -3628,7 +3628,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && ($CI_MERGE_REQUEST_LABELS =~ /.*FreeBSD.*/) && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && ($CI_MERGE_REQUEST_LABELS =~ /.*FreeBSD.*/) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -3688,7 +3688,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -3749,7 +3749,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -3810,7 +3810,7 @@
"rules": [
{
"allow_failure": true,
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "manual"
}
],
......@@ -3871,7 +3871,7 @@
"rules": [
{
"allow_failure": true,
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "manual"
}
],
......@@ -3931,7 +3931,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -3990,7 +3990,7 @@
"rules": [
{
"allow_failure": true,
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "manual"
}
],
......@@ -4048,7 +4048,7 @@
],
"rules": [
{
"if": "(\"true\" == \"true\") && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "(\"true\" == \"true\") && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -4107,7 +4107,7 @@
],
"rules": [
{
"if": "(\"true\" == \"true\") && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "(\"true\" == \"true\") && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -4130,6 +4130,64 @@
"TEST_ENV": "x86_64-linux-deb10-unreg-validate"
}
},
"x86_64-linux-deb10-validate": {
"after_script": [
".gitlab/ci.sh save_cache",
".gitlab/ci.sh clean",
"cat ci_timings"
],
"allow_failure": false,
"artifacts": {
"expire_in": "2 weeks",
"paths": [
"ghc-x86_64-linux-deb10-validate.tar.xz",
"junit.xml"
],
"reports": {
"junit": "junit.xml"
},
"when": "always"
},
"cache": {
"key": "x86_64-linux-deb10-$CACHE_REV",
"paths": [
"cabal-cache",
"toolchain"
]
},
"dependencies": [],
"image": "registry.gitlab.haskell.org/ghc/ci-images/x86_64-linux-deb10:$DOCKER_REV",
"needs": [
{
"artifacts": false,
"job": "hadrian-ghc-in-ghci"
}
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && ($CI_MERGE_REQUEST_LABELS =~ /.*IPE.*/) && (\"true\" == \"true\")",
"when": "on_success"
}
],
"script": [
"sudo chown ghc:ghc -R .",
".gitlab/ci.sh setup",
".gitlab/ci.sh configure",
".gitlab/ci.sh build_hadrian",
".gitlab/ci.sh test_hadrian"
],
"stage": "full-build",
"tags": [
"x86_64-linux"
],
"variables": {
"BIGNUM_BACKEND": "gmp",
"BIN_DIST_NAME": "ghc-x86_64-linux-deb10-validate",
"BUILD_FLAVOUR": "validate",
"CONFIGURE_ARGS": "--enable-ipe-data-compression",
"TEST_ENV": "x86_64-linux-deb10-validate"
}
},
"x86_64-linux-deb10-validate+debug_info": {
"after_script": [
".gitlab/ci.sh save_cache",
......@@ -4165,7 +4223,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -4223,7 +4281,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && ($CI_MERGE_REQUEST_LABELS =~ /.*LLVM backend.*/) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && ($CI_MERGE_REQUEST_LABELS =~ /.*LLVM backend.*/) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -4282,7 +4340,7 @@
"rules": [
{
"allow_failure": true,
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "manual"
}
],
......@@ -4342,7 +4400,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -4402,7 +4460,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -4463,7 +4521,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && ($CI_MERGE_REQUEST_LABELS =~ /.*non-moving GC.*/) && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && ($CI_MERGE_REQUEST_LABELS =~ /.*non-moving GC.*/) && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -4522,7 +4580,7 @@
],
"rules": [
{
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......@@ -4578,7 +4636,7 @@
],
"rules": [
{
"if": "(\"true\" == \"true\") && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"if": "(\"true\" == \"true\") && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success"
}
],
......
......@@ -18,6 +18,7 @@ options:
--release-mode Generate metadata which points to downloads folder
--fragment Output the generated fragment rather than whole modified file
--version VERSION Version of the GHC compiler
--date DATE Date of the compiler release
```
The script also requires the `.gitlab/jobs-metadata.yaml` file which can be generated
......
......@@ -63,7 +63,8 @@ eprint(f"Supported platforms: {job_mapping.keys()}")
# Artifact precisely specifies a job what the bindist to download is called.
class Artifact(NamedTuple):
job_name: str
name: str
download_name: str
output_name: str
subdir: str
# Platform spec provides a specification which is agnostic to Job
......@@ -72,8 +73,14 @@ class PlatformSpec(NamedTuple):
name: str
subdir: str
source_artifact = Artifact('source-tarball', 'ghc-{version}-src.tar.xz', 'ghc-{version}' )
test_artifact = Artifact('source-tarball', 'ghc-{version}-testsuite.tar.xz', 'ghc-{version}' )
source_artifact = Artifact('source-tarball'
, 'ghc-{version}-src.tar.xz'
, 'ghc-{version}-src.tar.xz'
, 'ghc-{version}' )
test_artifact = Artifact('source-tarball'
, 'ghc-{version}-testsuite.tar.xz'
, 'ghc-{version}-testsuite.tar.xz'
, 'ghc-{version}' )
def debian(arch, n):
return linux_platform(arch, "{arch}-linux-deb{n}".format(arch=arch, n=n))
......@@ -104,7 +111,7 @@ def linux_platform(arch, opsys):
return PlatformSpec( opsys, 'ghc-{version}-{arch}-unknown-linux'.format(version="{version}", arch=arch) )
base_url = 'https://gitlab.haskell.org/ghc/ghc/-/jobs/{job_id}/artifacts/raw/{artifact_name}'
base_url = 'https://gitlab.haskell.org/api/v4/projects/1/jobs/{job_id}/artifacts/{artifact_name}'
hash_cache = {}
......@@ -129,7 +136,7 @@ def download_and_hash(url):
def mk_one_metadata(release_mode, version, job_map, artifact):
job_id = job_map[artifact.job_name].id
url = base_url.format(job_id=job_id, artifact_name=urllib.parse.quote_plus(artifact.name.format(version=version)))
url = base_url.format(job_id=job_id, artifact_name=urllib.parse.quote_plus(artifact.download_name.format(version=version)))
# In --release-mode, the URL in the metadata needs to point into the downloads folder
# rather then the pipeline.
......@@ -143,10 +150,13 @@ def mk_one_metadata(release_mode, version, job_map, artifact):
eprint(f"Bindist URL: {url}")
eprint(f"Download URL: {final_url}")
# Download and hash from the release pipeline, this must not change anyway during upload.
#Download and hash from the release pipeline, this must not change anyway during upload.
h = download_and_hash(url)
res = { "dlUri": final_url, "dlSubdir": artifact.subdir.format(version=version), "dlHash" : h }
res = { "dlUri": final_url
, "dlSubdir": artifact.subdir.format(version=version)
, "dlOutput": artifact.output_name.format(version=version)
, "dlHash" : h }
eprint(res)
return res
......@@ -155,10 +165,14 @@ def mk_one_metadata(release_mode, version, job_map, artifact):
def mk_from_platform(pipeline_type, platform):
info = job_mapping[platform.name][pipeline_type]
eprint(f"From {platform.name} / {pipeline_type} selecting {info['name']}")
return Artifact(info['name'] , f"{info['jobInfo']['bindistName']}.tar.xz", platform.subdir)
return Artifact(info['name']
, f"{info['jobInfo']['bindistName']}.tar.xz"
, "ghc-{version}-{pn}.tar.xz".format(version="{version}", pn=platform.name)
, platform.subdir)
# Generate the new metadata for a specific GHC mode etc
def mk_new_yaml(release_mode, version, pipeline_type, job_map):
def mk_new_yaml(release_mode, version, date, pipeline_type, job_map):
def mk(platform):
eprint("\n=== " + platform.name + " " + ('=' * (75 - len(platform.name))))
return mk_one_metadata(release_mode, version, job_map, mk_from_platform(pipeline_type, platform))
......@@ -227,7 +241,14 @@ def mk_new_yaml(release_mode, version, pipeline_type, job_map):
else:
change_log = "https://gitlab.haskell.org"
return { "viTags": ["Latest", "TODO_base_version"]
if release_mode:
tags = ["Latest", "TODO_base_version"]
else:
tags = ["LatestNightly"]
return { "viTags": tags
, "viReleaseDay": date
# Check that this link exists
, "viChangeLog": change_log
, "viSourceDL": source
......@@ -239,6 +260,15 @@ def mk_new_yaml(release_mode, version, pipeline_type, job_map):
}
def setNightlyTags(ghcup_metadata):
for version in ghcup_metadata['ghcupDownloads']['GHC']:
if "LatestNightly" in ghcup_metadata['ghcupDownloads']['GHC'][version]["viTags"]:
ghcup_metadata['ghcupDownloads']['GHC'][version]["viTags"].remove("LatestNightly")
ghcup_metadata['ghcupDownloads']['GHC'][version]["viTags"].append("Nightly")
def main() -> None:
import argparse
......@@ -249,6 +279,7 @@ def main() -> None:
parser.add_argument('--fragment', action='store_true', help='Output the generated fragment rather than whole modified file')
# TODO: We could work out the --version from the project-version CI job.
parser.add_argument('--version', required=True, type=str, help='Version of the GHC compiler')
parser.add_argument('--date', required=True, type=str, help='Date of the compiler release')
args = parser.parse_args()
project = gl.projects.get(1, lazy=True)
......@@ -269,17 +300,21 @@ def main() -> None:
eprint(f"Pipeline Type: {pipeline_type}")
new_yaml = mk_new_yaml(args.release_mode, args.version, pipeline_type, job_map)
new_yaml = mk_new_yaml(args.release_mode, args.version, args.date, pipeline_type, job_map)
if args.fragment:
print(yaml.dump({ args.version : new_yaml }))
else:
with open(args.metadata, 'r') as file:
ghcup_metadata = yaml.safe_load(file)
if args.version in ghcup_metadata['ghcupDownloads']['GHC']:
raise RuntimeError("Refusing to override existing version in metadata")
setNightlyTags(ghcup_metadata)
ghcup_metadata['ghcupDownloads']['GHC'][args.version] = new_yaml
print(yaml.dump(ghcup_metadata))
if __name__ == '__main__':
main()
......@@ -763,6 +763,11 @@ Wrinkles
(W3) We need a TypeOrConstraint flag in LitRubbish.
(W4) In the CPR transformation, we can't unbox constructors with constraint
arguments because unboxed tuples (# …, … #) currently only supports fields
of type TYPE rr. See (CPR2) in Note [Which types are unboxed?] in
GHC.Core.Opt.WorkWrap.Utils.
Note [Type and Constraint are not apart]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Type and Constraint are not equal (eqType) but they are not /apart/
......
------------------------------------
-- ByteArray# operations
------------------------------------
-- Do not edit. This file is generated by utils/genprimopcode/gen_bytearray_ops.py.
-- To regenerate run,
--
-- python3 utils/genprimops/gen_bytearray_ops.py > compiler/GHC/Builtin/bytearray-ops.txt.pp
------------------------------------
-- aligned index operations
------------------------------------
primop IndexByteArrayOp_Char "indexCharArray#" GenPrimOp
ByteArray# -> Int# -> Char#
{Read a 8-bit character; offset in bytes.}
with can_fail = True
primop IndexByteArrayOp_WideChar "indexWideCharArray#" GenPrimOp
ByteArray# -> Int# -> Char#
{Read a 32-bit character; offset in 4-byte words.}
with can_fail = True
primop IndexByteArrayOp_Int "indexIntArray#" GenPrimOp
ByteArray# -> Int# -> Int#
{Read a word-sized integer; offset in machine words.}
with can_fail = True
primop IndexByteArrayOp_Word "indexWordArray#" GenPrimOp
ByteArray# -> Int# -> Word#
{Read a word-sized unsigned integer; offset in machine words.}
with can_fail = True
primop IndexByteArrayOp_Addr "indexAddrArray#" GenPrimOp
ByteArray# -> Int# -> Addr#
{Read a machine address; offset in machine words.}
with can_fail = True
primop IndexByteArrayOp_Float "indexFloatArray#" GenPrimOp
ByteArray# -> Int# -> Float#
{Read a single-precision floating-point value; offset in 4-byte words.}
with can_fail = True
primop IndexByteArrayOp_Double "indexDoubleArray#" GenPrimOp
ByteArray# -> Int# -> Double#
{Read a double-precision floating-point value; offset in 8-byte words.}
with can_fail = True
primop IndexByteArrayOp_StablePtr "indexStablePtrArray#" GenPrimOp
ByteArray# -> Int# -> StablePtr# a
{Read a 'StablePtr#' value; offset in machine words.}
with can_fail = True
primop IndexByteArrayOp_Int8 "indexInt8Array#" GenPrimOp
ByteArray# -> Int# -> Int8#
{Read a 8-bit signed integer; offset in bytes.}
with can_fail = True
primop IndexByteArrayOp_Int16 "indexInt16Array#" GenPrimOp
ByteArray# -> Int# -> Int16#
{Read a 16-bit signed integer; offset in 2-byte words.}
with can_fail = True
primop IndexByteArrayOp_Int32 "indexInt32Array#" GenPrimOp
ByteArray# -> Int# -> Int32#
{Read a 32-bit signed integer; offset in 4-byte words.}
with can_fail = True
primop IndexByteArrayOp_Int64 "indexInt64Array#" GenPrimOp
ByteArray# -> Int# -> Int64#
{Read a 64-bit signed integer; offset in 8-byte words.}
with can_fail = True
primop IndexByteArrayOp_Word8 "indexWord8Array#" GenPrimOp
ByteArray# -> Int# -> Word8#
{Read a 8-bit unsigned integer; offset in bytes.}
with can_fail = True
primop IndexByteArrayOp_Word16 "indexWord16Array#" GenPrimOp
ByteArray# -> Int# -> Word16#
{Read a 16-bit unsigned integer; offset in 2-byte words.}
with can_fail = True
primop IndexByteArrayOp_Word32 "indexWord32Array#" GenPrimOp
ByteArray# -> Int# -> Word32#
{Read a 32-bit unsigned integer; offset in 4-byte words.}
with can_fail = True
primop IndexByteArrayOp_Word64 "indexWord64Array#" GenPrimOp
ByteArray# -> Int# -> Word64#
{Read a 64-bit unsigned integer; offset in 8-byte words.}
with can_fail = True
------------------------------------
-- unaligned index operations
------------------------------------
primop IndexByteArrayOp_Word8AsChar "indexWord8ArrayAsChar#" GenPrimOp
ByteArray# -> Int# -> Char#
{Read a 8-bit character; offset in bytes.}
with can_fail = True
primop IndexByteArrayOp_Word8AsWideChar "indexWord8ArrayAsWideChar#" GenPrimOp
ByteArray# -> Int# -> Char#
{Read a 32-bit character; offset in bytes.}
with can_fail = True
primop IndexByteArrayOp_Word8AsInt "indexWord8ArrayAsInt#" GenPrimOp
ByteArray# -> Int# -> Int#
{Read a word-sized integer; offset in bytes.}
with can_fail = True
primop IndexByteArrayOp_Word8AsWord "indexWord8ArrayAsWord#" GenPrimOp
ByteArray# -> Int# -> Word#
{Read a word-sized unsigned integer; offset in bytes.}
with can_fail = True
primop IndexByteArrayOp_Word8AsAddr "indexWord8ArrayAsAddr#" GenPrimOp
ByteArray# -> Int# -> Addr#
{Read a machine address; offset in bytes.}
with can_fail = True
primop IndexByteArrayOp_Word8AsFloat "indexWord8ArrayAsFloat#" GenPrimOp
ByteArray# -> Int# -> Float#
{Read a single-precision floating-point value; offset in bytes.}
with can_fail = True
primop IndexByteArrayOp_Word8AsDouble "indexWord8ArrayAsDouble#" GenPrimOp
ByteArray# -> Int# -> Double#
{Read a double-precision floating-point value; offset in bytes.}
with can_fail = True
primop IndexByteArrayOp_Word8AsStablePtr "indexWord8ArrayAsStablePtr#" GenPrimOp
ByteArray# -> Int# -> StablePtr# a
{Read a 'StablePtr#' value; offset in bytes.}
with can_fail = True
primop IndexByteArrayOp_Word8AsInt16 "indexWord8ArrayAsInt16#" GenPrimOp
ByteArray# -> Int# -> Int16#
{Read a 16-bit signed integer; offset in bytes.}
with can_fail = True
primop IndexByteArrayOp_Word8AsInt32 "indexWord8ArrayAsInt32#" GenPrimOp
ByteArray# -> Int# -> Int32#
{Read a 32-bit signed integer; offset in bytes.}
with can_fail = True
primop IndexByteArrayOp_Word8AsInt64 "indexWord8ArrayAsInt64#" GenPrimOp
ByteArray# -> Int# -> Int64#
{Read a 64-bit signed integer; offset in bytes.}
with can_fail = True
primop IndexByteArrayOp_Word8AsWord16 "indexWord8ArrayAsWord16#" GenPrimOp
ByteArray# -> Int# -> Word16#
{Read a 16-bit unsigned integer; offset in bytes.}
with can_fail = True
primop IndexByteArrayOp_Word8AsWord32 "indexWord8ArrayAsWord32#" GenPrimOp
ByteArray# -> Int# -> Word32#
{Read a 32-bit unsigned integer; offset in bytes.}
with can_fail = True
primop IndexByteArrayOp_Word8AsWord64 "indexWord8ArrayAsWord64#" GenPrimOp
ByteArray# -> Int# -> Word64#
{Read a 64-bit unsigned integer; offset in bytes.}
with can_fail = True
------------------------------------
-- aligned read operations
------------------------------------
primop ReadByteArrayOp_Char "readCharArray#" GenPrimOp
MutableByteArray# s -> Int# -> State# s -> (# State# s, Char# #)
{Read a 8-bit character; offset in bytes.}
with has_side_effects = True
can_fail = True
primop ReadByteArrayOp_WideChar "readWideCharArray#" GenPrimOp
MutableByteArray# s -> Int# -> State# s -> (# State# s, Char# #)
{Read a 32-bit character; offset in 4-byte words.}
with has_side_effects = True
can_fail = True
primop ReadByteArrayOp_Int "readIntArray#" GenPrimOp
MutableByteArray# s -> Int# -> State# s -> (# State# s, Int# #)
{Read a word-sized integer; offset in machine words.}
with has_side_effects = True
can_fail = True
primop ReadByteArrayOp_Word "readWordArray#" GenPrimOp
MutableByteArray# s -> Int# -> State# s -> (# State# s, Word# #)
{Read a word-sized unsigned integer; offset in machine words.}
with has_side_effects = True
can_fail = True
primop ReadByteArrayOp_Addr "readAddrArray#" GenPrimOp
MutableByteArray# s -> Int# -> State# s -> (# State# s, Addr# #)
{Read a machine address; offset in machine words.}
with has_side_effects = True
can_fail = True
primop ReadByteArrayOp_Float "readFloatArray#" GenPrimOp
MutableByteArray# s -> Int# -> State# s -> (# State# s, Float# #)
{Read a single-precision floating-point value; offset in 4-byte words.}
with has_side_effects = True
can_fail = True
primop ReadByteArrayOp_Double "readDoubleArray#" GenPrimOp
MutableByteArray# s -> Int# -> State# s -> (# State# s, Double# #)
{Read a double-precision floating-point value; offset in 8-byte words.}
with has_side_effects = True
can_fail = True
primop ReadByteArrayOp_StablePtr "readStablePtrArray#" GenPrimOp
MutableByteArray# s -> Int# -> State# s -> (# State# s, StablePtr# a #)
{Read a 'StablePtr#' value; offset in machine words.}
with has_side_effects = True
can_fail = True
primop ReadByteArrayOp_Int8 "readInt8Array#" GenPrimOp
MutableByteArray# s -> Int# -> State# s -> (# State# s, Int8# #)
{Read a 8-bit signed integer; offset in bytes.}
with has_side_effects = True
can_fail = True
primop ReadByteArrayOp_Int16 "readInt16Array#" GenPrimOp
MutableByteArray# s -> Int# -> State# s -> (# State# s, Int16# #)
{Read a 16-bit signed integer; offset in 2-byte words.}
with has_side_effects = True
can_fail = True
primop ReadByteArrayOp_Int32 "readInt32Array#" GenPrimOp
MutableByteArray# s -> Int# -> State# s -> (# State# s, Int32# #)
{Read a 32-bit signed integer; offset in 4-byte words.}
with has_side_effects = True
can_fail = True
primop ReadByteArrayOp_Int64 "readInt64Array#" GenPrimOp
MutableByteArray# s -> Int# -> State# s -> (# State# s, Int64# #)
{Read a 64-bit signed integer; offset in 8-byte words.}
with has_side_effects = True
can_fail = True
primop ReadByteArrayOp_Word8 "readWord8Array#" GenPrimOp
MutableByteArray# s -> Int# -> State# s -> (# State# s, Word8# #)
{Read a 8-bit unsigned integer; offset in bytes.}
with has_side_effects = True
can_fail = True
primop ReadByteArrayOp_Word16 "readWord16Array#" GenPrimOp
MutableByteArray# s -> Int# -> State# s -> (# State# s, Word16# #)
{Read a 16-bit unsigned integer; offset in 2-byte words.}
with has_side_effects = True
can_fail = True
primop ReadByteArrayOp_Word32 "readWord32Array#" GenPrimOp
MutableByteArray# s -> Int# -> State# s -> (# State# s, Word32# #)
{Read a 32-bit unsigned integer; offset in 4-byte words.}
with has_side_effects = True
can_fail = True
primop ReadByteArrayOp_Word64 "readWord64Array#" GenPrimOp
MutableByteArray# s -> Int# -> State# s -> (# State# s, Word64# #)
{Read a 64-bit unsigned integer; offset in 8-byte words.}
with has_side_effects = True
can_fail = True
------------------------------------
-- unaligned read operations
------------------------------------
primop ReadByteArrayOp_Word8AsChar "readWord8ArrayAsChar#" GenPrimOp
MutableByteArray# s -> Int# -> State# s -> (# State# s, Char# #)
{Read a 8-bit character; offset in bytes.}
with has_side_effects = True
can_fail = True
primop ReadByteArrayOp_Word8AsWideChar "readWord8ArrayAsWideChar#" GenPrimOp
MutableByteArray# s -> Int# -> State# s -> (# State# s, Char# #)
{Read a 32-bit character; offset in bytes.}
with has_side_effects = True
can_fail = True
primop ReadByteArrayOp_Word8AsInt "readWord8ArrayAsInt#" GenPrimOp
MutableByteArray# s -> Int# -> State# s -> (# State# s, Int# #)
{Read a word-sized integer; offset in bytes.}
with has_side_effects = True
can_fail = True
primop ReadByteArrayOp_Word8AsWord "readWord8ArrayAsWord#" GenPrimOp
MutableByteArray# s -> Int# -> State# s -> (# State# s, Word# #)
{Read a word-sized unsigned integer; offset in bytes.}
with has_side_effects = True
can_fail = True
primop ReadByteArrayOp_Word8AsAddr "readWord8ArrayAsAddr#" GenPrimOp
MutableByteArray# s -> Int# -> State# s -> (# State# s, Addr# #)
{Read a machine address; offset in bytes.}
with has_side_effects = True
can_fail = True
primop ReadByteArrayOp_Word8AsFloat "readWord8ArrayAsFloat#" GenPrimOp
MutableByteArray# s -> Int# -> State# s -> (# State# s, Float# #)
{Read a single-precision floating-point value; offset in bytes.}
with has_side_effects = True
can_fail = True
primop ReadByteArrayOp_Word8AsDouble "readWord8ArrayAsDouble#" GenPrimOp
MutableByteArray# s -> Int# -> State# s -> (# State# s, Double# #)
{Read a double-precision floating-point value; offset in bytes.}
with has_side_effects = True
can_fail = True
primop ReadByteArrayOp_Word8AsStablePtr "readWord8ArrayAsStablePtr#" GenPrimOp
MutableByteArray# s -> Int# -> State# s -> (# State# s, StablePtr# a #)
{Read a 'StablePtr#' value; offset in bytes.}
with has_side_effects = True
can_fail = True
primop ReadByteArrayOp_Word8AsInt16 "readWord8ArrayAsInt16#" GenPrimOp
MutableByteArray# s -> Int# -> State# s -> (# State# s, Int16# #)
{Read a 16-bit signed integer; offset in bytes.}
with has_side_effects = True
can_fail = True
primop ReadByteArrayOp_Word8AsInt32 "readWord8ArrayAsInt32#" GenPrimOp
MutableByteArray# s -> Int# -> State# s -> (# State# s, Int32# #)
{Read a 32-bit signed integer; offset in bytes.}
with has_side_effects = True
can_fail = True
primop ReadByteArrayOp_Word8AsInt64 "readWord8ArrayAsInt64#" GenPrimOp
MutableByteArray# s -> Int# -> State# s -> (# State# s, Int64# #)
{Read a 64-bit signed integer; offset in bytes.}
with has_side_effects = True
can_fail = True
primop ReadByteArrayOp_Word8AsWord16 "readWord8ArrayAsWord16#" GenPrimOp
MutableByteArray# s -> Int# -> State# s -> (# State# s, Word16# #)
{Read a 16-bit unsigned integer; offset in bytes.}
with has_side_effects = True
can_fail = True
primop ReadByteArrayOp_Word8AsWord32 "readWord8ArrayAsWord32#" GenPrimOp
MutableByteArray# s -> Int# -> State# s -> (# State# s, Word32# #)
{Read a 32-bit unsigned integer; offset in bytes.}
with has_side_effects = True
can_fail = True
primop ReadByteArrayOp_Word8AsWord64 "readWord8ArrayAsWord64#" GenPrimOp
MutableByteArray# s -> Int# -> State# s -> (# State# s, Word64# #)
{Read a 64-bit unsigned integer; offset in bytes.}
with has_side_effects = True
can_fail = True
------------------------------------
-- aligned write operations
------------------------------------
primop WriteByteArrayOp_Char "writeCharArray#" GenPrimOp
MutableByteArray# s -> Int# -> Char# -> State# s -> State# s
{Write a 8-bit character; offset in bytes.}
with has_side_effects = True
can_fail = True
primop WriteByteArrayOp_WideChar "writeWideCharArray#" GenPrimOp
MutableByteArray# s -> Int# -> Char# -> State# s -> State# s
{Write a 32-bit character; offset in 4-byte words.}
with has_side_effects = True
can_fail = True
primop WriteByteArrayOp_Int "writeIntArray#" GenPrimOp
MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
{Write a word-sized integer; offset in machine words.}
with has_side_effects = True
can_fail = True
primop WriteByteArrayOp_Word "writeWordArray#" GenPrimOp
MutableByteArray# s -> Int# -> Word# -> State# s -> State# s
{Write a word-sized unsigned integer; offset in machine words.}
with has_side_effects = True
can_fail = True
primop WriteByteArrayOp_Addr "writeAddrArray#" GenPrimOp
MutableByteArray# s -> Int# -> Addr# -> State# s -> State# s
{Write a machine address; offset in machine words.}
with has_side_effects = True
can_fail = True
primop WriteByteArrayOp_Float "writeFloatArray#" GenPrimOp
MutableByteArray# s -> Int# -> Float# -> State# s -> State# s
{Write a single-precision floating-point value; offset in 4-byte words.}
with has_side_effects = True
can_fail = True
primop WriteByteArrayOp_Double "writeDoubleArray#" GenPrimOp
MutableByteArray# s -> Int# -> Double# -> State# s -> State# s
{Write a double-precision floating-point value; offset in 8-byte words.}
with has_side_effects = True
can_fail = True
primop WriteByteArrayOp_StablePtr "writeStablePtrArray#" GenPrimOp
MutableByteArray# s -> Int# -> StablePtr# a -> State# s -> State# s
{Write a 'StablePtr#' value; offset in machine words.}
with has_side_effects = True
can_fail = True
primop WriteByteArrayOp_Int8 "writeInt8Array#" GenPrimOp
MutableByteArray# s -> Int# -> Int8# -> State# s -> State# s
{Write a 8-bit signed integer; offset in bytes.}
with has_side_effects = True
can_fail = True
primop WriteByteArrayOp_Int16 "writeInt16Array#" GenPrimOp
MutableByteArray# s -> Int# -> Int16# -> State# s -> State# s
{Write a 16-bit signed integer; offset in 2-byte words.}
with has_side_effects = True
can_fail = True
primop WriteByteArrayOp_Int32 "writeInt32Array#" GenPrimOp
MutableByteArray# s -> Int# -> Int32# -> State# s -> State# s
{Write a 32-bit signed integer; offset in 4-byte words.}
with has_side_effects = True
can_fail = True
primop WriteByteArrayOp_Int64 "writeInt64Array#" GenPrimOp
MutableByteArray# s -> Int# -> Int64# -> State# s -> State# s
{Write a 64-bit signed integer; offset in 8-byte words.}
with has_side_effects = True
can_fail = True
primop WriteByteArrayOp_Word8 "writeWord8Array#" GenPrimOp
MutableByteArray# s -> Int# -> Word8# -> State# s -> State# s
{Write a 8-bit unsigned integer; offset in bytes.}
with has_side_effects = True
can_fail = True
primop WriteByteArrayOp_Word16 "writeWord16Array#" GenPrimOp
MutableByteArray# s -> Int# -> Word16# -> State# s -> State# s
{Write a 16-bit unsigned integer; offset in 2-byte words.}
with has_side_effects = True
can_fail = True
primop WriteByteArrayOp_Word32 "writeWord32Array#" GenPrimOp
MutableByteArray# s -> Int# -> Word32# -> State# s -> State# s
{Write a 32-bit unsigned integer; offset in 4-byte words.}
with has_side_effects = True
can_fail = True
primop WriteByteArrayOp_Word64 "writeWord64Array#" GenPrimOp
MutableByteArray# s -> Int# -> Word64# -> State# s -> State# s
{Write a 64-bit unsigned integer; offset in 8-byte words.}
with has_side_effects = True
can_fail = True
------------------------------------
-- unaligned write operations
------------------------------------
primop WriteByteArrayOp_Word8AsChar "writeWord8ArrayAsChar#" GenPrimOp
MutableByteArray# s -> Int# -> Char# -> State# s -> State# s
{Write a 8-bit character; offset in bytes.}
with has_side_effects = True
can_fail = True
primop WriteByteArrayOp_Word8AsWideChar "writeWord8ArrayAsWideChar#" GenPrimOp
MutableByteArray# s -> Int# -> Char# -> State# s -> State# s
{Write a 32-bit character; offset in bytes.}
with has_side_effects = True
can_fail = True
primop WriteByteArrayOp_Word8AsInt "writeWord8ArrayAsInt#" GenPrimOp
MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
{Write a word-sized integer; offset in bytes.}
with has_side_effects = True
can_fail = True
primop WriteByteArrayOp_Word8AsWord "writeWord8ArrayAsWord#" GenPrimOp
MutableByteArray# s -> Int# -> Word# -> State# s -> State# s
{Write a word-sized unsigned integer; offset in bytes.}
with has_side_effects = True
can_fail = True
primop WriteByteArrayOp_Word8AsAddr "writeWord8ArrayAsAddr#" GenPrimOp
MutableByteArray# s -> Int# -> Addr# -> State# s -> State# s
{Write a machine address; offset in bytes.}
with has_side_effects = True
can_fail = True
primop WriteByteArrayOp_Word8AsFloat "writeWord8ArrayAsFloat#" GenPrimOp
MutableByteArray# s -> Int# -> Float# -> State# s -> State# s
{Write a single-precision floating-point value; offset in bytes.}
with has_side_effects = True
can_fail = True
primop WriteByteArrayOp_Word8AsDouble "writeWord8ArrayAsDouble#" GenPrimOp
MutableByteArray# s -> Int# -> Double# -> State# s -> State# s
{Write a double-precision floating-point value; offset in bytes.}
with has_side_effects = True
can_fail = True
primop WriteByteArrayOp_Word8AsStablePtr "writeWord8ArrayAsStablePtr#" GenPrimOp
MutableByteArray# s -> Int# -> StablePtr# a -> State# s -> State# s
{Write a 'StablePtr#' value; offset in bytes.}
with has_side_effects = True
can_fail = True
primop WriteByteArrayOp_Word8AsInt16 "writeWord8ArrayAsInt16#" GenPrimOp
MutableByteArray# s -> Int# -> Int16# -> State# s -> State# s
{Write a 16-bit signed integer; offset in bytes.}
with has_side_effects = True
can_fail = True
primop WriteByteArrayOp_Word8AsInt32 "writeWord8ArrayAsInt32#" GenPrimOp
MutableByteArray# s -> Int# -> Int32# -> State# s -> State# s
{Write a 32-bit signed integer; offset in bytes.}
with has_side_effects = True
can_fail = True
primop WriteByteArrayOp_Word8AsInt64 "writeWord8ArrayAsInt64#" GenPrimOp
MutableByteArray# s -> Int# -> Int64# -> State# s -> State# s
{Write a 64-bit signed integer; offset in bytes.}
with has_side_effects = True
can_fail = True
primop WriteByteArrayOp_Word8AsWord16 "writeWord8ArrayAsWord16#" GenPrimOp
MutableByteArray# s -> Int# -> Word16# -> State# s -> State# s
{Write a 16-bit unsigned integer; offset in bytes.}
with has_side_effects = True
can_fail = True
primop WriteByteArrayOp_Word8AsWord32 "writeWord8ArrayAsWord32#" GenPrimOp
MutableByteArray# s -> Int# -> Word32# -> State# s -> State# s
{Write a 32-bit unsigned integer; offset in bytes.}
with has_side_effects = True
can_fail = True
primop WriteByteArrayOp_Word8AsWord64 "writeWord8ArrayAsWord64#" GenPrimOp
MutableByteArray# s -> Int# -> Word64# -> State# s -> State# s
{Write a 64-bit unsigned integer; offset in bytes.}
with has_side_effects = True
can_fail = True
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# This script generates the primop descriptions for many similar ByteArray#
# and Addr# access operations. Its output is #include-d into primops.txt.pp.
from typing import Optional, NamedTuple
import textwrap
import argparse
arg_parser = argparse.ArgumentParser()
arg_parser.add_argument('addr_or_bytearray',
choices = ["addr-access-ops", "bytearray-access-ops"],
)
arg_parser.add_argument('output_file',
type=argparse.FileType('w'),
metavar='FILE',
)
args = arg_parser.parse_args()
write = args.output_file.write
write('''
-- Do not edit.
-- This file is generated by compiler/GHC/Builtin/gen_bytearray_addr_access_ops.py.
-- (The build system should take care of this for you.)
''')
class ElementType(NamedTuple):
name: str
......@@ -28,26 +52,13 @@ element_types = [
ElementType("StablePtr", "StablePtr# a", "'StablePtr#' value", MACH_WORD),
]
# TODO: Eventually when the sized integer primops use proper unboxed types we
# should rather do:
#
#for n in [8,16,32,64]:
# element_types += [ ElementType(f"Int{n}", f"Int{n}#", f"{n}-bit signed integer", n // 8) ]
#
#for n in [8,16,32,64]:
# element_types += [ ElementType(f"Word{n}", f"Word{n}#", f"{n}-bit unsigned integer", n // 8) ]
element_types += [
ElementType("Int8", "Int8#", "8-bit signed integer", 1),
ElementType("Int16", "Int16#", "16-bit signed integer", 2),
ElementType("Int32", "Int32#", "32-bit signed integer", 4),
ElementType("Int64", "Int64#", "64-bit signed integer", 8),
ElementType("Word8", "Word8#", "8-bit unsigned integer", 1),
ElementType("Word16", "Word16#", "16-bit unsigned integer", 2),
ElementType("Word32", "Word32#", "32-bit unsigned integer", 4),
ElementType("Word64", "Word64#", "64-bit unsigned integer", 8),
]
for n in [8,16,32,64]:
element_types += [
ElementType(f"Int{n}", f"Int{n}#",
f"{n}-bit signed integer", n // 8),
ElementType(f"Word{n}", f"Word{n}#",
f"{n}-bit unsigned integer", n // 8)
]
def pretty_offset(n: Optional[int]) -> str:
if n == MACH_WORD:
......@@ -57,87 +68,134 @@ def pretty_offset(n: Optional[int]) -> str:
else:
return f'{n}-byte words'
def get_align_warn(n: ElementType) -> str:
if n.width == 1:
return ''
return '''
On some platforms, the access may fail
for an insufficiently aligned @Addr#@.
'''
def print_block(template: str, **kwargs) -> None:
print(textwrap.dedent(template.format(**kwargs)).lstrip())
write(textwrap.dedent(template.format(**kwargs)).lstrip())
write('\n')
def header(s: str):
print('')
write('\n')
print_block('''
------------------------------------
-- {s}
------------------------------------
''', s=s)
if args.addr_or_bytearray == "bytearray-access-ops":
header("ByteArray# operations")
header("ByteArray# operations")
print('''
-- Do not edit. This file is generated by utils/genprimopcode/gen_bytearray_ops.py.
-- To regenerate run,
--
-- python3 utils/genprimops/gen_bytearray_ops.py > compiler/GHC/Builtin/bytearray-ops.txt.pp
''')
header('aligned index operations')
for t in element_types:
offset = pretty_offset(t.width)
print_block('''
header('aligned index operations')
for t in element_types:
offset = pretty_offset(t.width)
print_block('''
primop IndexByteArrayOp_{name} "index{name}Array#" GenPrimOp
ByteArray# -> Int# -> {rep_ty}
{{Read a {desc}; offset in {offset}.}}
with can_fail = True
''', offset = offset, **t._asdict())
''', offset = offset, **t._asdict())
header('unaligned index operations')
for t in element_types:
if t.name in ['Int8', 'Word8']: continue
print_block('''
header('unaligned index operations')
for t in element_types:
if t.name in ['Int8', 'Word8']: continue
print_block('''
primop IndexByteArrayOp_Word8As{name} "indexWord8ArrayAs{name}#" GenPrimOp
ByteArray# -> Int# -> {rep_ty}
{{Read a {desc}; offset in bytes.}}
with can_fail = True
''', **t._asdict())
''', **t._asdict())
header('aligned read operations')
for t in element_types:
offset = pretty_offset(t.width)
print_block('''
header('aligned read operations')
for t in element_types:
offset = pretty_offset(t.width)
print_block('''
primop ReadByteArrayOp_{name} "read{name}Array#" GenPrimOp
MutableByteArray# s -> Int# -> State# s -> (# State# s, {rep_ty} #)
{{Read a {desc}; offset in {offset}.}}
with has_side_effects = True
can_fail = True
''', offset = offset, **t._asdict())
''', offset = offset, **t._asdict())
header('unaligned read operations')
for t in element_types:
if t.name in ['Int8', 'Word8']: continue
print_block('''
header('unaligned read operations')
for t in element_types:
if t.name in ['Int8', 'Word8']: continue
print_block('''
primop ReadByteArrayOp_Word8As{name} "readWord8ArrayAs{name}#" GenPrimOp
MutableByteArray# s -> Int# -> State# s -> (# State# s, {rep_ty} #)
{{Read a {desc}; offset in bytes.}}
with has_side_effects = True
can_fail = True
''', **t._asdict())
''', **t._asdict())
header('aligned write operations')
for t in element_types:
offset = pretty_offset(t.width)
print_block('''
header('aligned write operations')
for t in element_types:
offset = pretty_offset(t.width)
print_block('''
primop WriteByteArrayOp_{name} "write{name}Array#" GenPrimOp
MutableByteArray# s -> Int# -> {rep_ty} -> State# s -> State# s
{{Write a {desc}; offset in {offset}.}}
with has_side_effects = True
can_fail = True
''', offset = offset, **t._asdict())
''', offset = offset, **t._asdict())
header('unaligned write operations')
for t in element_types:
if t.name in ['Int8', 'Word8']: continue
print_block('''
header('unaligned write operations')
for t in element_types:
if t.name in ['Int8', 'Word8']: continue
print_block('''
primop WriteByteArrayOp_Word8As{name} "writeWord8ArrayAs{name}#" GenPrimOp
MutableByteArray# s -> Int# -> {rep_ty} -> State# s -> State# s
{{Write a {desc}; offset in bytes.}}
with has_side_effects = True
can_fail = True
''', **t._asdict())
''', **t._asdict())
else: # addr_or_bytearray == "addr-access-ops":
header("Addr# access operations")
header('aligned index operations')
for t in element_types:
offset = pretty_offset(t.width)
align_warn = get_align_warn(t)
print_block('''
primop IndexOffAddrOp_{name} "index{name}OffAddr#" GenPrimOp
Addr# -> Int# -> {rep_ty}
{{ Read a {desc}; offset in {offset}.
{align_warn}
}}
with can_fail = True
''', offset = offset, align_warn = align_warn, **t._asdict())
header('aligned read operations')
for t in element_types:
offset = pretty_offset(t.width)
align_warn = get_align_warn(t)
print_block('''
primop ReadOffAddrOp_{name} "read{name}OffAddr#" GenPrimOp
Addr# -> Int# -> State# s -> (# State# s, {rep_ty} #)
{{ Read a {desc}; offset in {offset}.
{align_warn}
}}
with has_side_effects = True
can_fail = True
''', offset = offset, align_warn = align_warn, **t._asdict())
header('aligned write operations')
for t in element_types:
offset = pretty_offset(t.width)
align_warn = get_align_warn(t)
print_block('''
primop WriteOffAddrOp_{name} "write{name}OffAddr#" GenPrimOp
Addr# -> Int# -> {rep_ty} -> State# s -> State# s
{{ Write a {desc}; offset in {offset}.
{align_warn}
}}
with has_side_effects = True
can_fail = True
''', offset = offset, align_warn = align_warn, **t._asdict())
......@@ -1941,7 +1941,7 @@ primop GetSizeofMutableByteArrayOp "getSizeofMutableByteArray#" GenPrimOp
@since 0.5.0.0}
#include "bytearray-ops.txt.pp"
#include "bytearray-access-ops.txt.pp"
primop CompareByteArraysOp "compareByteArrays#" GenPrimOp
ByteArray# -> Int# -> ByteArray# -> Int# -> Int# -> Int#
......@@ -2242,233 +2242,7 @@ primop AddrNeOp "neAddr#" Compare Addr# -> Addr# -> Int#
primop AddrLtOp "ltAddr#" Compare Addr# -> Addr# -> Int#
primop AddrLeOp "leAddr#" Compare Addr# -> Addr# -> Int#
primop IndexOffAddrOp_Char "indexCharOffAddr#" GenPrimOp
Addr# -> Int# -> Char#
{Reads 8-bit character; offset in bytes.}
with can_fail = True
primop IndexOffAddrOp_WideChar "indexWideCharOffAddr#" GenPrimOp
Addr# -> Int# -> Char#
{Reads 31-bit character; offset in 4-byte words.}
with can_fail = True
primop IndexOffAddrOp_Int "indexIntOffAddr#" GenPrimOp
Addr# -> Int# -> Int#
with can_fail = True
primop IndexOffAddrOp_Word "indexWordOffAddr#" GenPrimOp
Addr# -> Int# -> Word#
with can_fail = True
primop IndexOffAddrOp_Addr "indexAddrOffAddr#" GenPrimOp
Addr# -> Int# -> Addr#
with can_fail = True
primop IndexOffAddrOp_Float "indexFloatOffAddr#" GenPrimOp
Addr# -> Int# -> Float#
with can_fail = True
primop IndexOffAddrOp_Double "indexDoubleOffAddr#" GenPrimOp
Addr# -> Int# -> Double#
with can_fail = True
primop IndexOffAddrOp_StablePtr "indexStablePtrOffAddr#" GenPrimOp
Addr# -> Int# -> StablePtr# a
with can_fail = True
primop IndexOffAddrOp_Int8 "indexInt8OffAddr#" GenPrimOp
Addr# -> Int# -> Int8#
with can_fail = True
primop IndexOffAddrOp_Int16 "indexInt16OffAddr#" GenPrimOp
Addr# -> Int# -> Int16#
with can_fail = True
primop IndexOffAddrOp_Int32 "indexInt32OffAddr#" GenPrimOp
Addr# -> Int# -> Int32#
with can_fail = True
primop IndexOffAddrOp_Int64 "indexInt64OffAddr#" GenPrimOp
Addr# -> Int# -> Int64#
with can_fail = True
primop IndexOffAddrOp_Word8 "indexWord8OffAddr#" GenPrimOp
Addr# -> Int# -> Word8#
with can_fail = True
primop IndexOffAddrOp_Word16 "indexWord16OffAddr#" GenPrimOp
Addr# -> Int# -> Word16#
with can_fail = True
primop IndexOffAddrOp_Word32 "indexWord32OffAddr#" GenPrimOp
Addr# -> Int# -> Word32#
with can_fail = True
primop IndexOffAddrOp_Word64 "indexWord64OffAddr#" GenPrimOp
Addr# -> Int# -> Word64#
with can_fail = True
primop ReadOffAddrOp_Char "readCharOffAddr#" GenPrimOp
Addr# -> Int# -> State# s -> (# State# s, Char# #)
{Reads 8-bit character; offset in bytes.}
with has_side_effects = True
can_fail = True
primop ReadOffAddrOp_WideChar "readWideCharOffAddr#" GenPrimOp
Addr# -> Int# -> State# s -> (# State# s, Char# #)
{Reads 31-bit character; offset in 4-byte words.}
with has_side_effects = True
can_fail = True
primop ReadOffAddrOp_Int "readIntOffAddr#" GenPrimOp
Addr# -> Int# -> State# s -> (# State# s, Int# #)
with has_side_effects = True
can_fail = True
primop ReadOffAddrOp_Word "readWordOffAddr#" GenPrimOp
Addr# -> Int# -> State# s -> (# State# s, Word# #)
with has_side_effects = True
can_fail = True
primop ReadOffAddrOp_Addr "readAddrOffAddr#" GenPrimOp
Addr# -> Int# -> State# s -> (# State# s, Addr# #)
with has_side_effects = True
can_fail = True
primop ReadOffAddrOp_Float "readFloatOffAddr#" GenPrimOp
Addr# -> Int# -> State# s -> (# State# s, Float# #)
with has_side_effects = True
can_fail = True
primop ReadOffAddrOp_Double "readDoubleOffAddr#" GenPrimOp
Addr# -> Int# -> State# s -> (# State# s, Double# #)
with has_side_effects = True
can_fail = True
primop ReadOffAddrOp_StablePtr "readStablePtrOffAddr#" GenPrimOp
Addr# -> Int# -> State# s -> (# State# s, StablePtr# a #)
with has_side_effects = True
can_fail = True
primop ReadOffAddrOp_Int8 "readInt8OffAddr#" GenPrimOp
Addr# -> Int# -> State# s -> (# State# s, Int8# #)
with has_side_effects = True
can_fail = True
primop ReadOffAddrOp_Int16 "readInt16OffAddr#" GenPrimOp
Addr# -> Int# -> State# s -> (# State# s, Int16# #)
with has_side_effects = True
can_fail = True
primop ReadOffAddrOp_Int32 "readInt32OffAddr#" GenPrimOp
Addr# -> Int# -> State# s -> (# State# s, Int32# #)
with has_side_effects = True
can_fail = True
primop ReadOffAddrOp_Int64 "readInt64OffAddr#" GenPrimOp
Addr# -> Int# -> State# s -> (# State# s, Int64# #)
with has_side_effects = True
can_fail = True
primop ReadOffAddrOp_Word8 "readWord8OffAddr#" GenPrimOp
Addr# -> Int# -> State# s -> (# State# s, Word8# #)
with has_side_effects = True
can_fail = True
primop ReadOffAddrOp_Word16 "readWord16OffAddr#" GenPrimOp
Addr# -> Int# -> State# s -> (# State# s, Word16# #)
with has_side_effects = True
can_fail = True
primop ReadOffAddrOp_Word32 "readWord32OffAddr#" GenPrimOp
Addr# -> Int# -> State# s -> (# State# s, Word32# #)
with has_side_effects = True
can_fail = True
primop ReadOffAddrOp_Word64 "readWord64OffAddr#" GenPrimOp
Addr# -> Int# -> State# s -> (# State# s, Word64# #)
with has_side_effects = True
can_fail = True
primop WriteOffAddrOp_Char "writeCharOffAddr#" GenPrimOp
Addr# -> Int# -> Char# -> State# s -> State# s
with has_side_effects = True
can_fail = True
primop WriteOffAddrOp_WideChar "writeWideCharOffAddr#" GenPrimOp
Addr# -> Int# -> Char# -> State# s -> State# s
with has_side_effects = True
can_fail = True
primop WriteOffAddrOp_Int "writeIntOffAddr#" GenPrimOp
Addr# -> Int# -> Int# -> State# s -> State# s
with has_side_effects = True
can_fail = True
primop WriteOffAddrOp_Word "writeWordOffAddr#" GenPrimOp
Addr# -> Int# -> Word# -> State# s -> State# s
with has_side_effects = True
can_fail = True
primop WriteOffAddrOp_Addr "writeAddrOffAddr#" GenPrimOp
Addr# -> Int# -> Addr# -> State# s -> State# s
with has_side_effects = True
can_fail = True
primop WriteOffAddrOp_Float "writeFloatOffAddr#" GenPrimOp
Addr# -> Int# -> Float# -> State# s -> State# s
with has_side_effects = True
can_fail = True
primop WriteOffAddrOp_Double "writeDoubleOffAddr#" GenPrimOp
Addr# -> Int# -> Double# -> State# s -> State# s
with has_side_effects = True
can_fail = True
primop WriteOffAddrOp_StablePtr "writeStablePtrOffAddr#" GenPrimOp
Addr# -> Int# -> StablePtr# a -> State# s -> State# s
with has_side_effects = True
can_fail = True
primop WriteOffAddrOp_Int8 "writeInt8OffAddr#" GenPrimOp
Addr# -> Int# -> Int8# -> State# s -> State# s
with has_side_effects = True
can_fail = True
primop WriteOffAddrOp_Int16 "writeInt16OffAddr#" GenPrimOp
Addr# -> Int# -> Int16# -> State# s -> State# s
with has_side_effects = True
can_fail = True
primop WriteOffAddrOp_Int32 "writeInt32OffAddr#" GenPrimOp
Addr# -> Int# -> Int32# -> State# s -> State# s
with has_side_effects = True
can_fail = True
primop WriteOffAddrOp_Int64 "writeInt64OffAddr#" GenPrimOp
Addr# -> Int# -> Int64# -> State# s -> State# s
with has_side_effects = True
can_fail = True
primop WriteOffAddrOp_Word8 "writeWord8OffAddr#" GenPrimOp
Addr# -> Int# -> Word8# -> State# s -> State# s
with has_side_effects = True
can_fail = True
primop WriteOffAddrOp_Word16 "writeWord16OffAddr#" GenPrimOp
Addr# -> Int# -> Word16# -> State# s -> State# s
with has_side_effects = True
can_fail = True
primop WriteOffAddrOp_Word32 "writeWord32OffAddr#" GenPrimOp
Addr# -> Int# -> Word32# -> State# s -> State# s
with has_side_effects = True
can_fail = True
primop WriteOffAddrOp_Word64 "writeWord64OffAddr#" GenPrimOp
Addr# -> Int# -> Word64# -> State# s -> State# s
with has_side_effects = True
can_fail = True
#include "addr-access-ops.txt.pp"
primop InterlockedExchange_Addr "atomicExchangeAddrAddr#" GenPrimOp
Addr# -> Addr# -> State# s -> (# State# s, Addr# #)
......
......@@ -119,7 +119,7 @@ import GHC.Cmm.CLabel
import GHC.Types.Unique.FM
import GHC.Types.Unique.Supply
import GHC.Driver.Session
import GHC.Driver.DynFlags
import GHC.Driver.Ppr
import GHC.Utils.Misc
import GHC.Utils.Logger
......
......@@ -27,7 +27,7 @@ import GHC.Cmm
import GHC.Cmm.Dataflow.Collections
import GHC.Utils.BufHandle
import GHC.Driver.Session
import GHC.Driver.DynFlags
import GHC.Platform ( platformArch, Arch(..) )
import GHC.Utils.Error
import GHC.Data.FastString
......
......@@ -44,7 +44,7 @@ import GHC.CmmToLlvm.Config
import GHC.Cmm.CLabel
import GHC.Platform.Regs ( activeStgRegs, globalRegMaybe )
import GHC.Driver.Session
import GHC.Driver.DynFlags
import GHC.Data.FastString
import GHC.Cmm hiding ( succ )
import GHC.Cmm.Utils (globalRegsOverlap)
......
......@@ -26,7 +26,7 @@ import GHC.Core
import GHC.Core.Opt.Monad
import GHC.Core.Utils (mkTick)
import GHC.Types.Id
import GHC.Driver.Session
import GHC.Driver.DynFlags
import GHC.Utils.Logger
import GHC.Utils.Outputable
......
......@@ -31,7 +31,7 @@ module GHC.Core.Lint (
import GHC.Prelude
import GHC.Driver.Session
import GHC.Driver.DynFlags
import GHC.Tc.Utils.TcType ( isFloatingPrimTy, isTyFamFree )
import GHC.Unit.Module.ModGuts
......@@ -302,6 +302,10 @@ path does not result in allocation in the hot path. This can be surprisingly
impactful. Changing `lint_app` reduced allocations for one test program I was
looking at by ~4%.
Note [MCInfo for Lint]
~~~~~~~~~~~~~~~~~~~~~~
When printing a Lint message, use the MCInfo severity so that the
message is printed on stderr rather than stdout (#13342).
************************************************************************
* *
......@@ -425,7 +429,7 @@ displayLintResults :: Logger
-> IO ()
displayLintResults logger display_warnings pp_what pp_pgm (warns, errs)
| not (isEmptyBag errs)
= do { logMsg logger Err.MCDump noSrcSpan
= do { logMsg logger Err.MCInfo noSrcSpan -- See Note [MCInfo for Lint]
$ withPprStyle defaultDumpStyle
(vcat [ lint_banner "errors" pp_what, Err.pprMessageBag errs
, text "*** Offending Program ***"
......@@ -436,9 +440,7 @@ displayLintResults logger display_warnings pp_what pp_pgm (warns, errs)
| not (isEmptyBag warns)
, log_enable_debug (logFlags logger)
, display_warnings
-- If the Core linter encounters an error, output to stderr instead of
-- stdout (#13342)
= logMsg logger Err.MCInfo noSrcSpan
= logMsg logger Err.MCInfo noSrcSpan -- See Note [MCInfo for Lint]
$ withPprStyle defaultDumpStyle
(lint_banner "warnings" pp_what $$ Err.pprMessageBag (mapBag ($$ blankLine) warns))
......
......@@ -2863,18 +2863,11 @@ pushCoValArg co
= Just (MRefl, MRefl)
| isFunTy tyL
, (co_mult, co1, co2) <- decomposeFunCo co
, (_, co1, co2) <- decomposeFunCo co
-- If co :: (tyL1 -> tyL2) ~ (tyR1 -> tyR2)
-- then co1 :: tyL1 ~ tyR1
-- co2 :: tyL2 ~ tyR2
, isReflexiveCo co_mult
-- We can't push the coercion in the case where co_mult isn't reflexivity:
-- it could be an unsafe axiom, and losing this information could yield
-- ill-typed terms. For instance (fun x ::(1) Int -> (fun _ -> () |> co) x)
-- with co :: (Int -> ()) ~ (Int %1 -> ()), would reduce to (fun x ::(1) Int
-- -> (fun _ ::(Many) Int -> ()) x) which is ill-typed.
, typeHasFixedRuntimeRep new_arg_ty
-- We can't push the coercion inside if it would give rise to
-- a representation-polymorphic argument.
......@@ -2907,10 +2900,7 @@ pushCoercionIntoLambda in_scope x e co
, Pair s1s2 t1t2 <- coercionKind co
, Just {} <- splitFunTy_maybe s1s2
, Just (_, w1, t1,_t2) <- splitFunTy_maybe t1t2
, (co_mult, co1, co2) <- decomposeFunCo co
, isReflexiveCo co_mult
-- We can't push the coercion in the case where co_mult isn't
-- reflexivity. See pushCoValArg for more details.
, (_, co1, co2) <- decomposeFunCo co
, typeHasFixedRuntimeRep t1
-- We can't push the coercion into the lambda if it would create
-- a representation-polymorphic binder.
......
......@@ -15,14 +15,11 @@ module GHC.Core.Opt.CallerCC
, parseCallerCcFilter
) where
import Data.Word (Word8)
import Data.Maybe
import Control.Applicative
import GHC.Utils.Monad.State.Strict
import Data.Either
import Control.Monad
import qualified Text.ParserCombinators.ReadP as P
import GHC.Prelude
import GHC.Utils.Outputable as Outputable
......@@ -38,11 +35,8 @@ import GHC.Unit.Types
import GHC.Data.FastString
import GHC.Core
import GHC.Core.Opt.Monad
import GHC.Utils.Panic
import qualified GHC.Utils.Binary as B
import Data.Char
import GHC.Core.Opt.CallerCC.Types
import Language.Haskell.Syntax.Module.Name
addCallerCostCentres :: ModGuts -> CoreM ModGuts
addCallerCostCentres guts = do
......@@ -139,90 +133,3 @@ needsCallSiteCostCentre env i =
checkFunc =
occNameMatches (ccfFuncName ccf) (getOccName i)
data NamePattern
= PChar Char NamePattern
| PWildcard NamePattern
| PEnd
instance Outputable NamePattern where
ppr (PChar c rest) = char c <> ppr rest
ppr (PWildcard rest) = char '*' <> ppr rest
ppr PEnd = Outputable.empty
instance B.Binary NamePattern where
get bh = do
tag <- B.get bh
case tag :: Word8 of
0 -> PChar <$> B.get bh <*> B.get bh
1 -> PWildcard <$> B.get bh
2 -> pure PEnd
_ -> panic "Binary(NamePattern): Invalid tag"
put_ bh (PChar x y) = B.put_ bh (0 :: Word8) >> B.put_ bh x >> B.put_ bh y
put_ bh (PWildcard x) = B.put_ bh (1 :: Word8) >> B.put_ bh x
put_ bh PEnd = B.put_ bh (2 :: Word8)
occNameMatches :: NamePattern -> OccName -> Bool
occNameMatches pat = go pat . occNameString
where
go :: NamePattern -> String -> Bool
go PEnd "" = True
go (PChar c rest) (d:s)
= d == c && go rest s
go (PWildcard rest) s
= go rest s || go (PWildcard rest) (tail s)
go _ _ = False
type Parser = P.ReadP
parseNamePattern :: Parser NamePattern
parseNamePattern = pattern
where
pattern = star P.<++ wildcard P.<++ char P.<++ end
star = PChar '*' <$ P.string "\\*" <*> pattern
wildcard = do
void $ P.char '*'
PWildcard <$> pattern
char = PChar <$> P.get <*> pattern
end = PEnd <$ P.eof
data CallerCcFilter
= CallerCcFilter { ccfModuleName :: Maybe ModuleName
, ccfFuncName :: NamePattern
}
instance Outputable CallerCcFilter where
ppr ccf =
maybe (char '*') ppr (ccfModuleName ccf)
<> char '.'
<> ppr (ccfFuncName ccf)
instance B.Binary CallerCcFilter where
get bh = CallerCcFilter <$> B.get bh <*> B.get bh
put_ bh (CallerCcFilter x y) = B.put_ bh x >> B.put_ bh y
parseCallerCcFilter :: String -> Either String CallerCcFilter
parseCallerCcFilter inp =
case P.readP_to_S parseCallerCcFilter' inp of
((result, ""):_) -> Right result
_ -> Left $ "parse error on " ++ inp
parseCallerCcFilter' :: Parser CallerCcFilter
parseCallerCcFilter' =
CallerCcFilter
<$> moduleFilter
<* P.char '.'
<*> parseNamePattern
where
moduleFilter :: Parser (Maybe ModuleName)
moduleFilter =
(Just . mkModuleName <$> moduleName)
<|>
(Nothing <$ P.char '*')
moduleName :: Parser String
moduleName = do
c <- P.satisfy isUpper
cs <- P.munch1 (\c -> isUpper c || isLower c || isDigit c || c == '_')
rest <- optional $ P.char '.' >> fmap ('.':) moduleName
return $ c : (cs ++ fromMaybe "" rest)
module GHC.Core.Opt.CallerCC where
import GHC.Prelude
-- Necessary due to import in GHC.Driver.Session.
data CallerCcFilter
parseCallerCcFilter :: String -> Either String CallerCcFilter
module GHC.Core.Opt.CallerCC.Types ( NamePattern(..)
, CallerCcFilter(..)
, occNameMatches
, parseCallerCcFilter
, parseNamePattern
) where
import Data.Word (Word8)
import Data.Maybe
import Control.Applicative
import Data.Either
import Control.Monad
import qualified Text.ParserCombinators.ReadP as P
import GHC.Prelude
import GHC.Utils.Outputable as Outputable
import GHC.Types.Name hiding (varName)
import GHC.Utils.Panic
import qualified GHC.Utils.Binary as B
import Data.Char
import Language.Haskell.Syntax.Module.Name
data NamePattern
= PChar Char NamePattern
| PWildcard NamePattern
| PEnd
instance Outputable NamePattern where
ppr (PChar c rest) = char c <> ppr rest
ppr (PWildcard rest) = char '*' <> ppr rest
ppr PEnd = Outputable.empty
instance B.Binary NamePattern where
get bh = do
tag <- B.get bh
case tag :: Word8 of
0 -> PChar <$> B.get bh <*> B.get bh
1 -> PWildcard <$> B.get bh
2 -> pure PEnd
_ -> panic "Binary(NamePattern): Invalid tag"
put_ bh (PChar x y) = B.put_ bh (0 :: Word8) >> B.put_ bh x >> B.put_ bh y
put_ bh (PWildcard x) = B.put_ bh (1 :: Word8) >> B.put_ bh x
put_ bh PEnd = B.put_ bh (2 :: Word8)
occNameMatches :: NamePattern -> OccName -> Bool
occNameMatches pat = go pat . occNameString
where
go :: NamePattern -> String -> Bool
go PEnd "" = True
go (PChar c rest) (d:s)
= d == c && go rest s
go (PWildcard rest) s
= go rest s || go (PWildcard rest) (tail s)
go _ _ = False
type Parser = P.ReadP
parseNamePattern :: Parser NamePattern
parseNamePattern = pattern
where
pattern = star P.<++ wildcard P.<++ char P.<++ end
star = PChar '*' <$ P.string "\\*" <*> pattern
wildcard = do
void $ P.char '*'
PWildcard <$> pattern
char = PChar <$> P.get <*> pattern
end = PEnd <$ P.eof
data CallerCcFilter
= CallerCcFilter { ccfModuleName :: Maybe ModuleName
, ccfFuncName :: NamePattern
}
instance Outputable CallerCcFilter where
ppr ccf =
maybe (char '*') ppr (ccfModuleName ccf)
<> char '.'
<> ppr (ccfFuncName ccf)
instance B.Binary CallerCcFilter where
get bh = CallerCcFilter <$> B.get bh <*> B.get bh
put_ bh (CallerCcFilter x y) = B.put_ bh x >> B.put_ bh y
parseCallerCcFilter :: String -> Either String CallerCcFilter
parseCallerCcFilter inp =
case P.readP_to_S parseCallerCcFilter' inp of
((result, ""):_) -> Right result
_ -> Left $ "parse error on " ++ inp
parseCallerCcFilter' :: Parser CallerCcFilter
parseCallerCcFilter' =
CallerCcFilter
<$> moduleFilter
<* P.char '.'
<*> parseNamePattern
where
moduleFilter :: Parser (Maybe ModuleName)
moduleFilter =
(Just . mkModuleName <$> moduleName)
<|>
(Nothing <$ P.char '*')
moduleName :: Parser String
moduleName = do
c <- P.satisfy isUpper
cs <- P.munch1 (\c -> isUpper c || isLower c || isDigit c || c == '_')
rest <- optional $ P.char '.' >> fmap ('.':) moduleName
return $ c : (cs ++ fromMaybe "" rest)
\ No newline at end of file
......@@ -10,7 +10,7 @@ module GHC.Core.Opt.Pipeline ( core2core, simplifyExpr ) where
import GHC.Prelude
import GHC.Driver.Session
import GHC.Driver.DynFlags
import GHC.Driver.Plugins ( withPlugins, installCoreToDos )
import GHC.Driver.Env
import GHC.Driver.Config.Core.Lint ( endPass )
......
......@@ -25,7 +25,7 @@ module GHC.Core.Opt.SpecConstr(
import GHC.Prelude
import GHC.Driver.Session ( DynFlags(..), GeneralFlag( Opt_SpecConstrKeen )
import GHC.Driver.DynFlags ( DynFlags(..), GeneralFlag( Opt_SpecConstrKeen )
, gopt, hasPprDebug )
import GHC.Core
......