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 (98)
  • Ben Gamari's avatar
    Reg.Liveness: Strictness · 34d08a20
    Ben Gamari authored and Marge Bot's avatar Marge Bot committed
    34d08a20
  • Ben Gamari's avatar
    Reg.Liveness: Don't repeatedly construct UniqSets · c5deaa27
    Ben Gamari authored and Marge Bot's avatar Marge Bot committed
    c5deaa27
  • Ben Gamari's avatar
    compiler/Types: Ensure that fromList-type operations can fuse · b947250b
    Ben Gamari authored and Marge Bot's avatar Marge Bot committed
    In #20740 I noticed that mkUniqSet does not fuse. In practice, allowing
    it to do so makes a considerable difference in allocations due to the
    backend.
    
    Metric Decrease:
        T12707
        T13379
        T3294
        T4801
        T5321FD
        T5321Fun
        T783
    b947250b
  • Sven Tennie's avatar
    x86 Codegen: Implement MO_S_MulMayOflo for W16 · 6c88c2ba
    Sven Tennie authored and Marge Bot's avatar Marge Bot committed
    6c88c2ba
  • Sven Tennie's avatar
    x86 CodeGen: MO_S_MulMayOflo better error message for rep > W64 · 5f1154e0
    Sven Tennie authored and Marge Bot's avatar Marge Bot committed
    It's useful to see which value made the pattern match fail. (If it ever
    occurs.)
    5f1154e0
  • Sven Tennie's avatar
    x86 CodeGen: Implement MO_S_MulMayOflo for W8 · e8c9a95f
    Sven Tennie authored and Marge Bot's avatar Marge Bot committed
    This case wasn't handled before. But, the test-primops test suite showed
    that it actually might appear.
    e8c9a95f
  • Sven Tennie's avatar
    Add test for %mulmayoflo primop · a36f9dc9
    Sven Tennie authored and Marge Bot's avatar Marge Bot committed
    The test expects a perfect implementation with no false positives.
    a36f9dc9
  • Matthew Pickering's avatar
    lint-ci-config: Generate jobs-metadata.json · 38a36248
    Matthew Pickering authored and Marge Bot's avatar Marge Bot committed
    We also now save the jobs-metadata.json and jobs.yaml file as artifacts
    as:
    
    * It might be useful for someone who is modifying CI to copy jobs.yaml
      if they are having trouble regenerating locally.
    * jobs-metadata.json is very useful for downstream pipelines to work out
      the right job to download.
    
    Fixes #23654
    38a36248
  • Vladislav Zavialov's avatar
    Initialize 9.10.1-notes.rst · 1535a671
    Vladislav Zavialov authored and Marge Bot's avatar Marge Bot committed
    Create new release notes for the next GHC release (GHC 9.10)
    1535a671
  • sheaf's avatar
    Prioritise Parent when looking up class sub-binder · 3bd4d5b5
    sheaf authored and Marge Bot's avatar Marge Bot committed
    When we look up children GlobalRdrElts of a given Parent, we sometimes
    would rather prioritise those GlobalRdrElts which have the right Parent,
    and sometimes prioritise those that have the right NameSpace:
    
      - in export lists, we should prioritise NameSpace
      - for class/instance binders, we should prioritise Parent
    
    See Note [childGREPriority] in GHC.Types.Name.Reader.
    
    fixes #23664
    3bd4d5b5
  • Alan Zimmerman's avatar
    EPA: Improve annotation management in getMonoBind · 9c8fdda3
    Alan Zimmerman authored and Marge Bot's avatar Marge Bot committed
    Ensure the LHsDecl for a FunBind has the correct leading comments and
    trailing annotations.
    
    See the added note for details.
    9c8fdda3
  • Matthew Pickering's avatar
    Remove unused files in .gitlab · ff884b77
    Matthew Pickering authored
    These were left over after 6078b429
    ff884b77
  • Matthew Pickering's avatar
    gen_ci: Add hie.yaml file · 29ef590c
    Matthew Pickering authored
    This allows you to load `gen_ci.hs` into HLS, and now it is a huge
    module, that is quite useful.
    29ef590c
  • Matthew Pickering's avatar
    ci: Make "fast-ci" the default validate configuration · 808b55cf
    Matthew Pickering authored
    We are trying out a lighter weight validation pipeline where by default
    we just test on 5 platforms:
    
    * x86_64-deb10-slow-validate
    * windows
    * x86_64-fedora33-release
    * aarch64-darwin
    * aarch64-linux-deb10
    
    In order to enable the "full" validation pipeline you can apply the
    `full-ci` label which will enable all the validation pipelines.
    
    All the validation jobs are still run on a marge batch.
    
    The goal is to reduce the overall CI capacity so that pipelines start
    faster for MRs and marge bot batches are faster.
    
    Fixes #23694
    808b55cf
  • Alan Zimmerman's avatar
    EPA: Simplify GHC/Parser.y sL1 · 0b23db03
    Alan Zimmerman authored and Marge Bot's avatar Marge Bot committed
    This is the next patch in a series simplifying location management in
    GHC/Parser.y
    
    This one simplifies sL1, to use the HasLoc instances introduced in
    !10743 (closed)
    0b23db03
  • Ben Gamari's avatar
    nativeGen: Explicitly set flags of text sections on Windows · 3ece9856
    Ben Gamari authored and Marge Bot's avatar Marge Bot committed
    The binutils documentation (for COFF) claims,
    
    > If no flags are specified, the default flags depend upon the section
    > name. If the section name is not recognized, the default will be for the
    > section to be loaded and writable.
    
    We previously assumed that this would do the right thing for split
    sections (e.g. a section named `.text$foo` would be correctly inferred
    to be a text section). However, we have observed that this is not the
    case (at least under the clang toolchain used on Windows): when
    split-sections is enabled, text sections are treated by the assembler as
    data (matching the "default" behavior specified by the documentation).
    
    Avoid this by setting section flags explicitly. This should fix split
    sections on Windows.
    
    Fixes #22834.
    3ece9856
  • Ben Gamari's avatar
    nativeGen: Set explicit section types on all platforms · db7f7240
    Ben Gamari authored and Marge Bot's avatar Marge Bot committed
    db7f7240
  • Finley McIlwaine's avatar
    Insert documentation into parsed signature modules · b444c16f
    Finley McIlwaine authored and Marge Bot's avatar Marge Bot committed
    Causes haddock comments in signature modules to be properly
    inserted into the AST (just as they are for regular modules)
    if the `-haddock` flag is given.
    
    Also adds a test that compares `-ddump-parsed-ast` output
    for a signature module to prevent further regressions.
    
    Fixes #23315
    b444c16f
  • Ben Gamari's avatar
    primops: Introduce unsafeThawByteArray# · c30cea53
    Ben Gamari authored and Marge Bot's avatar Marge Bot committed
    This addresses an odd asymmetry in the ByteArray# primops, which
    previously provided unsafeFreezeByteArray# but no corresponding
    thaw operation.
    
    Closes #22710
    c30cea53
  • Ben Gamari's avatar
    testsuite: Elaborate in interface stability README · 87f9bd47
    Ben Gamari authored and Marge Bot's avatar Marge Bot committed
    This discussion didn't make it into the original MR.
    87f9bd47
  • Matthew Pickering's avatar
    Allow users to override non-essential haddock options in a Flavour · e4350b41
    Matthew Pickering authored and Marge Bot's avatar Marge Bot committed
    We now supply the non-essential options to haddock using the `extraArgs`
    field, which can be specified in a Flavour so that if an advanced user
    wants to change how documentation is generated then they can use
    something other than the `defaultHaddockExtraArgs`.
    
    This does have the potential to regress some packaging if a user has
    overridden `extraArgs` themselves, because now they also need to add
    the haddock options to extraArgs. This can easily be done by appending
    `defaultHaddockExtraArgs` to their extraArgs invocation but someone
    might not notice this behaviour has changed.
    
    In any case, I think passing the non-essential options in this manner is
    the right thing to do and matches what we do for the "ghc" builder,
    which by default doesn't pass any optmisation levels, and would likewise
    be very bad if someone didn't pass suitable `-O` levels for builds.
    
    Fixes #23625
    e4350b41
  • Ilias Tsitsimpis's avatar
    ghc-prim: Link against libatomic · fc186b0c
    Ilias Tsitsimpis authored and Marge Bot's avatar Marge Bot committed
    Commit b4d39adb made 'hs_cmpxchg64()' available to all architectures.
    Unfortunately this made GHC to fail to build on armel, since armel needs
    libatomic to support atomic operations on 64-bit word sizes.
    
    Configure libraries/ghc-prim/ghc-prim.cabal to link against libatomic,
    the same way as we do in rts/rts.cabal.
    fc186b0c
  • Matthew Pickering's avatar
    simplifier: Correct InScopeSet in rule matching · 4f5538a8
    Matthew Pickering authored and Marge Bot's avatar Marge Bot committed
    The in-scope set passedto the `exprIsLambda_maybe` call lacked all the
    in-scope binders. @simonpj suggests this fix where we augment the
    in-scope set with the free variables of expression which fixes this
    failure mode in quite a direct way.
    
    Fixes #23630
    4f5538a8
  • Krzysztof Gogolewski's avatar
    Add a test for #23413 · 5ad8d597
    Krzysztof Gogolewski authored and Marge Bot's avatar Marge Bot committed
    It was fixed by commit e1590ddc: Add the SolverStage monad.
    5ad8d597
  • sheaf's avatar
    Finish migration of diagnostics in GHC.Tc.Validity · 7e05f6df
    sheaf authored and Marge Bot's avatar Marge Bot committed
    This patch finishes migrating the error messages in GHC.Tc.Validity
    to use the new diagnostic infrastructure.
    
    It also refactors the error message datatypes for class and family
    instances, to common them up under a single datatype as much as possible.
    7e05f6df
  • Matthew Pickering's avatar
    ci: Enable some more jobs to run in a marge batch · 4876fddc
    Matthew Pickering authored and Marge Bot's avatar Marge Bot committed
    In !10907 I made the majority of jobs not run on a validate pipeline but
    then forgot to renable a select few jobs on the marge batch MR.
    4876fddc
  • Jens Petersen's avatar
    user_guide/flags.py: python-3.12 no longer includes distutils · 026991d7
    Jens Petersen authored and Marge Bot's avatar Marge Bot committed
    packaging.version seems able to handle this fine
    026991d7
  • Matthew Pickering's avatar
    ci: Mention ~full-ci label in MR template · b91bbc2b
    Matthew Pickering authored and Marge Bot's avatar Marge Bot committed
    We mention that if you need a full validation pipeline then you can
    apply the ~full-ci label to your MR in order to test against the full
    validation pipeline (like we do for marge).
    b91bbc2b
  • sheaf's avatar
    RTS: declare setKeepCAFs symbol · 42b05e9b
    sheaf authored and Marge Bot's avatar Marge Bot committed
    Commit 08ba8720 failed to declare the dependency of keepCAFsForGHCi on
    the symbol setKeepCAFs in the RTS, which led to undefined symbol errors
    on Windows, as exhibited by the testcase frontend001.
    
    Thanks to Moritz Angermann and Ryan Scott for the diagnosis and fix.
    
    Fixes #22961
    42b05e9b
  • sheaf's avatar
    Mark plugins-external as broken on Windows · a72015d6
    sheaf authored and Marge Bot's avatar Marge Bot committed
    This test is broken on Windows, so we explicitly mark it as such now
    that we stop skipping plugin tests on Windows.
    a72015d6
  • sheaf's avatar
    Stop marking plugin tests as fragile on Windows · cb9c93d7
    sheaf authored and Marge Bot's avatar Marge Bot committed
    Now that b2bb3e62 has landed we are in a better situation with
    regards to plugins on Windows, allowing us to unmark many plugin tests
    as fragile.
    
    Fixes #16405
    cb9c93d7
  • Krzysztof Gogolewski's avatar
    Misc cleanup · a7349217
    Krzysztof Gogolewski authored and Marge Bot's avatar Marge Bot committed
    - Remove unused RDR names
    - Fix typos in comments
    - Deriving: simplify boxConTbl and remove unused litConTbl
    - chmod -x GHC/Exts.hs, this seems accidental
    a7349217
  • Vladislav Zavialov's avatar
    Visible forall in types of terms: Part 1 (#22326) · 33b6850a
    Vladislav Zavialov authored and Marge Bot's avatar Marge Bot committed
    This patch implements part 1 of GHC Proposal #281,
    introducing explicit `type` patterns and `type` arguments.
    
    Summary of the changes:
    
    1. New extension flag:
         RequiredTypeArguments
    
    2. New user-facing syntax:
         `type p` patterns    (represented by EmbTyPat)
         `type e` expressions (represented by HsEmbTy)
    
    3. Functions with required type arguments (visible forall)
       can now be defined and applied:
          idv :: forall a -> a -> a    -- signature   (relevant change: checkVdqOK in GHC/Tc/Validity.hs)
          idv (type a) (x :: a) = x    -- definition  (relevant change: tcPats in GHC/Tc/Gen/Pat.hs)
          x = idv (type Int) 42        -- usage       (relevant change: tcInstFun in GHC/Tc/Gen/App.hs)
    
    4. template-haskell support:
          TH.TypeE corresponds to HsEmbTy
          TH.TypeP corresponds to EmbTyPat
    
    5. Test cases and a new User's Guide section
    
    Changes *not* included here are the t2t (term-to-type) transformation
    and term variable capture; those belong to part 2.
    33b6850a
  • sheaf's avatar
    Add test for #22424 · 73b5c7ce
    sheaf authored and Marge Bot's avatar Marge Bot committed
    This is a simple Template Haskell test in which we refer to
    record selectors by their exact Names, in two different ways.
    
    Fixes #22424
    73b5c7ce
  • Ben Gamari's avatar
    ghc-toolchain: Initial commit · 83cbc672
    Ben Gamari authored and Matthew Pickering's avatar Matthew Pickering committed
    83cbc672
  • Rodrigo Mesquita's avatar
    ghc-toolchain: Toolchain Selection · 31dcd26c
    Rodrigo Mesquita authored and Matthew Pickering's avatar Matthew Pickering committed
    This commit integrates ghc-toolchain, the brand new way of configuring
    toolchains for GHC, with the Hadrian build system, with configure, and
    extends and improves the first iteration of ghc-toolchain.
    
    The general overview is
    
    * We introduce a program invoked `ghc-toolchain --triple=...` which, when run,
      produces a file with a `Target`. A `GHC.Toolchain.Target.Target`
      describes the properties of a target and the toolchain (executables
      and configured flags) to produce code for that target
    
    * Hadrian was modified to read Target files, and will both
      * Invoke the toolchain configured in the Target file as needed
      * Produce a `settings` file for GHC based on the Target file for that stage
    
    * `./configure` will invoke ghc-toolchain to generate target files, but
      it will also generate target files based on the flags configure itself
      configured (through `.in` files that are substituted)
    
      * By default, the Targets generated by configure are still (for now) the ones used by Hadrian
    
      * But we additionally validate the Target files generated by
        ghc-toolchain against the ones generated by configure, to get a head
        start on catching configuration bugs before we transition
        completely.
    
      * When we make that transition, we will want to drop a lot of the
        toolchain configuration logic from configure, but keep it otherwise.
    
    * For each compiler stage we should have 1 target file (up to a stage compiler we can't run in our machine)
      * We just have a HOST target file, which we use as the target for stage0
      * And a TARGET target file, which we use for stage1 (and later stages, if not cross compiling)
      * Note there is no BUILD target file, because we only support cross compilation where BUILD=HOST
      * (for more details on cross-compilation see discussion on !9263)
    
    See also
    * Note [How we configure the bundled windows toolchain]
    * Note [ghc-toolchain consistency checking]
    * Note [ghc-toolchain overview]
    
    Ticket: #19877
    MR: !9263
    31dcd26c
  • Rodrigo Mesquita's avatar
    Add flag to enable/disable ghc-toolchain based configurations · a732b6d3
    Rodrigo Mesquita authored and Matthew Pickering's avatar Matthew Pickering committed
    This flag is disabled by default, and we'll use the
    configure-generated-toolchains by default until we remove the toolchain
    configuration logic from configure.
    a732b6d3
  • Rodrigo Mesquita's avatar
    Split ghc-toolchain executable to new packge · 61eea240
    Rodrigo Mesquita authored and Matthew Pickering's avatar Matthew Pickering committed
    In light of #23690, we split the ghc-toolchain executable out of the
    library package to be able to ship it in the bindist using Hadrian.
    
    Ideally, we eventually revert this commit.
    61eea240
  • Rodrigo Mesquita's avatar
    Ship ghc-toolchain in the bindist · 38e795ff
    Rodrigo Mesquita authored and Matthew Pickering's avatar Matthew Pickering committed
    Add the ghc-toolchain binary to the binary distribution we ship to
    users, and teach the bindist configure to use the existing ghc-toolchain.
    38e795ff
  • Matthew Craven's avatar
    Kill off gen_bytearray_addr_access_ops.py · 32cae784
    Matthew Craven authored and Marge Bot's avatar Marge Bot committed
    The relevant primop descriptions are now
    generated directly by genprimopcode.
    
    This makes progress toward fixing #23490, but it is not
    a complete fix since there is more than one way in which
    cabal-reinstall (hadrian/build build-cabal) is broken.
    32cae784
  • Matthew Pickering's avatar
    compiler: Remove unused `containers.h` include · 02e6a6ce
    Matthew Pickering authored and Marge Bot's avatar Marge Bot committed
    Fixes #23712
    02e6a6ce
  • Matthew Pickering's avatar
    Fix pretty printing of WARNING pragmas · 822ef66b
    Matthew Pickering authored and Marge Bot's avatar Marge Bot committed
    There is still something quite unsavoury going on with WARNING pragma
    printing because the printing relies on the fact that for decl
    deprecations the SourceText of WarningTxt is empty. However, I let that
    lion sleep and just fixed things directly.
    
    Fixes #23465
    822ef66b
  • Matthew Pickering's avatar
    ci-images: Bump to commit which has 9.6 image · e7b38ede
    Matthew Pickering authored and Marge Bot's avatar Marge Bot committed
    The test-bootstrap job has been failing for 9.6 because we accidentally
    used a non-master commit.
    e7b38ede
  • Matthew Pickering's avatar
    Update bootstrap plans for 9.6.2 and 9.4.5 · bb408936
    Matthew Pickering authored and Marge Bot's avatar Marge Bot committed
    bb408936
  • Alan Zimmerman's avatar
    EPA: Simplify GHC/Parser.y comb4/comb5 · 355e1792
    Alan Zimmerman authored and Marge Bot's avatar Marge Bot committed
    Use the HasLoc instance from Ast.hs to allow comb4/comb5 to work with
    anything with a SrcSpan
    
    Also get rid of some more now unnecessary reLoc calls.
    355e1792
  • Gavin Zhao's avatar
    compiler: make -ddump-asm work with wasm backend NCG · 9393df83
    Gavin Zhao authored and Marge Bot's avatar Marge Bot committed
    
    Fixes #23503.
    
    Now the `-ddump-asm` flag is respected in the wasm backend
    NCG, so developers can directly view the generated ASM instead of
    needing to pass `-S` or `-keep-tmp-files` and manually find & open
    the assembly file.
    
    Ideally, we should be able to output the assembly files in smaller
    chunks like in other NCG backends. This would also make dumping assembly
    stats easier. However, this would require a large refactoring, so for
    short-term debugging purposes I think the current approach works fine.
    
    Signed-off-by: default avatarGavin Zhao <git@gzgz.dev>
    9393df83
  • Krzysztof Gogolewski's avatar
    llvm: Restore accidentally deleted code in 0fc5cb97 · 79463036
    Krzysztof Gogolewski authored and Marge Bot's avatar Marge Bot committed
    Fixes #23711
    79463036
  • Rodrigo Mesquita's avatar
    configure: Default missing options to False when preparing ghc-toolchain Targets · 20db7e26
    Rodrigo Mesquita authored and Marge Bot's avatar Marge Bot committed
    This commit fixes building ghc with 9.2 as the boostrap compiler.
    
    The ghc-toolchain patch assumed all _STAGE0 options were available, and
    forgot to account for this missing information in 9.2.
    
    Ghc 9.2 does not have in settings whether ar supports -l, hence can't
    report it with --info (unliked 9.4 upwards).
    
    The fix is to default the missing information (we default "ar supports
    -l" and other missing options to False)
    20db7e26
  • Naïm Favier's avatar
    docs: Fix typo · fac9e84e
    Naïm Favier authored and Marge Bot's avatar Marge Bot committed
    fac9e84e
  • Bartłomiej Cieślar's avatar
    This MR is an implementation of the proposal #516. · 503fd647
    Bartłomiej Cieślar authored and Marge Bot's avatar Marge Bot committed
    It adds a warning -Wincomplete-record-selectors for usages of a record
    field access function (either a record selector or getField @"rec"),
    while trying to silence the warning whenever it can be sure that a constructor
    without the record field would not be invoked (which would otherwise cause
    the program to fail). For example:
    
        data T = T1 | T2 {x :: Bool}
    
        f a = x a -- this would throw an error
    
        g T1 = True
        g a = x a -- this would not throw an error
    
        h :: HasField "x" r Bool => r -> Bool
        h = getField @"x"
    
        j :: T -> Bool
        j = h -- this would throw an error because of the `HasField`
              -- constraint being solved
    
    See the tests DsIncompleteRecSel* and TcIncompleteRecSel for more examples of the warning.
    See Note [Detecting incomplete record selectors] in GHC.HsToCore.Expr for implementation details
    503fd647
  • Arnaud Spiwack's avatar
    Fix user-facing label in MR template · af6fdf42
    Arnaud Spiwack authored and Marge Bot's avatar Marge Bot committed
    af6fdf42
  • Matthew Pickering's avatar
    ci: Test bootstrapping configurations with full-ci and on marge batches · 5d45b92a
    Matthew Pickering authored and Marge Bot's avatar Marge Bot committed
    There have been two incidents recently where bootstrapping has been
    broken by removing support for building with 9.2.*.
    
    The process for bumping the minimum required version starts with bumping
    the configure version and then other CI jobs such as the bootstrap jobs
    have to be updated. We must not silently bump the minimum required
    version.
    
    Now we are running a slimmed down validate pipeline it seems worthwile
    to test these bootstrap configurations in the full-ci pipeline.
    5d45b92a
  • Matthew Pickering's avatar
    bootstrap: Remove ghc-9_2_* plans · 25d4fee7
    Matthew Pickering authored and Marge Bot's avatar Marge Bot committed
    We are anticipating shortly making it necessary to use ghc-9.4 to boot
    the compiler.
    25d4fee7
  • Matthew Pickering's avatar
    Update bootstrap plans for ghc-platform and ghc-toolchain dependencies · 2f66da16
    Matthew Pickering authored and Marge Bot's avatar Marge Bot committed
    Fixes #23735
    2f66da16
  • Matthew Pickering's avatar
    bootstrap: Disable -selftest flag from bootstrap plans · c8c6eab1
    Matthew Pickering authored and Marge Bot's avatar Marge Bot committed
    This saves on building one dependency (QuickCheck) which is unecessary
    for bootstrapping.
    c8c6eab1
  • Bodigrim's avatar
    Link reference paper and package from System.Mem.{StableName,Weak} · a80ca086
    Bodigrim authored and Marge Bot's avatar Marge Bot committed
    a80ca086
  • David's avatar
    Update Match Datatype · a5319358
    David authored and Marge Bot's avatar Marge Bot committed
    EquationInfo currently contains a list of the equation's patterns together with a CoreExpr that is to be evaluated after a successful match on this equation.
    All the match-functions only operate on the first pattern of an equation - after successfully matching it, match is called recursively on the tail of the pattern list.
    We can express this more clearly and make the code a little more elegant by updating the datatype of EquationInfo as follows:
    
    data EquationInfo
        = EqnMatch { eqn_pat = Pat GhcTc, eqn_rest = EquationInfo }
        | EqnDone { eqn_rhs = MatchResult CoreExpr }
    
    An EquationInfo now explicitly exposes its first pattern which most functions operate on, and exposes the equation that remains after processing the first pattern. An EqnDone signifies an empty equation where the CoreExpr can now be evaluated.
    a5319358
  • BinderDavid's avatar
    Improve documentation for Data.Fixed · 86ad1af9
    BinderDavid authored and Marge Bot's avatar Marge Bot committed
    86ad1af9
  • Ben Gamari's avatar
    ghc-prim: Use C11 atomics · f8fa1d08
    Ben Gamari authored and Marge Bot's avatar Marge Bot committed
    Previously `ghc-prim`'s atomic wrappers used the legacy `__sync_*`
    family of C builtins. Here we refactor these to rather use the
    appropriate C11 atomic equivalents, allowing us to be more explicit
    about the expected ordering semantics.
    f8fa1d08
  • Finley McIlwaine's avatar
    Include -haddock in DynFlags fingerprint · 0bfc8908
    Finley McIlwaine authored and Marge Bot's avatar Marge Bot committed
    The -haddock flag determines whether or not the resulting .hi files
    contain haddock documentation strings. If the existing .hi files do
    not contain haddock documentation strings and the user requests them,
    we should recompile.
    0bfc8908
  • Andreas Klebinger's avatar
    Aarch64 NCG: Use encoded immediates for literals. · 40425c50
    Andreas Klebinger authored and Marge Bot's avatar Marge Bot committed
    Try to generate
    
        instr x2, <imm>
    
    instead of
    
        mov x1, lit
        instr x2, x1
    
    When possible. This get's rid if quite a few redundant
    mov instructions.
    
    I believe this causes a metric decrease for LargeRecords as
    we reduce register pressure.
    
    -------------------------
    Metric Decrease:
        LargeRecord
    -------------------------
    40425c50
  • Bodigrim's avatar
    Bump filepath submodule to 1.4.100.4 · e9a0fa3f
    Bodigrim authored and Marge Bot's avatar Marge Bot committed
    Resolves #23741
    
    Metric Decrease:
        MultiComponentModules
        MultiComponentModulesRecomp
        MultiLayerModules
        MultiLayerModulesRecomp
        T10421
        T12234
        T12425
        T13035
        T13701
        T13719
        T16875
        T18304
        T18698a
        T18698b
        T21839c
        T9198
        TcPlugin_RewritePerf
        hard_hole_fits
    
    Metric decrease on Windows can be probably attributed to https://github.com/haskell/filepath/pull/183
    e9a0fa3f
  • Bodigrim's avatar
    Add since pragmas to GHC.IO.Handle.FD · ee93edfd
    Bodigrim authored and Marge Bot's avatar Marge Bot committed
    ee93edfd
  • Simon Peyton Jones's avatar
    Make the occurrence analyser smarter about join points · d0369802
    Simon Peyton Jones authored and Simon Peyton Jones's avatar Simon Peyton Jones committed
    This MR addresses #22404.  There is a big Note
    
       Note [Occurrence analysis for join points]
    
    that explains it all.  Significant changes
    
    * New field occ_join_points in OccEnv
    
    * The NonRec case of occAnalBind splits into two cases:
      one for existing join points (which does the special magic for
      Note [Occurrence analysis for join points], and one for other
      bindings.
    
    * mkOneOcc adds in info from occ_join_points.
    
    * All "bring into scope" activity is centralised in the
      new function `addInScope`.
    
    * I made a local data type LocalOcc for use inside the occurrence analyser
      It is like OccInfo, but lacks IAmDead and IAmALoopBreaker, which in turn
      makes computationns over it simpler and more efficient.
    
    * I found quite a bit of allocation in GHC.Core.Rules.getRules
      so I optimised it a bit.
    
    More minor changes
    
    * I found I was using (Maybe Arity) a lot, so I defined a new data
      type JoinPointHood and used it everwhere.  This touches a lot of
      non-occ-anal files, but it makes everything more perspicuous.
    
    * Renamed data constructor WithUsageDetails to WUD, and
      WithTailUsageDetails to WTUD
    
    This also fixes #21128, on the way.
    
    --------- Compiler perf -----------
    I spent quite a time on performance tuning, so even though it
    does more than before, the occurrence analyser runs slightly faster
    on average.  Here are the compile-time allocation changes over 0.5%
    
          CoOpt_Read(normal) ghc/alloc    766,025,520    754,561,992  -1.5%
    CoOpt_Singletons(normal) ghc/alloc    759,436,840    762,925,512  +0.5%
         LargeRecord(normal) ghc/alloc  1,814,482,440  1,799,530,456  -0.8%
           PmSeriesT(normal) ghc/alloc     68,159,272     67,519,720  -0.9%
              T10858(normal) ghc/alloc    120,805,224    118,746,968  -1.7%
              T11374(normal) ghc/alloc    164,901,104    164,070,624  -0.5%
              T11545(normal) ghc/alloc     79,851,808     78,964,704  -1.1%
              T12150(optasm) ghc/alloc     73,903,664     71,237,544  -3.6% GOOD
              T12227(normal) ghc/alloc    333,663,200    331,625,864  -0.6%
              T12234(optasm) ghc/alloc     52,583,224     52,340,344  -0.5%
              T12425(optasm) ghc/alloc     81,943,216     81,566,720  -0.5%
              T13056(optasm) ghc/alloc    294,517,928    289,642,512  -1.7%
          T13253-spj(normal) ghc/alloc    118,271,264     59,859,040 -49.4% GOOD
              T15164(normal) ghc/alloc  1,102,630,352  1,091,841,296  -1.0%
              T15304(normal) ghc/alloc  1,196,084,000  1,166,733,000  -2.5%
              T15630(normal) ghc/alloc    148,729,632    147,261,064  -1.0%
              T15703(normal) ghc/alloc    379,366,664    377,600,008  -0.5%
              T16875(normal) ghc/alloc     32,907,120     32,670,976  -0.7%
              T17516(normal) ghc/alloc  1,658,001,888  1,627,863,848  -1.8%
              T17836(normal) ghc/alloc    395,329,400    393,080,248  -0.6%
              T18140(normal) ghc/alloc     71,968,824     73,243,040  +1.8%
              T18223(normal) ghc/alloc    456,852,568    453,059,088  -0.8%
              T18282(normal) ghc/alloc    129,105,576    131,397,064  +1.8%
              T18304(normal) ghc/alloc     71,311,712     70,722,720  -0.8%
             T18698a(normal) ghc/alloc    208,795,112    210,102,904  +0.6%
             T18698b(normal) ghc/alloc    230,320,736    232,697,976  +1.0%  BAD
              T19695(normal) ghc/alloc  1,483,648,128  1,504,702,976  +1.4%
              T20049(normal) ghc/alloc     85,612,024     85,114,376  -0.6%
             T21839c(normal) ghc/alloc    415,080,992    410,906,216  -1.0% GOOD
               T4801(normal) ghc/alloc    247,590,920    250,726,272  +1.3%
               T6048(optasm) ghc/alloc     95,699,416     95,080,680  -0.6%
                T783(normal) ghc/alloc    335,323,384    332,988,120  -0.7%
               T9233(normal) ghc/alloc    709,641,224    685,947,008  -3.3% GOOD
               T9630(normal) ghc/alloc    965,635,712    948,356,120  -1.8%
               T9675(optasm) ghc/alloc    444,604,152    428,987,216  -3.5% GOOD
               T9961(normal) ghc/alloc    303,064,592    308,798,800  +1.9%  BAD
               WWRec(normal) ghc/alloc    503,728,832    498,102,272  -1.1%
    
                   geo. mean                                          -1.0%
                   minimum                                           -49.4%
                   maximum                                            +1.9%
    
    In fact these figures seem to vary between platforms; generally worse
    on i386 for some reason.  The Windows numbers vary by 1% espec in
    benchmarks where the total allocation is low. But the geom mean stays
    solidly negative, which is good.  The "increase/decrease" list below
    covers all platforms.
    
    The big win on T13253-spj comes because it has a big nest of join
    points, each occurring twice in the next one.  The new occ-anal takes
    only one iteration of the simplifier to do the inlining; the old one
    took four.  Moreover, we get much smaller code with the new one:
    
      New: Result size of Tidy Core
        = {terms: 429, types: 84, coercions: 0, joins: 14/14}
    
      Old: Result size of Tidy Core
        = {terms: 2,437, types: 304, coercions: 0, joins: 10/10}
    
    --------- Runtime perf -----------
    No significant changes in nofib results, except a 1% reduction in
    compiler allocation.
    
    Metric Decrease:
        CoOpt_Read
        T13253-spj
        T9233
        T9630
        T9675
        T12150
        T21839c
        LargeRecord
        MultiComponentModulesRecomp
        T10421
        T13701
        T10421
        T13701
        T12425
    
    Metric Increase:
        T18140
        T9961
        T18282
        T18698a
        T18698b
        T19695
    d0369802
  • Julian Ospald's avatar
  • Sylvain Henry's avatar
    JS: implement getMonotonicTime (fix #23687) · 33598ecb
    Sylvain Henry authored and Marge Bot's avatar Marge Bot committed
    33598ecb
  • Bartłomiej Cieślar's avatar
    Implementation of the Deprecated Instances proposal #575 · d2bedffd
    Bartłomiej Cieślar authored and Marge Bot's avatar Marge Bot committed
    
    This commit implements the ability to deprecate certain instances,
    which causes the compiler to emit the desired deprecation message
    whenever they are instantiated. For example:
    
      module A where
      class C t where
      instance {-# DEPRECATED "dont use" #-} C Int where
    
      module B where
      import A
      f :: C t => t
      f = undefined
      g :: Int
      g = f -- "dont use" emitted here
    
    The implementation is as follows:
      - In the parser, we parse deprecations/warnings attached to instances:
    
          instance {-# DEPRECATED "msg" #-} Show X
          deriving instance {-# WARNING "msg2" #-} Eq Y
    
        (Note that non-standalone deriving instance declarations do not support
        this mechanism.)
    
      - We store the resulting warning message in `ClsInstDecl` (respectively, `DerivDecl`).
        In `GHC.Tc.TyCl.Instance.tcClsInstDecl` (respectively, `GHC.Tc.Deriv.Utils.newDerivClsInst`),
        we pass on that information to `ClsInst` (and eventually store it in `IfaceClsInst` too).
    
      - Finally, when we solve a constraint using such an instance, in
        `GHC.Tc.Instance.Class.matchInstEnv`, we emit the appropriate warning
        that was stored in `ClsInst`.
        Note that we only emit a warning when the instance is used in a different module
        than it is defined, which keeps the behaviour in line with the deprecation of
        top-level identifiers.
    
    Signed-off-by: default avatarBartłomiej Cieślar <bcieslar2001@gmail.com>
    d2bedffd
  • Ben Gamari's avatar
    compiler: Style fixes · d5a65af6
    Ben Gamari authored and Marge Bot's avatar Marge Bot committed
    d5a65af6
  • Ben Gamari's avatar
    rts: Fix implicit cast · 7218c80a
    Ben Gamari authored and Marge Bot's avatar Marge Bot committed
    This ensures that Task.h can be built with a C++ compiler.
    7218c80a
  • Ben Gamari's avatar
    testsuite: Fix warning in hs_try_putmvar001 · d6d5aafc
    Ben Gamari authored and Marge Bot's avatar Marge Bot committed
    d6d5aafc
  • Ben Gamari's avatar
    testsuite: Add AtomicModifyIORef test · d9eddf7a
    Ben Gamari authored and Marge Bot's avatar Marge Bot committed
    d9eddf7a
  • Ben Gamari's avatar
    rts: Introduce NO_WARN macro · f9eea4ba
    Ben Gamari authored and Marge Bot's avatar Marge Bot committed
    This allows fine-grained ignoring of warnings.
    f9eea4ba
  • Ben Gamari's avatar
    rts: Simplify atomicModifyMutVar2# implementation · 497b24ec
    Ben Gamari authored and Marge Bot's avatar Marge Bot committed
    Previously we would perform a redundant load in the non-threaded RTS in
    atomicModifyMutVar2# implementation for the benefit of the non-moving
    GC's write barrier. Eliminate this.
    497b24ec
  • Ben Gamari's avatar
    rts: Introduce more principled fence operations · 52ee082b
    Ben Gamari authored and Marge Bot's avatar Marge Bot committed
    52ee082b
  • Ben Gamari's avatar
    rts: Introduce SET_INFO_RELAXED · cd3c0377
    Ben Gamari authored and Marge Bot's avatar Marge Bot committed
    cd3c0377
  • Ben Gamari's avatar
    rts: Style fixes · 6df2352a
    Ben Gamari authored and Marge Bot's avatar Marge Bot committed
    6df2352a
  • Ben Gamari's avatar
    codeGen/tsan: Rework handling of spilling · 4ef6f319
    Ben Gamari authored and Marge Bot's avatar Marge Bot committed
    4ef6f319
  • Ben Gamari's avatar
    hadrian: More debug information · f9ca7e27
    Ben Gamari authored and Marge Bot's avatar Marge Bot committed
    f9ca7e27
  • Ben Gamari's avatar
    Improve TSAN documentation · df4153ac
    Ben Gamari authored and Marge Bot's avatar Marge Bot committed
    df4153ac
  • Ben Gamari's avatar
    hadrian: More selective TSAN instrumentation · fecae988
    Ben Gamari authored and Marge Bot's avatar Marge Bot committed
    fecae988
  • Alan Zimmerman's avatar
    EPA: Provide correct annotation span for ImportDecl · 465a9a0b
    Alan Zimmerman authored and Marge Bot's avatar Marge Bot committed
    Use the whole declaration, rather than just the span of the 'import'
    keyword.
    
    Metric Decrease:
       T9961
       T5205
    Metric Increase:
      T13035
    465a9a0b
  • Bartłomiej Cieślar's avatar
    Add cases to T23279: HasField for deprecated record fields · ae63d0fa
    Bartłomiej Cieślar authored and Marge Bot's avatar Marge Bot committed
    This commit adds additional tests from ticket #23279 to ensure that we don't
    regress on reporting deprecated record fields in conjunction with HasField,
    either when using overloaded record dot syntax or directly through `getField`.
    
    Fixes #23279
    ae63d0fa
  • Andreas Klebinger's avatar
    AArch NCG: Pure refactor · 00fb6e6b
    Andreas Klebinger authored and Marge Bot's avatar Marge Bot committed
    Combine some alternatives. Add some line breaks for overly long lines
    00fb6e6b
  • Andreas Klebinger's avatar
    Aarch ncg: Optimize immediate use for address calculations · 8f3b3b78
    Andreas Klebinger authored and Marge Bot's avatar Marge Bot committed
    When the offset doesn't fit into the immediate we now just reuse the
    general getRegister' code path which is well optimized to compute the
    offset into a register instead of a special case for CmmRegOff.
    
    This means we generate a lot less code under certain conditions which is
    why performance metrics for these improve.
    
    -------------------------
    Metric Decrease:
        T4801
        T5321FD
        T5321Fun
    -------------------------
    8f3b3b78
  • MorrowM's avatar
    Add a RULE to make lookup fuse · 74a882dc
    MorrowM authored and Marge Bot's avatar Marge Bot committed
    See https://github.com/haskell/core-libraries-committee/issues/175
    
    Metric Increase:
        T18282
    74a882dc
  • Ben Gamari's avatar
    hadrian: Ensure that way-flags are passed to CC · cca74dab
    Ben Gamari authored and Marge Bot's avatar Marge Bot committed
    Previously the way-specific compilation flags (e.g. `-DDEBUG`,
    `-DTHREADED_RTS`) would not be passed to the CC invocations. This meant
    that C dependency files would not correctly reflect
    dependencies predicated on the way, resulting in the rather
    painful #23554.
    
    Closes #23554.
    cca74dab
  • Jaro Reinders's avatar
    Native 32-bit Enum Int64/Word64 instances · 622b483c
    Jaro Reinders authored and Marge Bot's avatar Marge Bot committed
    This commits adds more performant Enum Int64 and Enum Word64 instances
    for 32-bit platforms, replacing the Integer-based implementation.
    
    These instances are a copy of the Enum Int and Enum Word instances with
    minimal changes to manipulate Int64 and Word64 instead.
    
    On i386 this yields a 1.5x performance increase and for the JavaScript
    back end it even yields a 5.6x speedup.
    
    Metric Decrease:
        T18964
    622b483c
  • Sylvain Henry's avatar
    JS: fix typos in constants (#23650) · c8bd7fa4
    Sylvain Henry authored and Marge Bot's avatar Marge Bot committed
    c8bd7fa4
  • Josh Meredith's avatar
    b9d5bfe9
  • Matthew Pickering's avatar
    ci: Pass -Werror when building hadrian in hadrian-ghc-in-ghci job · 28211215
    Matthew Pickering authored and Marge Bot's avatar Marge Bot committed
    Warnings when building Hadrian can end up cluttering the output of HLS,
    and we've had bug reports in the past about these warnings when building
    Hadrian. It would be nice to turn on -Werror on at least one build of
    Hadrian in CI to avoid a patch introducing warnings when building
    Hadrian.
    
    Fixes #23638
    28211215
  • Ben Gamari's avatar
    codeGen: Ensure that TSAN is aware of writeArray# write barriers · aca20a5d
    Ben Gamari authored and Marge Bot's avatar Marge Bot committed
    By using a proper release store instead of a fence.
    aca20a5d
  • Ben Gamari's avatar
    codeGen: Ensure that array reads have necessary barriers · 453c0531
    Ben Gamari authored and Marge Bot's avatar Marge Bot committed
    This was the cause of #23541.
    453c0531
  • Arnaud Spiwack's avatar
    Add test for #23550 · 93a0d089
    Arnaud Spiwack authored and Marge Bot's avatar Marge Bot committed
    93a0d089
  • Arnaud Spiwack's avatar
    Desugar non-recursive lets to non-recursive lets (take 2) · 6a2f4a20
    Arnaud Spiwack authored and Marge Bot's avatar Marge Bot committed
    This reverts commit 522bd584. And
    takes care of the case that I missed in my previous attempt. Namely
    the case of an AbsBinds with no type variables and no dictionary
    variable.
    
    Ironically, the comment explaining why non-recursive lets were
    desugared to recursive lets were pointing specifically at this case
    as the reason. I just failed to understand that it was until Simon PJ
    pointed it out to me.
    
    See #23550 for more discussion.
    6a2f4a20
  • Jade's avatar
    Expand documentation of List & Data.List · ff81d53f
    Jade authored and Marge Bot's avatar Marge Bot committed
    This commit aims to improve the documentation and examples
    of symbols exported from Data.List
    ff81d53f
  • Jade's avatar
    Improve documentation of Semigroup & Monoid · fa4e5913
    Jade authored and Marge Bot's avatar Marge Bot committed
    This commit aims to improve the documentation of various symbols
    exported from Data.Semigroup and Data.Monoid
    fa4e5913
  • Gergő Érdi's avatar
    e2c91bff
  • Gergő Érdi's avatar
    5ff82c73
Showing
with 483 additions and 541 deletions
...@@ -2,7 +2,7 @@ variables: ...@@ -2,7 +2,7 @@ variables:
GIT_SSL_NO_VERIFY: "1" GIT_SSL_NO_VERIFY: "1"
# Commit of ghc/ci-images repository from which to pull Docker images # Commit of ghc/ci-images repository from which to pull Docker images
DOCKER_REV: e0874d9716897188a8ba059d2245269ed541bf9d DOCKER_REV: a9c0f5efbe503c17f63070583b2d815e498acc68
# Sequential version number of all cached things. # Sequential version number of all cached things.
# Bump to invalidate GitLab CI cache. # Bump to invalidate GitLab CI cache.
...@@ -82,11 +82,9 @@ workflow: ...@@ -82,11 +82,9 @@ workflow:
# which versions of GHC to allow bootstrap with # which versions of GHC to allow bootstrap with
.bootstrap_matrix : &bootstrap_matrix .bootstrap_matrix : &bootstrap_matrix
matrix: matrix:
- GHC_VERSION: 9.2.5
DOCKER_IMAGE: "registry.gitlab.haskell.org/ghc/ci-images/x86_64-linux-deb10-ghc9_2:$DOCKER_REV"
- GHC_VERSION: 9.4.3 - GHC_VERSION: 9.4.3
DOCKER_IMAGE: "registry.gitlab.haskell.org/ghc/ci-images/x86_64-linux-deb10:$DOCKER_REV" DOCKER_IMAGE: "registry.gitlab.haskell.org/ghc/ci-images/x86_64-linux-deb10:$DOCKER_REV"
- GHC_VERSION: 9.6.1 - GHC_VERSION: 9.6.2
DOCKER_IMAGE: "registry.gitlab.haskell.org/ghc/ci-images/x86_64-linux-deb10-ghc9_6:$DOCKER_REV" DOCKER_IMAGE: "registry.gitlab.haskell.org/ghc/ci-images/x86_64-linux-deb10-ghc9_6:$DOCKER_REV"
# Allow linters to fail on draft MRs. # Allow linters to fail on draft MRs.
...@@ -278,6 +276,13 @@ lint-ci-config: ...@@ -278,6 +276,13 @@ lint-ci-config:
- nix run .gitlab/generate-ci#generate-jobs - nix run .gitlab/generate-ci#generate-jobs
# 1 if .gitlab/generate_jobs changed the output of the generated config # 1 if .gitlab/generate_jobs changed the output of the generated config
- nix shell nixpkgs#git -c git diff --exit-code - nix shell nixpkgs#git -c git diff --exit-code
# And run this to generate the .gitlab/jobs-metadata.json
- nix run .gitlab/generate-ci#generate-job-metadata
artifacts:
when: always
paths:
- .gitlab/jobs-metadata.json
- .gitlab/jobs.yaml
dependencies: [] dependencies: []
lint-submods: lint-submods:
...@@ -364,6 +369,9 @@ hadrian-ghc-in-ghci: ...@@ -364,6 +369,9 @@ hadrian-ghc-in-ghci:
- git clean -xdf && git submodule foreach git clean -xdf - git clean -xdf && git submodule foreach git clean -xdf
- .gitlab/ci.sh setup - .gitlab/ci.sh setup
- .gitlab/ci.sh configure - .gitlab/ci.sh configure
# Enable -Werror when building hadrian
- "echo 'package hadrian' > hadrian/cabal.project.local"
- "echo ' ghc-options: -Werror' >> hadrian/cabal.project.local"
# Load ghc-in-ghci then immediately exit and check the modules loaded # Load ghc-in-ghci then immediately exit and check the modules loaded
- echo ":q" | hadrian/ghci -j`mk/detect-cpu-count.sh`| tail -n2 | grep "Ok," - echo ":q" | hadrian/ghci -j`mk/detect-cpu-count.sh`| tail -n2 | grep "Ok,"
after_script: after_script:
...@@ -425,7 +433,8 @@ hadrian-multi: ...@@ -425,7 +433,8 @@ hadrian-multi:
paths: paths:
- cabal-cache - cabal-cache
rules: rules:
- if: '$CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/' - if: '$CI_MERGE_REQUEST_LABELS =~ /.*full-ci.*/'
- if: '$CI_MERGE_REQUEST_LABELS =~ /.*marge_bot_batch_merge_job.*/'
############################################################ ############################################################
# stack-hadrian-build # stack-hadrian-build
...@@ -504,7 +513,7 @@ doc-tarball: ...@@ -504,7 +513,7 @@ doc-tarball:
optional: true optional: true
- job: nightly-x86_64-windows-validate - job: nightly-x86_64-windows-validate
optional: true optional: true
- job: release-x86_64-windows-release+no_split_sections - job: release-x86_64-windows-release
optional: true optional: true
tags: tags:
...@@ -528,7 +537,7 @@ doc-tarball: ...@@ -528,7 +537,7 @@ doc-tarball:
|| mv "ghc-x86_64-linux-deb10-release.tar.xz" "$LINUX_BINDIST" \ || mv "ghc-x86_64-linux-deb10-release.tar.xz" "$LINUX_BINDIST" \
|| true || true
mv "ghc-x86_64-windows-validate.tar.xz" "$WINDOWS_BINDIST" \ mv "ghc-x86_64-windows-validate.tar.xz" "$WINDOWS_BINDIST" \
|| mv "ghc-x86_64-windows-release+no_split_sections.tar.xz" "$WINDOWS_BINDIST" \ || mv "ghc-x86_64-windows-release.tar.xz" "$WINDOWS_BINDIST" \
|| true || true
if [ ! -f "$LINUX_BINDIST" ]; then if [ ! -f "$LINUX_BINDIST" ]; then
echo "Error: $LINUX_BINDIST does not exist. Did the Debian 9 job fail?" echo "Error: $LINUX_BINDIST does not exist. Did the Debian 9 job fail?"
...@@ -596,6 +605,8 @@ source-tarball: ...@@ -596,6 +605,8 @@ source-tarball:
- if: $NIGHTLY - if: $NIGHTLY
- if: '$RELEASE_JOB == "yes"' - if: '$RELEASE_JOB == "yes"'
- if: '$CI_MERGE_REQUEST_LABELS =~ /.*test-bootstrap.*/' - if: '$CI_MERGE_REQUEST_LABELS =~ /.*test-bootstrap.*/'
- if: '$CI_MERGE_REQUEST_LABELS =~ /.*full-ci.*/'
- if: '$CI_MERGE_REQUEST_LABELS =~ /.*marge_bot_batch_merge_job.*/'
generate-hadrian-bootstrap-sources: generate-hadrian-bootstrap-sources:
stage: full-build stage: full-build
...@@ -614,6 +625,8 @@ generate-hadrian-bootstrap-sources: ...@@ -614,6 +625,8 @@ generate-hadrian-bootstrap-sources:
- if: $NIGHTLY - if: $NIGHTLY
- if: '$RELEASE_JOB == "yes"' - if: '$RELEASE_JOB == "yes"'
- if: '$CI_MERGE_REQUEST_LABELS =~ /.*test-bootstrap.*/' - if: '$CI_MERGE_REQUEST_LABELS =~ /.*test-bootstrap.*/'
- if: '$CI_MERGE_REQUEST_LABELS =~ /.*full-ci.*/'
- if: '$CI_MERGE_REQUEST_LABELS =~ /.*marge_bot_batch_merge_job.*/'
package-hadrian-bootstrap-sources: package-hadrian-bootstrap-sources:
...@@ -631,6 +644,8 @@ package-hadrian-bootstrap-sources: ...@@ -631,6 +644,8 @@ package-hadrian-bootstrap-sources:
- if: $NIGHTLY - if: $NIGHTLY
- if: '$RELEASE_JOB == "yes"' - if: '$RELEASE_JOB == "yes"'
- if: '$CI_MERGE_REQUEST_LABELS =~ /.*test-bootstrap.*/' - if: '$CI_MERGE_REQUEST_LABELS =~ /.*test-bootstrap.*/'
- if: '$CI_MERGE_REQUEST_LABELS =~ /.*full-ci.*/'
- if: '$CI_MERGE_REQUEST_LABELS =~ /.*marge_bot_batch_merge_job.*/'
test-bootstrap: test-bootstrap:
stage: full-build stage: full-build
...@@ -667,6 +682,8 @@ test-bootstrap: ...@@ -667,6 +682,8 @@ test-bootstrap:
rules: rules:
- if: $NIGHTLY - if: $NIGHTLY
- if: '$CI_MERGE_REQUEST_LABELS =~ /.*test-bootstrap.*/' - if: '$CI_MERGE_REQUEST_LABELS =~ /.*test-bootstrap.*/'
- if: '$CI_MERGE_REQUEST_LABELS =~ /.*full-ci.*/'
- if: '$CI_MERGE_REQUEST_LABELS =~ /.*marge_bot_batch_merge_job.*/'
- if: '$RELEASE_JOB == "yes"' - if: '$RELEASE_JOB == "yes"'
when: always when: always
variables: variables:
...@@ -823,7 +840,8 @@ perf-nofib: ...@@ -823,7 +840,8 @@ perf-nofib:
- if: $CI_MERGE_REQUEST_ID - if: $CI_MERGE_REQUEST_ID
- if: '$CI_COMMIT_BRANCH == "master"' - if: '$CI_COMMIT_BRANCH == "master"'
- if: '$CI_COMMIT_BRANCH =~ /ghc-[0.9]+\.[0-9]+/' - if: '$CI_COMMIT_BRANCH =~ /ghc-[0.9]+\.[0-9]+/'
- if: '$CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/' - if: '$CI_MERGE_REQUEST_LABELS =~ /.*full-ci.*/'
- if: '$CI_MERGE_REQUEST_LABELS =~ /.*marge_bot_batch_merge_job.*/'
tags: tags:
- x86_64-linux - x86_64-linux
before_script: before_script:
...@@ -890,7 +908,8 @@ perf: ...@@ -890,7 +908,8 @@ perf:
paths: paths:
- out - out
rules: rules:
- if: '$CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/' - if: '$CI_MERGE_REQUEST_LABELS =~ /.*full-ci.*/'
- if: '$CI_MERGE_REQUEST_LABELS =~ /.*marge_bot_batch_merge_job.*/'
############################################################ ############################################################
# ABI testing # ABI testing
...@@ -930,7 +949,8 @@ abi-test: ...@@ -930,7 +949,8 @@ abi-test:
paths: paths:
- out - out
rules: rules:
- if: '$CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/' - if: '$CI_MERGE_REQUEST_LABELS =~ /.*full-ci.*/'
- if: '$CI_MERGE_REQUEST_LABELS =~ /.*marge_bot_batch_merge_job.*/'
############################################################ ############################################################
......
cabal-version: 3.0
name: gen-ci
version: 0.1.0.0
build-type: Simple
common warnings
ghc-options: -Wall
executable gen_ci
import: warnings
main-is: gen_ci.hs
build-depends:
, aeson >=1.8.1
, base
, bytestring
, containers
default-language: Haskell2010
...@@ -556,7 +556,8 @@ instance ToJSON OnOffRules where ...@@ -556,7 +556,8 @@ instance ToJSON OnOffRules where
-- | A Rule corresponds to some condition which must be satisifed in order to -- | A Rule corresponds to some condition which must be satisifed in order to
-- run the job. -- run the job.
data Rule = FastCI -- ^ Run this job when the fast-ci label is set data Rule = FastCI -- ^ Run this job on all validate pipelines, all pipelines are enabled
-- by the "full-ci" label.
| ReleaseOnly -- ^ Only run this job in a release pipeline | ReleaseOnly -- ^ Only run this job in a release pipeline
| Nightly -- ^ Only run this job in the nightly pipeline | Nightly -- ^ Only run this job in the nightly pipeline
| LLVMBackend -- ^ Only run this job when the "LLVM backend" label is present | LLVMBackend -- ^ Only run this job when the "LLVM backend" label is present
...@@ -578,7 +579,7 @@ false = "\"disabled\" != \"disabled\"" ...@@ -578,7 +579,7 @@ false = "\"disabled\" != \"disabled\""
-- Convert the state of the rule into a string that gitlab understand. -- Convert the state of the rule into a string that gitlab understand.
ruleString :: OnOff -> Rule -> String ruleString :: OnOff -> Rule -> String
ruleString On FastCI = true ruleString On FastCI = true
ruleString Off FastCI = "$CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/" ruleString Off FastCI = "($CI_MERGE_REQUEST_LABELS =~ /.*full-ci.*/) || ($CI_MERGE_REQUEST_LABELS =~ /.*marge_bot_batch_merge_job.*/)"
ruleString On LLVMBackend = "$CI_MERGE_REQUEST_LABELS =~ /.*LLVM backend.*/" ruleString On LLVMBackend = "$CI_MERGE_REQUEST_LABELS =~ /.*LLVM backend.*/"
ruleString Off LLVMBackend = true ruleString Off LLVMBackend = true
ruleString On FreeBSDLabel = "$CI_MERGE_REQUEST_LABELS =~ /.*FreeBSD.*/" ruleString On FreeBSDLabel = "$CI_MERGE_REQUEST_LABELS =~ /.*FreeBSD.*/"
...@@ -767,17 +768,25 @@ delVariable k j = j { jobVariables = MonoidalMap $ Map.delete k $ unMonoidalMap ...@@ -767,17 +768,25 @@ delVariable k j = j { jobVariables = MonoidalMap $ Map.delete k $ unMonoidalMap
validate :: Arch -> Opsys -> BuildConfig -> NamedJob Job validate :: Arch -> Opsys -> BuildConfig -> NamedJob Job
validate = job validate = job
-- Nightly and release apply the FastCI configuration to all jobs so that they all run in
-- the pipeline (not conditional on the full-ci label)
nightlyRule :: Job -> Job
nightlyRule = addJobRule FastCI . addJobRule Nightly
releaseRule :: Job -> Job
releaseRule = addJobRule FastCI . addJobRule ReleaseOnly
-- | Make a normal nightly CI job -- | Make a normal nightly CI job
nightly :: Arch -> Opsys -> BuildConfig -> NamedJob Job nightly :: Arch -> Opsys -> BuildConfig -> NamedJob Job
nightly arch opsys bc = nightly arch opsys bc =
let NamedJob n j = job arch opsys bc let NamedJob n j = job arch opsys bc
in NamedJob { name = "nightly-" ++ n, jobInfo = addJobRule Nightly . keepArtifacts "8 weeks" . highCompression $ j} in NamedJob { name = "nightly-" ++ n, jobInfo = nightlyRule . keepArtifacts "8 weeks" . highCompression $ j}
-- | Make a normal release CI job -- | Make a normal release CI job
release :: Arch -> Opsys -> BuildConfig -> NamedJob Job release :: Arch -> Opsys -> BuildConfig -> NamedJob Job
release arch opsys bc = release arch opsys bc =
let NamedJob n j = job arch opsys (bc { buildFlavour = Release }) let NamedJob n j = job arch opsys (bc { buildFlavour = Release })
in NamedJob { name = "release-" ++ n, jobInfo = addJobRule ReleaseOnly . keepArtifacts "1 year" . ignorePerfFailures . useHashUnitIds . highCompression $ j} in NamedJob { name = "release-" ++ n, jobInfo = releaseRule . keepArtifacts "1 year" . ignorePerfFailures . useHashUnitIds . highCompression $ j}
-- Specific job modification functions -- Specific job modification functions
...@@ -806,6 +815,7 @@ useHashUnitIds :: Job -> Job ...@@ -806,6 +815,7 @@ useHashUnitIds :: Job -> Job
useHashUnitIds = addVariable "HADRIAN_ARGS" "--hash-unit-ids" useHashUnitIds = addVariable "HADRIAN_ARGS" "--hash-unit-ids"
-- | Mark the validate job to run in fast-ci mode -- | Mark the validate job to run in fast-ci mode
-- This is default way, to enable all jobs you have to apply the `full-ci` label.
fastCI :: JobGroup Job -> JobGroup Job fastCI :: JobGroup Job -> JobGroup Job
fastCI = modifyValidateJobs (addJobRule FastCI) fastCI = modifyValidateJobs (addJobRule FastCI)
...@@ -888,7 +898,7 @@ job_groups = ...@@ -888,7 +898,7 @@ job_groups =
[ disableValidate (standardBuilds Amd64 (Linux Debian10)) [ disableValidate (standardBuilds Amd64 (Linux Debian10))
, standardBuildsWithConfig Amd64 (Linux Debian10) dwarf , standardBuildsWithConfig Amd64 (Linux Debian10) dwarf
, validateBuilds Amd64 (Linux Debian10) nativeInt , validateBuilds Amd64 (Linux Debian10) nativeInt
, fastCI (validateBuilds Amd64 (Linux Debian10) unreg) , validateBuilds Amd64 (Linux Debian10) unreg
, fastCI (validateBuilds Amd64 (Linux Debian10) debug) , fastCI (validateBuilds Amd64 (Linux Debian10) debug)
, -- Nightly allowed to fail: #22520 , -- Nightly allowed to fail: #22520
modifyNightlyJobs allowFailure modifyNightlyJobs allowFailure
...@@ -907,16 +917,16 @@ job_groups = ...@@ -907,16 +917,16 @@ job_groups =
, disableValidate (standardBuildsWithConfig Amd64 (Linux Centos7) (splitSectionsBroken vanilla)) , disableValidate (standardBuildsWithConfig Amd64 (Linux Centos7) (splitSectionsBroken vanilla))
-- Fedora33 job is always built with perf so there's one job in the normal -- Fedora33 job is always built with perf so there's one job in the normal
-- validate pipeline which is built with perf. -- validate pipeline which is built with perf.
, standardBuildsWithConfig Amd64 (Linux Fedora33) releaseConfig , fastCI (standardBuildsWithConfig Amd64 (Linux Fedora33) releaseConfig)
-- This job is only for generating head.hackage docs -- This job is only for generating head.hackage docs
, hackage_doc_job (disableValidate (standardBuildsWithConfig Amd64 (Linux Fedora33) releaseConfig)) , hackage_doc_job (disableValidate (standardBuildsWithConfig Amd64 (Linux Fedora33) releaseConfig))
, disableValidate (standardBuildsWithConfig Amd64 (Linux Fedora33) dwarf) , disableValidate (standardBuildsWithConfig Amd64 (Linux Fedora33) dwarf)
, fastCI (standardBuildsWithConfig Amd64 Windows (splitSectionsBroken vanilla)) , fastCI (standardBuildsWithConfig Amd64 Windows vanilla)
, disableValidate (standardBuildsWithConfig Amd64 Windows (splitSectionsBroken nativeInt)) , disableValidate (standardBuildsWithConfig Amd64 Windows nativeInt)
, standardBuilds Amd64 Darwin , standardBuilds Amd64 Darwin
, allowFailureGroup (addValidateRule FreeBSDLabel (validateBuilds Amd64 FreeBSD13 vanilla)) , allowFailureGroup (addValidateRule FreeBSDLabel (validateBuilds Amd64 FreeBSD13 vanilla))
, standardBuilds AArch64 Darwin , fastCI (standardBuilds AArch64 Darwin)
, standardBuildsWithConfig AArch64 (Linux Debian10) (splitSectionsBroken vanilla) , fastCI (standardBuildsWithConfig AArch64 (Linux Debian10) (splitSectionsBroken vanilla))
, disableValidate (validateBuilds AArch64 (Linux Debian10) llvm) , disableValidate (validateBuilds AArch64 (Linux Debian10) llvm)
, standardBuildsWithConfig I386 (Linux Debian10) (splitSectionsBroken vanilla) , standardBuildsWithConfig I386 (Linux Debian10) (splitSectionsBroken vanilla)
-- Fully static build, in theory usable on any linux distribution. -- Fully static build, in theory usable on any linux distribution.
......
File moved
...@@ -37,7 +37,7 @@ ...@@ -37,7 +37,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"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" "when": "on_success"
} }
], ],
...@@ -102,7 +102,7 @@ ...@@ -102,7 +102,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"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" "when": "on_success"
} }
], ],
...@@ -163,7 +163,7 @@ ...@@ -163,7 +163,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")", "if": "(($CI_MERGE_REQUEST_LABELS =~ /.*full-ci.*/) || ($CI_MERGE_REQUEST_LABELS =~ /.*marge_bot_batch_merge_job.*/)) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success" "when": "on_success"
} }
], ],
...@@ -224,7 +224,7 @@ ...@@ -224,7 +224,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")", "if": "(\"true\" == \"true\") && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success" "when": "on_success"
} }
], ],
...@@ -290,7 +290,7 @@ ...@@ -290,7 +290,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")", "if": "(\"true\" == \"true\") && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success" "when": "on_success"
} }
], ],
...@@ -352,7 +352,7 @@ ...@@ -352,7 +352,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")", "if": "(\"true\" == \"true\") && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success" "when": "on_success"
} }
], ],
...@@ -414,7 +414,7 @@ ...@@ -414,7 +414,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")", "if": "(\"true\" == \"true\") && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success" "when": "on_success"
} }
], ],
...@@ -476,7 +476,7 @@ ...@@ -476,7 +476,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")", "if": "(\"true\" == \"true\") && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success" "when": "on_success"
} }
], ],
...@@ -545,7 +545,7 @@ ...@@ -545,7 +545,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")", "if": "(\"true\" == \"true\") && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success" "when": "on_success"
} }
], ],
...@@ -609,7 +609,7 @@ ...@@ -609,7 +609,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")", "if": "(\"true\" == \"true\") && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success" "when": "on_success"
} }
], ],
...@@ -674,7 +674,7 @@ ...@@ -674,7 +674,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")", "if": "(\"true\" == \"true\") && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success" "when": "on_success"
} }
], ],
...@@ -739,7 +739,7 @@ ...@@ -739,7 +739,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")", "if": "(\"true\" == \"true\") && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success" "when": "on_success"
} }
], ],
...@@ -804,7 +804,7 @@ ...@@ -804,7 +804,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")", "if": "(\"true\" == \"true\") && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success" "when": "on_success"
} }
], ],
...@@ -868,7 +868,7 @@ ...@@ -868,7 +868,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")", "if": "(\"true\" == \"true\") && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success" "when": "on_success"
} }
], ],
...@@ -932,7 +932,7 @@ ...@@ -932,7 +932,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")", "if": "(\"true\" == \"true\") && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success" "when": "on_success"
} }
], ],
...@@ -996,7 +996,7 @@ ...@@ -996,7 +996,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")", "if": "(\"true\" == \"true\") && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success" "when": "on_success"
} }
], ],
...@@ -1059,7 +1059,7 @@ ...@@ -1059,7 +1059,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")", "if": "(\"true\" == \"true\") && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success" "when": "on_success"
} }
], ],
...@@ -1121,7 +1121,7 @@ ...@@ -1121,7 +1121,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")", "if": "(\"true\" == \"true\") && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success" "when": "on_success"
} }
], ],
...@@ -1183,7 +1183,7 @@ ...@@ -1183,7 +1183,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")", "if": "(\"true\" == \"true\") && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success" "when": "on_success"
} }
], ],
...@@ -1246,7 +1246,7 @@ ...@@ -1246,7 +1246,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")", "if": "(\"true\" == \"true\") && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success" "when": "on_success"
} }
], ],
...@@ -1308,7 +1308,7 @@ ...@@ -1308,7 +1308,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")", "if": "(\"true\" == \"true\") && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success" "when": "on_success"
} }
], ],
...@@ -1370,7 +1370,7 @@ ...@@ -1370,7 +1370,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")", "if": "(\"true\" == \"true\") && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success" "when": "on_success"
} }
], ],
...@@ -1432,7 +1432,7 @@ ...@@ -1432,7 +1432,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")", "if": "(\"true\" == \"true\") && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success" "when": "on_success"
} }
], ],
...@@ -1494,7 +1494,7 @@ ...@@ -1494,7 +1494,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")", "if": "(\"true\" == \"true\") && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success" "when": "on_success"
} }
], ],
...@@ -1558,7 +1558,7 @@ ...@@ -1558,7 +1558,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")", "if": "(\"true\" == \"true\") && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success" "when": "on_success"
} }
], ],
...@@ -1622,7 +1622,7 @@ ...@@ -1622,7 +1622,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")", "if": "(\"true\" == \"true\") && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success" "when": "on_success"
} }
], ],
...@@ -1687,7 +1687,7 @@ ...@@ -1687,7 +1687,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")", "if": "(\"true\" == \"true\") && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success" "when": "on_success"
} }
], ],
...@@ -1749,7 +1749,7 @@ ...@@ -1749,7 +1749,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")", "if": "(\"true\" == \"true\") && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success" "when": "on_success"
} }
], ],
...@@ -1811,7 +1811,7 @@ ...@@ -1811,7 +1811,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")", "if": "(\"true\" == \"true\") && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success" "when": "on_success"
} }
], ],
...@@ -1873,7 +1873,7 @@ ...@@ -1873,7 +1873,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")", "if": "(\"true\" == \"true\") && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success" "when": "on_success"
} }
], ],
...@@ -1937,7 +1937,7 @@ ...@@ -1937,7 +1937,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")", "if": "(\"true\" == \"true\") && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success" "when": "on_success"
} }
], ],
...@@ -2002,7 +2002,7 @@ ...@@ -2002,7 +2002,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")", "if": "(\"true\" == \"true\") && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success" "when": "on_success"
} }
], ],
...@@ -2066,7 +2066,7 @@ ...@@ -2066,7 +2066,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")", "if": "(\"true\" == \"true\") && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success" "when": "on_success"
} }
], ],
...@@ -2129,7 +2129,7 @@ ...@@ -2129,7 +2129,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")", "if": "(\"true\" == \"true\") && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success" "when": "on_success"
} }
], ],
...@@ -2191,7 +2191,7 @@ ...@@ -2191,7 +2191,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")", "if": "(\"true\" == \"true\") && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success" "when": "on_success"
} }
], ],
...@@ -2249,7 +2249,7 @@ ...@@ -2249,7 +2249,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")", "if": "(\"true\" == \"true\") && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success" "when": "on_success"
} }
], ],
...@@ -2311,7 +2311,7 @@ ...@@ -2311,7 +2311,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")", "if": "(\"true\" == \"true\") && ($RELEASE_JOB != \"yes\") && ($NIGHTLY) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success" "when": "on_success"
} }
], ],
...@@ -2377,7 +2377,7 @@ ...@@ -2377,7 +2377,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"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" "when": "on_success"
} }
], ],
...@@ -2444,7 +2444,7 @@ ...@@ -2444,7 +2444,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"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" "when": "on_success"
} }
], ],
...@@ -2508,7 +2508,7 @@ ...@@ -2508,7 +2508,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"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" "when": "on_success"
} }
], ],
...@@ -2572,7 +2572,7 @@ ...@@ -2572,7 +2572,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"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" "when": "on_success"
} }
], ],
...@@ -2642,7 +2642,7 @@ ...@@ -2642,7 +2642,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"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" "when": "on_success"
} }
], ],
...@@ -2708,7 +2708,7 @@ ...@@ -2708,7 +2708,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"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" "when": "on_success"
} }
], ],
...@@ -2774,7 +2774,7 @@ ...@@ -2774,7 +2774,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"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" "when": "on_success"
} }
], ],
...@@ -2840,7 +2840,7 @@ ...@@ -2840,7 +2840,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"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" "when": "on_success"
} }
], ],
...@@ -2904,7 +2904,7 @@ ...@@ -2904,7 +2904,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"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" "when": "on_success"
} }
], ],
...@@ -2968,7 +2968,7 @@ ...@@ -2968,7 +2968,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"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" "when": "on_success"
} }
], ],
...@@ -3032,7 +3032,7 @@ ...@@ -3032,7 +3032,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"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" "when": "on_success"
} }
], ],
...@@ -3096,7 +3096,7 @@ ...@@ -3096,7 +3096,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"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" "when": "on_success"
} }
], ],
...@@ -3160,7 +3160,7 @@ ...@@ -3160,7 +3160,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"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" "when": "on_success"
} }
], ],
...@@ -3224,7 +3224,7 @@ ...@@ -3224,7 +3224,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"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" "when": "on_success"
} }
], ],
...@@ -3290,7 +3290,7 @@ ...@@ -3290,7 +3290,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"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" "when": "on_success"
} }
], ],
...@@ -3356,7 +3356,7 @@ ...@@ -3356,7 +3356,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"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" "when": "on_success"
} }
], ],
...@@ -3422,7 +3422,7 @@ ...@@ -3422,7 +3422,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"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" "when": "on_success"
} }
], ],
...@@ -3486,7 +3486,7 @@ ...@@ -3486,7 +3486,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"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" "when": "on_success"
} }
], ],
...@@ -3550,7 +3550,7 @@ ...@@ -3550,7 +3550,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"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" "when": "on_success"
} }
], ],
...@@ -3577,7 +3577,7 @@ ...@@ -3577,7 +3577,7 @@
"XZ_OPT": "-9" "XZ_OPT": "-9"
} }
}, },
"release-x86_64-windows-int_native-release+no_split_sections": { "release-x86_64-windows-int_native-release": {
"after_script": [ "after_script": [
"bash .gitlab/ci.sh save_cache", "bash .gitlab/ci.sh save_cache",
"bash .gitlab/ci.sh save_test_output", "bash .gitlab/ci.sh save_test_output",
...@@ -3587,7 +3587,7 @@ ...@@ -3587,7 +3587,7 @@
"artifacts": { "artifacts": {
"expire_in": "1 year", "expire_in": "1 year",
"paths": [ "paths": [
"ghc-x86_64-windows-int_native-release+no_split_sections.tar.xz", "ghc-x86_64-windows-int_native-release.tar.xz",
"junit.xml", "junit.xml",
"unexpected-test-output.tar.gz" "unexpected-test-output.tar.gz"
], ],
...@@ -3610,7 +3610,7 @@ ...@@ -3610,7 +3610,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"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" "when": "on_success"
} }
], ],
...@@ -3626,8 +3626,8 @@ ...@@ -3626,8 +3626,8 @@
], ],
"variables": { "variables": {
"BIGNUM_BACKEND": "native", "BIGNUM_BACKEND": "native",
"BIN_DIST_NAME": "ghc-x86_64-windows-int_native-release+no_split_sections", "BIN_DIST_NAME": "ghc-x86_64-windows-int_native-release",
"BUILD_FLAVOUR": "release+no_split_sections", "BUILD_FLAVOUR": "release",
"CABAL_INSTALL_VERSION": "3.8.1.0", "CABAL_INSTALL_VERSION": "3.8.1.0",
"CONFIGURE_ARGS": "", "CONFIGURE_ARGS": "",
"GHC_VERSION": "9.4.3", "GHC_VERSION": "9.4.3",
...@@ -3636,11 +3636,11 @@ ...@@ -3636,11 +3636,11 @@
"LANG": "en_US.UTF-8", "LANG": "en_US.UTF-8",
"MSYSTEM": "CLANG64", "MSYSTEM": "CLANG64",
"RUNTEST_ARGS": "", "RUNTEST_ARGS": "",
"TEST_ENV": "x86_64-windows-int_native-release+no_split_sections", "TEST_ENV": "x86_64-windows-int_native-release",
"XZ_OPT": "-9" "XZ_OPT": "-9"
} }
}, },
"release-x86_64-windows-release+no_split_sections": { "release-x86_64-windows-release": {
"after_script": [ "after_script": [
"bash .gitlab/ci.sh save_cache", "bash .gitlab/ci.sh save_cache",
"bash .gitlab/ci.sh save_test_output", "bash .gitlab/ci.sh save_test_output",
...@@ -3650,7 +3650,7 @@ ...@@ -3650,7 +3650,7 @@
"artifacts": { "artifacts": {
"expire_in": "1 year", "expire_in": "1 year",
"paths": [ "paths": [
"ghc-x86_64-windows-release+no_split_sections.tar.xz", "ghc-x86_64-windows-release.tar.xz",
"junit.xml", "junit.xml",
"unexpected-test-output.tar.gz" "unexpected-test-output.tar.gz"
], ],
...@@ -3673,7 +3673,7 @@ ...@@ -3673,7 +3673,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB == \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"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" "when": "on_success"
} }
], ],
...@@ -3689,8 +3689,8 @@ ...@@ -3689,8 +3689,8 @@
], ],
"variables": { "variables": {
"BIGNUM_BACKEND": "gmp", "BIGNUM_BACKEND": "gmp",
"BIN_DIST_NAME": "ghc-x86_64-windows-release+no_split_sections", "BIN_DIST_NAME": "ghc-x86_64-windows-release",
"BUILD_FLAVOUR": "release+no_split_sections", "BUILD_FLAVOUR": "release",
"CABAL_INSTALL_VERSION": "3.8.1.0", "CABAL_INSTALL_VERSION": "3.8.1.0",
"CONFIGURE_ARGS": "", "CONFIGURE_ARGS": "",
"GHC_VERSION": "9.4.3", "GHC_VERSION": "9.4.3",
...@@ -3699,7 +3699,7 @@ ...@@ -3699,7 +3699,7 @@
"LANG": "en_US.UTF-8", "LANG": "en_US.UTF-8",
"MSYSTEM": "CLANG64", "MSYSTEM": "CLANG64",
"RUNTEST_ARGS": "", "RUNTEST_ARGS": "",
"TEST_ENV": "x86_64-windows-release+no_split_sections", "TEST_ENV": "x86_64-windows-release",
"XZ_OPT": "-9" "XZ_OPT": "-9"
} }
}, },
...@@ -3740,7 +3740,7 @@ ...@@ -3740,7 +3740,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")", "if": "(($CI_MERGE_REQUEST_LABELS =~ /.*full-ci.*/) || ($CI_MERGE_REQUEST_LABELS =~ /.*marge_bot_batch_merge_job.*/)) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success" "when": "on_success"
} }
], ],
...@@ -3808,7 +3808,7 @@ ...@@ -3808,7 +3808,7 @@
], ],
"rules": [ "rules": [
{ {
"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\")", "if": "(($CI_MERGE_REQUEST_LABELS =~ /.*full-ci.*/) || ($CI_MERGE_REQUEST_LABELS =~ /.*marge_bot_batch_merge_job.*/)) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && ($CI_MERGE_REQUEST_LABELS =~ /.*FreeBSD.*/) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success" "when": "on_success"
} }
], ],
...@@ -3871,7 +3871,7 @@ ...@@ -3871,7 +3871,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")", "if": "(($CI_MERGE_REQUEST_LABELS =~ /.*full-ci.*/) || ($CI_MERGE_REQUEST_LABELS =~ /.*marge_bot_batch_merge_job.*/)) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success" "when": "on_success"
} }
], ],
...@@ -3935,7 +3935,7 @@ ...@@ -3935,7 +3935,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")", "if": "(($CI_MERGE_REQUEST_LABELS =~ /.*full-ci.*/) || ($CI_MERGE_REQUEST_LABELS =~ /.*marge_bot_batch_merge_job.*/)) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success" "when": "on_success"
} }
], ],
...@@ -3999,7 +3999,7 @@ ...@@ -3999,7 +3999,7 @@
"rules": [ "rules": [
{ {
"allow_failure": true, "allow_failure": true,
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")", "if": "(($CI_MERGE_REQUEST_LABELS =~ /.*full-ci.*/) || ($CI_MERGE_REQUEST_LABELS =~ /.*marge_bot_batch_merge_job.*/)) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "manual" "when": "manual"
} }
], ],
...@@ -4063,7 +4063,7 @@ ...@@ -4063,7 +4063,7 @@
"rules": [ "rules": [
{ {
"allow_failure": true, "allow_failure": true,
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")", "if": "(($CI_MERGE_REQUEST_LABELS =~ /.*full-ci.*/) || ($CI_MERGE_REQUEST_LABELS =~ /.*marge_bot_batch_merge_job.*/)) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "manual" "when": "manual"
} }
], ],
...@@ -4126,7 +4126,7 @@ ...@@ -4126,7 +4126,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")", "if": "(($CI_MERGE_REQUEST_LABELS =~ /.*full-ci.*/) || ($CI_MERGE_REQUEST_LABELS =~ /.*marge_bot_batch_merge_job.*/)) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success" "when": "on_success"
} }
], ],
...@@ -4188,7 +4188,7 @@ ...@@ -4188,7 +4188,7 @@
"rules": [ "rules": [
{ {
"allow_failure": true, "allow_failure": true,
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")", "if": "(($CI_MERGE_REQUEST_LABELS =~ /.*full-ci.*/) || ($CI_MERGE_REQUEST_LABELS =~ /.*marge_bot_batch_merge_job.*/)) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "manual" "when": "manual"
} }
], ],
...@@ -4311,7 +4311,7 @@ ...@@ -4311,7 +4311,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "(\"true\" == \"true\") && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")", "if": "(($CI_MERGE_REQUEST_LABELS =~ /.*full-ci.*/) || ($CI_MERGE_REQUEST_LABELS =~ /.*marge_bot_batch_merge_job.*/)) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success" "when": "on_success"
} }
], ],
...@@ -4372,7 +4372,7 @@ ...@@ -4372,7 +4372,7 @@
], ],
"rules": [ "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\")", "if": "(($CI_MERGE_REQUEST_LABELS =~ /.*full-ci.*/) || ($CI_MERGE_REQUEST_LABELS =~ /.*marge_bot_batch_merge_job.*/)) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && ($CI_MERGE_REQUEST_LABELS =~ /.*IPE.*/) && (\"true\" == \"true\")",
"when": "on_success" "when": "on_success"
} }
], ],
...@@ -4433,7 +4433,7 @@ ...@@ -4433,7 +4433,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")", "if": "(($CI_MERGE_REQUEST_LABELS =~ /.*full-ci.*/) || ($CI_MERGE_REQUEST_LABELS =~ /.*marge_bot_batch_merge_job.*/)) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success" "when": "on_success"
} }
], ],
...@@ -4494,7 +4494,7 @@ ...@@ -4494,7 +4494,7 @@
], ],
"rules": [ "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\") && (\"true\" == \"true\")", "if": "(($CI_MERGE_REQUEST_LABELS =~ /.*full-ci.*/) || ($CI_MERGE_REQUEST_LABELS =~ /.*marge_bot_batch_merge_job.*/)) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && ($CI_MERGE_REQUEST_LABELS =~ /.*LLVM backend.*/) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success" "when": "on_success"
} }
], ],
...@@ -4556,7 +4556,7 @@ ...@@ -4556,7 +4556,7 @@
"rules": [ "rules": [
{ {
"allow_failure": true, "allow_failure": true,
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")", "if": "(($CI_MERGE_REQUEST_LABELS =~ /.*full-ci.*/) || ($CI_MERGE_REQUEST_LABELS =~ /.*marge_bot_batch_merge_job.*/)) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "manual" "when": "manual"
} }
], ],
...@@ -4619,7 +4619,7 @@ ...@@ -4619,7 +4619,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")", "if": "(($CI_MERGE_REQUEST_LABELS =~ /.*full-ci.*/) || ($CI_MERGE_REQUEST_LABELS =~ /.*marge_bot_batch_merge_job.*/)) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success" "when": "on_success"
} }
], ],
...@@ -4682,7 +4682,7 @@ ...@@ -4682,7 +4682,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")", "if": "(($CI_MERGE_REQUEST_LABELS =~ /.*full-ci.*/) || ($CI_MERGE_REQUEST_LABELS =~ /.*marge_bot_batch_merge_job.*/)) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success" "when": "on_success"
} }
], ],
...@@ -4746,7 +4746,7 @@ ...@@ -4746,7 +4746,7 @@
], ],
"rules": [ "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\") && (\"true\" == \"true\")", "if": "(($CI_MERGE_REQUEST_LABELS =~ /.*full-ci.*/) || ($CI_MERGE_REQUEST_LABELS =~ /.*marge_bot_batch_merge_job.*/)) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"true\" == \"true\") && ($CI_MERGE_REQUEST_LABELS =~ /.*non-moving GC.*/) && (\"true\" == \"true\") && (\"true\" == \"true\")",
"when": "on_success" "when": "on_success"
} }
], ],
...@@ -4807,7 +4807,7 @@ ...@@ -4807,7 +4807,7 @@
], ],
"rules": [ "rules": [
{ {
"if": "($CI_MERGE_REQUEST_LABELS !~ /.*fast-ci.*/) && ($RELEASE_JOB != \"yes\") && ($NIGHTLY == null) && (\"true\" == \"true\") && (\"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" "when": "on_success"
} }
], ],
......
...@@ -9,7 +9,7 @@ Please take a few moments to address the following points: ...@@ -9,7 +9,7 @@ Please take a few moments to address the following points:
* [ ] if your MR may break existing programs (e.g. touches `base` or causes the * [ ] if your MR may break existing programs (e.g. touches `base` or causes the
compiler to reject programs), please describe the expected breakage and add compiler to reject programs), please describe the expected breakage and add
the ~"user facing" label. This will run ghc/head.hackage> to characterise the ~"user-facing" label. This will run ghc/head.hackage> to characterise
the effect of your change on Hackage. the effect of your change on Hackage.
* [ ] ensure that your commits are either individually buildable or squashed * [ ] ensure that your commits are either individually buildable or squashed
* [ ] ensure that your commit messages describe *what they do* * [ ] ensure that your commit messages describe *what they do*
...@@ -25,6 +25,10 @@ If you have any questions don't hesitate to open your merge request and inquire ...@@ -25,6 +25,10 @@ If you have any questions don't hesitate to open your merge request and inquire
in a comment. If your patch isn't quite done yet please do add prefix your MR in a comment. If your patch isn't quite done yet please do add prefix your MR
title with `WIP:`. title with `WIP:`.
By default a minimal validation pipeline is run on each merge request, the ~full-ci
label can be applied to perform additional validation checks if your MR affects a more
unusual configuration.
Once your change is ready please remove the `WIP:` tag and wait for review. If Once your change is ready please remove the `WIP:` tag and wait for review. If
no one has offerred review in a few days then please leave a comment mentioning no one has offerred review in a few days then please leave a comment mentioning
@triagers and apply the ~"Blocked on Review" label. @triagers and apply the ~"Blocked on Review" label.
......
...@@ -716,14 +716,6 @@ ltTag_RDR = nameRdrName ordLTDataConName ...@@ -716,14 +716,6 @@ ltTag_RDR = nameRdrName ordLTDataConName
eqTag_RDR = nameRdrName ordEQDataConName eqTag_RDR = nameRdrName ordEQDataConName
gtTag_RDR = nameRdrName ordGTDataConName gtTag_RDR = nameRdrName ordGTDataConName
eqClass_RDR, numClass_RDR, ordClass_RDR, enumClass_RDR, monadClass_RDR
:: RdrName
eqClass_RDR = nameRdrName eqClassName
numClass_RDR = nameRdrName numClassName
ordClass_RDR = nameRdrName ordClassName
enumClass_RDR = nameRdrName enumClassName
monadClass_RDR = nameRdrName monadClassName
map_RDR, append_RDR :: RdrName map_RDR, append_RDR :: RdrName
map_RDR = nameRdrName mapName map_RDR = nameRdrName mapName
append_RDR = nameRdrName appendName append_RDR = nameRdrName appendName
...@@ -750,41 +742,10 @@ enumFromTo_RDR = nameRdrName enumFromToName ...@@ -750,41 +742,10 @@ enumFromTo_RDR = nameRdrName enumFromToName
enumFromThen_RDR = nameRdrName enumFromThenName enumFromThen_RDR = nameRdrName enumFromThenName
enumFromThenTo_RDR = nameRdrName enumFromThenToName enumFromThenTo_RDR = nameRdrName enumFromThenToName
ratioDataCon_RDR, integerAdd_RDR, integerMul_RDR :: RdrName times_RDR, plus_RDR :: RdrName
ratioDataCon_RDR = nameRdrName ratioDataConName
integerAdd_RDR = nameRdrName integerAddName
integerMul_RDR = nameRdrName integerMulName
ioDataCon_RDR :: RdrName
ioDataCon_RDR = nameRdrName ioDataConName
newStablePtr_RDR :: RdrName
newStablePtr_RDR = nameRdrName newStablePtrName
bindIO_RDR, returnIO_RDR :: RdrName
bindIO_RDR = nameRdrName bindIOName
returnIO_RDR = nameRdrName returnIOName
fromInteger_RDR, fromRational_RDR, minus_RDR, times_RDR, plus_RDR :: RdrName
fromInteger_RDR = nameRdrName fromIntegerName
fromRational_RDR = nameRdrName fromRationalName
minus_RDR = nameRdrName minusName
times_RDR = varQual_RDR gHC_NUM (fsLit "*") times_RDR = varQual_RDR gHC_NUM (fsLit "*")
plus_RDR = varQual_RDR gHC_NUM (fsLit "+") plus_RDR = varQual_RDR gHC_NUM (fsLit "+")
toInteger_RDR, toRational_RDR, fromIntegral_RDR :: RdrName
toInteger_RDR = nameRdrName toIntegerName
toRational_RDR = nameRdrName toRationalName
fromIntegral_RDR = nameRdrName fromIntegralName
fromString_RDR :: RdrName
fromString_RDR = nameRdrName fromStringName
fromList_RDR, fromListN_RDR, toList_RDR :: RdrName
fromList_RDR = nameRdrName fromListName
fromListN_RDR = nameRdrName fromListNName
toList_RDR = nameRdrName toListName
compose_RDR :: RdrName compose_RDR :: RdrName
compose_RDR = varQual_RDR gHC_BASE (fsLit ".") compose_RDR = varQual_RDR gHC_BASE (fsLit ".")
......
...@@ -47,6 +47,7 @@ templateHaskellNames = [ ...@@ -47,6 +47,7 @@ templateHaskellNames = [
litPName, varPName, tupPName, unboxedTupPName, unboxedSumPName, litPName, varPName, tupPName, unboxedTupPName, unboxedSumPName,
conPName, tildePName, bangPName, infixPName, conPName, tildePName, bangPName, infixPName,
asPName, wildPName, recPName, listPName, sigPName, viewPName, asPName, wildPName, recPName, listPName, sigPName, viewPName,
typePName,
-- FieldPat -- FieldPat
fieldPatName, fieldPatName,
-- Match -- Match
...@@ -61,6 +62,7 @@ templateHaskellNames = [ ...@@ -61,6 +62,7 @@ templateHaskellNames = [
fromEName, fromThenEName, fromToEName, fromThenToEName, fromEName, fromThenEName, fromToEName, fromThenToEName,
listEName, sigEName, recConEName, recUpdEName, staticEName, unboundVarEName, listEName, sigEName, recConEName, recUpdEName, staticEName, unboundVarEName,
labelEName, implicitParamVarEName, getFieldEName, projectionEName, labelEName, implicitParamVarEName, getFieldEName, projectionEName,
typeEName,
-- FieldExp -- FieldExp
fieldExpName, fieldExpName,
-- Body -- Body
...@@ -268,7 +270,7 @@ charPrimLName = libFun (fsLit "charPrimL") charPrimLIdKey ...@@ -268,7 +270,7 @@ charPrimLName = libFun (fsLit "charPrimL") charPrimLIdKey
-- data Pat = ... -- data Pat = ...
litPName, varPName, tupPName, unboxedTupPName, unboxedSumPName, conPName, litPName, varPName, tupPName, unboxedTupPName, unboxedSumPName, conPName,
infixPName, tildePName, bangPName, asPName, wildPName, recPName, listPName, infixPName, tildePName, bangPName, asPName, wildPName, recPName, listPName,
sigPName, viewPName :: Name sigPName, viewPName, typePName :: Name
litPName = libFun (fsLit "litP") litPIdKey litPName = libFun (fsLit "litP") litPIdKey
varPName = libFun (fsLit "varP") varPIdKey varPName = libFun (fsLit "varP") varPIdKey
tupPName = libFun (fsLit "tupP") tupPIdKey tupPName = libFun (fsLit "tupP") tupPIdKey
...@@ -284,6 +286,7 @@ recPName = libFun (fsLit "recP") recPIdKey ...@@ -284,6 +286,7 @@ recPName = libFun (fsLit "recP") recPIdKey
listPName = libFun (fsLit "listP") listPIdKey listPName = libFun (fsLit "listP") listPIdKey
sigPName = libFun (fsLit "sigP") sigPIdKey sigPName = libFun (fsLit "sigP") sigPIdKey
viewPName = libFun (fsLit "viewP") viewPIdKey viewPName = libFun (fsLit "viewP") viewPIdKey
typePName = libFun (fsLit "typeP") typePIdKey
-- type FieldPat = ... -- type FieldPat = ...
fieldPatName :: Name fieldPatName :: Name
...@@ -302,7 +305,7 @@ varEName, conEName, litEName, appEName, appTypeEName, infixEName, infixAppName, ...@@ -302,7 +305,7 @@ varEName, conEName, litEName, appEName, appTypeEName, infixEName, infixAppName,
sectionLName, sectionRName, lamEName, lamCaseEName, lamCasesEName, tupEName, sectionLName, sectionRName, lamEName, lamCaseEName, lamCasesEName, tupEName,
unboxedTupEName, unboxedSumEName, condEName, multiIfEName, letEName, unboxedTupEName, unboxedSumEName, condEName, multiIfEName, letEName,
caseEName, doEName, mdoEName, compEName, staticEName, unboundVarEName, caseEName, doEName, mdoEName, compEName, staticEName, unboundVarEName,
labelEName, implicitParamVarEName, getFieldEName, projectionEName :: Name labelEName, implicitParamVarEName, getFieldEName, projectionEName, typeEName :: Name
varEName = libFun (fsLit "varE") varEIdKey varEName = libFun (fsLit "varE") varEIdKey
conEName = libFun (fsLit "conE") conEIdKey conEName = libFun (fsLit "conE") conEIdKey
litEName = libFun (fsLit "litE") litEIdKey litEName = libFun (fsLit "litE") litEIdKey
...@@ -343,6 +346,7 @@ labelEName = libFun (fsLit "labelE") labelEIdKey ...@@ -343,6 +346,7 @@ labelEName = libFun (fsLit "labelE") labelEIdKey
implicitParamVarEName = libFun (fsLit "implicitParamVarE") implicitParamVarEIdKey implicitParamVarEName = libFun (fsLit "implicitParamVarE") implicitParamVarEIdKey
getFieldEName = libFun (fsLit "getFieldE") getFieldEIdKey getFieldEName = libFun (fsLit "getFieldE") getFieldEIdKey
projectionEName = libFun (fsLit "projectionE") projectionEIdKey projectionEName = libFun (fsLit "projectionE") projectionEIdKey
typeEName = libFun (fsLit "typeE") typeEIdKey
-- type FieldExp = ... -- type FieldExp = ...
fieldExpName :: Name fieldExpName :: Name
...@@ -808,7 +812,7 @@ liftStringIdKey = mkPreludeMiscIdUnique 230 ...@@ -808,7 +812,7 @@ liftStringIdKey = mkPreludeMiscIdUnique 230
-- data Pat = ... -- data Pat = ...
litPIdKey, varPIdKey, tupPIdKey, unboxedTupPIdKey, unboxedSumPIdKey, conPIdKey, litPIdKey, varPIdKey, tupPIdKey, unboxedTupPIdKey, unboxedSumPIdKey, conPIdKey,
infixPIdKey, tildePIdKey, bangPIdKey, asPIdKey, wildPIdKey, recPIdKey, infixPIdKey, tildePIdKey, bangPIdKey, asPIdKey, wildPIdKey, recPIdKey,
listPIdKey, sigPIdKey, viewPIdKey :: Unique listPIdKey, sigPIdKey, viewPIdKey, typePIdKey :: Unique
litPIdKey = mkPreludeMiscIdUnique 240 litPIdKey = mkPreludeMiscIdUnique 240
varPIdKey = mkPreludeMiscIdUnique 241 varPIdKey = mkPreludeMiscIdUnique 241
tupPIdKey = mkPreludeMiscIdUnique 242 tupPIdKey = mkPreludeMiscIdUnique 242
...@@ -824,6 +828,7 @@ recPIdKey = mkPreludeMiscIdUnique 251 ...@@ -824,6 +828,7 @@ recPIdKey = mkPreludeMiscIdUnique 251
listPIdKey = mkPreludeMiscIdUnique 252 listPIdKey = mkPreludeMiscIdUnique 252
sigPIdKey = mkPreludeMiscIdUnique 253 sigPIdKey = mkPreludeMiscIdUnique 253
viewPIdKey = mkPreludeMiscIdUnique 254 viewPIdKey = mkPreludeMiscIdUnique 254
typePIdKey = mkPreludeMiscIdUnique 255
-- type FieldPat = ... -- type FieldPat = ...
fieldPatIdKey :: Unique fieldPatIdKey :: Unique
...@@ -846,7 +851,7 @@ varEIdKey, conEIdKey, litEIdKey, appEIdKey, appTypeEIdKey, infixEIdKey, ...@@ -846,7 +851,7 @@ varEIdKey, conEIdKey, litEIdKey, appEIdKey, appTypeEIdKey, infixEIdKey,
fromEIdKey, fromThenEIdKey, fromToEIdKey, fromThenToEIdKey, fromEIdKey, fromThenEIdKey, fromToEIdKey, fromThenToEIdKey,
listEIdKey, sigEIdKey, recConEIdKey, recUpdEIdKey, staticEIdKey, listEIdKey, sigEIdKey, recConEIdKey, recUpdEIdKey, staticEIdKey,
unboundVarEIdKey, labelEIdKey, implicitParamVarEIdKey, mdoEIdKey, unboundVarEIdKey, labelEIdKey, implicitParamVarEIdKey, mdoEIdKey,
getFieldEIdKey, projectionEIdKey :: Unique getFieldEIdKey, projectionEIdKey, typeEIdKey :: Unique
varEIdKey = mkPreludeMiscIdUnique 270 varEIdKey = mkPreludeMiscIdUnique 270
conEIdKey = mkPreludeMiscIdUnique 271 conEIdKey = mkPreludeMiscIdUnique 271
litEIdKey = mkPreludeMiscIdUnique 272 litEIdKey = mkPreludeMiscIdUnique 272
...@@ -883,28 +888,29 @@ implicitParamVarEIdKey = mkPreludeMiscIdUnique 302 ...@@ -883,28 +888,29 @@ implicitParamVarEIdKey = mkPreludeMiscIdUnique 302
mdoEIdKey = mkPreludeMiscIdUnique 303 mdoEIdKey = mkPreludeMiscIdUnique 303
getFieldEIdKey = mkPreludeMiscIdUnique 304 getFieldEIdKey = mkPreludeMiscIdUnique 304
projectionEIdKey = mkPreludeMiscIdUnique 305 projectionEIdKey = mkPreludeMiscIdUnique 305
typeEIdKey = mkPreludeMiscIdUnique 306
-- type FieldExp = ... -- type FieldExp = ...
fieldExpIdKey :: Unique fieldExpIdKey :: Unique
fieldExpIdKey = mkPreludeMiscIdUnique 306 fieldExpIdKey = mkPreludeMiscIdUnique 307
-- data Body = ... -- data Body = ...
guardedBIdKey, normalBIdKey :: Unique guardedBIdKey, normalBIdKey :: Unique
guardedBIdKey = mkPreludeMiscIdUnique 307 guardedBIdKey = mkPreludeMiscIdUnique 308
normalBIdKey = mkPreludeMiscIdUnique 308 normalBIdKey = mkPreludeMiscIdUnique 309
-- data Guard = ... -- data Guard = ...
normalGEIdKey, patGEIdKey :: Unique normalGEIdKey, patGEIdKey :: Unique
normalGEIdKey = mkPreludeMiscIdUnique 309 normalGEIdKey = mkPreludeMiscIdUnique 310
patGEIdKey = mkPreludeMiscIdUnique 310 patGEIdKey = mkPreludeMiscIdUnique 311
-- data Stmt = ... -- data Stmt = ...
bindSIdKey, letSIdKey, noBindSIdKey, parSIdKey, recSIdKey :: Unique bindSIdKey, letSIdKey, noBindSIdKey, parSIdKey, recSIdKey :: Unique
bindSIdKey = mkPreludeMiscIdUnique 311 bindSIdKey = mkPreludeMiscIdUnique 312
letSIdKey = mkPreludeMiscIdUnique 312 letSIdKey = mkPreludeMiscIdUnique 313
noBindSIdKey = mkPreludeMiscIdUnique 313 noBindSIdKey = mkPreludeMiscIdUnique 314
parSIdKey = mkPreludeMiscIdUnique 314 parSIdKey = mkPreludeMiscIdUnique 315
recSIdKey = mkPreludeMiscIdUnique 315 recSIdKey = mkPreludeMiscIdUnique 316
-- data Dec = ... -- data Dec = ...
funDIdKey, valDIdKey, dataDIdKey, newtypeDIdKey, tySynDIdKey, classDIdKey, funDIdKey, valDIdKey, dataDIdKey, newtypeDIdKey, tySynDIdKey, classDIdKey,
...@@ -1147,29 +1153,7 @@ bndrInvisKey = mkPreludeMiscIdUnique 801 ...@@ -1147,29 +1153,7 @@ bndrInvisKey = mkPreludeMiscIdUnique 801
************************************************************************ ************************************************************************
-} -}
lift_RDR, liftTyped_RDR, mkNameG_dRDR, mkNameG_vRDR, mkNameG_fldRDR, lift_RDR, liftTyped_RDR, unsafeCodeCoerce_RDR :: RdrName
unsafeCodeCoerce_RDR :: RdrName
lift_RDR = nameRdrName liftName lift_RDR = nameRdrName liftName
liftTyped_RDR = nameRdrName liftTypedName liftTyped_RDR = nameRdrName liftTypedName
unsafeCodeCoerce_RDR = nameRdrName unsafeCodeCoerceName unsafeCodeCoerce_RDR = nameRdrName unsafeCodeCoerceName
mkNameG_dRDR = nameRdrName mkNameG_dName
mkNameG_vRDR = nameRdrName mkNameG_vName
mkNameG_fldRDR = nameRdrName mkNameG_fldName
-- data Exp = ...
conE_RDR, litE_RDR, appE_RDR, infixApp_RDR :: RdrName
conE_RDR = nameRdrName conEName
litE_RDR = nameRdrName litEName
appE_RDR = nameRdrName appEName
infixApp_RDR = nameRdrName infixAppName
-- data Lit = ...
stringL_RDR, intPrimL_RDR, wordPrimL_RDR, floatPrimL_RDR,
doublePrimL_RDR, stringPrimL_RDR, charPrimL_RDR :: RdrName
stringL_RDR = nameRdrName stringLName
intPrimL_RDR = nameRdrName intPrimLName
wordPrimL_RDR = nameRdrName wordPrimLName
floatPrimL_RDR = nameRdrName floatPrimLName
doublePrimL_RDR = nameRdrName doublePrimLName
stringPrimL_RDR = nameRdrName stringPrimLName
charPrimL_RDR = nameRdrName charPrimLName
#!/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
rep_ty: str
desc: str
width: Optional[int]
MACH_WORD = None
element_types = [
# (name, representation type, human description, width)
#
# width in bytes.
# width == None denotes machine word
ElementType("Char", "Char#", "8-bit character", 1),
ElementType("WideChar", "Char#", "32-bit character", 4),
ElementType("Int", "Int#", "word-sized integer", MACH_WORD),
ElementType("Word", "Word#", "word-sized unsigned integer", MACH_WORD),
ElementType("Addr", "Addr#", "machine address", MACH_WORD),
ElementType("Float", "Float#", "single-precision floating-point value", 4),
ElementType("Double", "Double#", "double-precision floating-point value", 8),
ElementType("StablePtr", "StablePtr# a", "'StablePtr#' value", MACH_WORD),
]
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:
return 'machine words'
elif n == 1:
return 'bytes'
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:
write(textwrap.dedent(template.format(**kwargs)).lstrip())
write('\n')
def header(s: str):
write('\n')
print_block('''
------------------------------------
-- {s}
------------------------------------
''', s=s)
if args.addr_or_bytearray == "bytearray-access-ops":
header("ByteArray# operations")
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())
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())
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())
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())
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())
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())
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())
...@@ -1929,6 +1929,14 @@ primop UnsafeFreezeByteArrayOp "unsafeFreezeByteArray#" GenPrimOp ...@@ -1929,6 +1929,14 @@ primop UnsafeFreezeByteArrayOp "unsafeFreezeByteArray#" GenPrimOp
with with
has_side_effects = True has_side_effects = True
primop UnsafeThawByteArrayOp "unsafeThawByteArray#" GenPrimOp
ByteArray# -> State# s -> (# State# s, MutableByteArray# s #)
{Make an immutable byte array mutable, without copying.
@since 0.12.0.0}
with
has_side_effects = True
primop SizeofByteArrayOp "sizeofByteArray#" GenPrimOp primop SizeofByteArrayOp "sizeofByteArray#" GenPrimOp
ByteArray# -> Int# ByteArray# -> Int#
{Return the size of the array in bytes.} {Return the size of the array in bytes.}
...@@ -1948,7 +1956,11 @@ primop GetSizeofMutableByteArrayOp "getSizeofMutableByteArray#" GenPrimOp ...@@ -1948,7 +1956,11 @@ primop GetSizeofMutableByteArrayOp "getSizeofMutableByteArray#" GenPrimOp
@since 0.5.0.0} @since 0.5.0.0}
#include "bytearray-access-ops.txt.pp"
bytearray_access_ops
-- This generates a whole bunch of primops;
-- see utils/genprimopcode/AccessOps.hs
primop CompareByteArraysOp "compareByteArrays#" GenPrimOp primop CompareByteArraysOp "compareByteArrays#" GenPrimOp
ByteArray# -> Int# -> ByteArray# -> Int# -> Int# -> Int# ByteArray# -> Int# -> ByteArray# -> Int# -> Int# -> Int#
...@@ -2251,7 +2263,11 @@ primop AddrNeOp "neAddr#" Compare Addr# -> Addr# -> Int# ...@@ -2251,7 +2263,11 @@ primop AddrNeOp "neAddr#" Compare Addr# -> Addr# -> Int#
primop AddrLtOp "ltAddr#" Compare Addr# -> Addr# -> Int# primop AddrLtOp "ltAddr#" Compare Addr# -> Addr# -> Int#
primop AddrLeOp "leAddr#" Compare Addr# -> Addr# -> Int# primop AddrLeOp "leAddr#" Compare Addr# -> Addr# -> Int#
#include "addr-access-ops.txt.pp"
addr_access_ops
-- This generates a whole bunch of primops;
-- see utils/genprimopcode/AccessOps.hs
primop InterlockedExchange_Addr "atomicExchangeAddrAddr#" GenPrimOp primop InterlockedExchange_Addr "atomicExchangeAddrAddr#" GenPrimOp
Addr# -> Addr# -> State# s -> (# State# s, Addr# #) Addr# -> Addr# -> State# s -> (# State# s, Addr# #)
......
...@@ -56,6 +56,25 @@ Note that there are variety of places in the native code generator where we ...@@ -56,6 +56,25 @@ Note that there are variety of places in the native code generator where we
assume that the code produced for a MachOp does not introduce new blocks. assume that the code produced for a MachOp does not introduce new blocks.
-} -}
-- Note [MO_S_MulMayOflo significant width]
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
--
-- There are two interpretations in the code about what a multiplication
-- overflow exactly means:
--
-- 1. The result does not fit into the specified width (of type Width.)
-- 2. The result does not fit into a register.
--
-- (2) has some flaws: A following MO_Mul has a width, too. So MO_S_MulMayOflo
-- may signal no overflow, while MO_Mul truncates the result. There are
-- architectures with several register widths and it might be hard to decide
-- what's an overflow and what not. Both attributes can easily lead to subtle
-- bugs.
--
-- (1) has the benefit that its interpretation is completely independent of the
-- architecture. So, the mid-term plan is to migrate to this
-- interpretation/sematics.
data MachOp data MachOp
-- Integer operations (insensitive to signed/unsigned) -- Integer operations (insensitive to signed/unsigned)
= MO_Add Width = MO_Add Width
...@@ -65,7 +84,8 @@ data MachOp ...@@ -65,7 +84,8 @@ data MachOp
| MO_Mul Width -- low word of multiply | MO_Mul Width -- low word of multiply
-- Signed multiply/divide -- Signed multiply/divide
| MO_S_MulMayOflo Width -- nonzero if signed multiply overflows | MO_S_MulMayOflo Width -- nonzero if signed multiply overflows. See
-- Note [MO_S_MulMayOflo significant width]
| MO_S_Quot Width -- signed / (same semantics as IntQuotOp) | MO_S_Quot Width -- signed / (same semantics as IntQuotOp)
| MO_S_Rem Width -- signed % (same semantics as IntRemOp) | MO_S_Rem Width -- signed % (same semantics as IntRemOp)
| MO_S_Neg Width -- unary - | MO_S_Neg Width -- unary -
......
...@@ -205,7 +205,7 @@ memory ordering guarantees. These are supported in Cmm syntax as follows: ...@@ -205,7 +205,7 @@ memory ordering guarantees. These are supported in Cmm syntax as follows:
%relaxed W_[ptr] = ...; // an atomic store with relaxed ordering semantics %relaxed W_[ptr] = ...; // an atomic store with relaxed ordering semantics
%release W_[ptr] = ...; // an atomic store with release ordering semantics %release W_[ptr] = ...; // an atomic store with release ordering semantics
x = W_(ptr); // a non-atomic load x = W_[ptr]; // a non-atomic load
x = %relaxed W_[ptr]; // an atomic load with relaxed ordering x = %relaxed W_[ptr]; // an atomic load with relaxed ordering
x = %acquire W_[ptr]; // an atomic load with acquire ordering x = %acquire W_[ptr]; // an atomic load with acquire ordering
// or equivalently... // or equivalently...
......
...@@ -6,7 +6,6 @@ module GHC.Cmm.ThreadSanitizer (annotateTSAN) where ...@@ -6,7 +6,6 @@ module GHC.Cmm.ThreadSanitizer (annotateTSAN) where
import GHC.Prelude import GHC.Prelude
import GHC.StgToCmm.Utils (get_GlobalReg_addr)
import GHC.Platform import GHC.Platform
import GHC.Platform.Regs (activeStgRegs, callerSaves) import GHC.Platform.Regs (activeStgRegs, callerSaves)
import GHC.Cmm import GHC.Cmm
...@@ -24,12 +23,12 @@ import GHC.Types.Unique.Supply ...@@ -24,12 +23,12 @@ import GHC.Types.Unique.Supply
import Data.Maybe (fromMaybe) import Data.Maybe (fromMaybe)
data Env = Env { platform :: Platform data Env = Env { platform :: Platform
, uniques :: [Unique] , uniques :: UniqSupply
} }
annotateTSAN :: Platform -> CmmGraph -> UniqSM CmmGraph annotateTSAN :: Platform -> CmmGraph -> UniqSM CmmGraph
annotateTSAN platform graph = do annotateTSAN platform graph = do
env <- Env platform <$> getUniquesM env <- Env platform <$> getUniqueSupplyM
return $ modifyGraph (mapGraphBlocks (annotateBlock env)) graph return $ modifyGraph (mapGraphBlocks (annotateBlock env)) graph
mapBlockList :: (forall e' x'. n e' x' -> Block n e' x') mapBlockList :: (forall e' x'. n e' x' -> Block n e' x')
...@@ -37,11 +36,11 @@ mapBlockList :: (forall e' x'. n e' x' -> Block n e' x') ...@@ -37,11 +36,11 @@ mapBlockList :: (forall e' x'. n e' x' -> Block n e' x')
mapBlockList f (BlockCO n rest ) = f n `blockAppend` mapBlockList f rest mapBlockList f (BlockCO n rest ) = f n `blockAppend` mapBlockList f rest
mapBlockList f (BlockCC n rest m) = f n `blockAppend` mapBlockList f rest `blockAppend` f m mapBlockList f (BlockCC n rest m) = f n `blockAppend` mapBlockList f rest `blockAppend` f m
mapBlockList f (BlockOC rest m) = mapBlockList f rest `blockAppend` f m mapBlockList f (BlockOC rest m) = mapBlockList f rest `blockAppend` f m
mapBlockList _ BNil = BNil mapBlockList _ BNil = BNil
mapBlockList f (BMiddle blk) = f blk mapBlockList f (BMiddle blk) = f blk
mapBlockList f (BCat a b) = mapBlockList f a `blockAppend` mapBlockList f b mapBlockList f (BCat a b) = mapBlockList f a `blockAppend` mapBlockList f b
mapBlockList f (BSnoc a n) = mapBlockList f a `blockAppend` f n mapBlockList f (BSnoc a n) = mapBlockList f a `blockAppend` f n
mapBlockList f (BCons n a) = f n `blockAppend` mapBlockList f a mapBlockList f (BCons n a) = f n `blockAppend` mapBlockList f a
annotateBlock :: Env -> Block CmmNode e x -> Block CmmNode e x annotateBlock :: Env -> Block CmmNode e x -> Block CmmNode e x
annotateBlock env = mapBlockList (annotateNode env) annotateBlock env = mapBlockList (annotateNode env)
...@@ -114,10 +113,10 @@ annotatePrim :: Env ...@@ -114,10 +113,10 @@ annotatePrim :: Env
-> [CmmActual] -- ^ arguments -> [CmmActual] -- ^ arguments
-> Maybe (Block CmmNode O O) -> Maybe (Block CmmNode O O)
-- ^ 'Just' a block of instrumentation, if applicable -- ^ 'Just' a block of instrumentation, if applicable
annotatePrim env (MO_AtomicRMW w aop) [dest] [addr, val] = Just $ tsanAtomicRMW env MemOrderSeqCst aop w addr val dest annotatePrim env (MO_AtomicRMW w aop) [dest] [addr, val] = Just $ tsanAtomicRMW env MemOrderSeqCst aop w addr val dest
annotatePrim env (MO_AtomicRead w mord) [dest] [addr] = Just $ tsanAtomicLoad env mord w addr dest annotatePrim env (MO_AtomicRead w mord) [dest] [addr] = Just $ tsanAtomicLoad env mord w addr dest
annotatePrim env (MO_AtomicWrite w mord) [] [addr, val] = Just $ tsanAtomicStore env mord w val addr annotatePrim env (MO_AtomicWrite w mord) [] [addr, val] = Just $ tsanAtomicStore env mord w val addr
annotatePrim env (MO_Xchg w) [dest] [addr, val] = Just $ tsanAtomicExchange env MemOrderSeqCst w val addr dest annotatePrim env (MO_Xchg w) [dest] [addr, val] = Just $ tsanAtomicExchange env MemOrderSeqCst w val addr dest
annotatePrim env (MO_Cmpxchg w) [dest] [addr, expected, new] annotatePrim env (MO_Cmpxchg w) [dest] [addr, expected, new]
= Just $ tsanAtomicCas env MemOrderSeqCst MemOrderSeqCst w addr expected new dest = Just $ tsanAtomicCas env MemOrderSeqCst MemOrderSeqCst w addr expected new dest
annotatePrim _ _ _ _ = Nothing annotatePrim _ _ _ _ = Nothing
...@@ -133,14 +132,15 @@ mkUnsafeCall env ftgt formals args = ...@@ -133,14 +132,15 @@ mkUnsafeCall env ftgt formals args =
call `blockAppend` -- perform call call `blockAppend` -- perform call
restore -- restore global registers restore -- restore global registers
where where
-- We are rather conservative here and just save/restore all GlobalRegs. (save, restore) = saveRestoreCallerRegs gregs_us (platform env)
(save, restore) = saveRestoreCallerRegs (platform env)
(arg_us, gregs_us) = splitUniqSupply (uniques env)
-- We also must be careful not to mention caller-saved registers in -- We also must be careful not to mention caller-saved registers in
-- arguments as Cmm-Lint checks this. To accomplish this we instead bind -- arguments as Cmm-Lint checks this. To accomplish this we instead bind
-- the arguments to local registers. -- the arguments to local registers.
arg_regs :: [CmmReg] arg_regs :: [CmmReg]
arg_regs = zipWith arg_reg (uniques env) args arg_regs = zipWith arg_reg (uniqsFromSupply arg_us) args
where where
arg_reg :: Unique -> CmmExpr -> CmmReg arg_reg :: Unique -> CmmExpr -> CmmReg
arg_reg u expr = CmmLocal $ LocalReg u (cmmExprType (platform env) expr) arg_reg u expr = CmmLocal $ LocalReg u (cmmExprType (platform env) expr)
...@@ -150,31 +150,34 @@ mkUnsafeCall env ftgt formals args = ...@@ -150,31 +150,34 @@ mkUnsafeCall env ftgt formals args =
call = CmmUnsafeForeignCall ftgt formals (map CmmReg arg_regs) call = CmmUnsafeForeignCall ftgt formals (map CmmReg arg_regs)
saveRestoreCallerRegs :: Platform -- | We save the contents of global registers in locals and allow the
-- register allocator to spill them to the stack around the call.
-- We cannot use the register table for this since we would interface
-- with {SAVE,RESTORE}_THREAD_STATE.
saveRestoreCallerRegs :: UniqSupply -> Platform
-> (Block CmmNode O O, Block CmmNode O O) -> (Block CmmNode O O, Block CmmNode O O)
saveRestoreCallerRegs platform = saveRestoreCallerRegs us platform =
(save, restore) (save, restore)
where where
regs = filter (callerSaves platform) (activeStgRegs platform) regs_to_save :: [GlobalReg]
regs_to_save = filter (callerSaves platform) (activeStgRegs platform)
save = blockFromList (map saveReg regs)
nodes :: [(CmmNode O O, CmmNode O O)]
saveReg :: GlobalReg -> CmmNode O O nodes =
saveReg reg = zipWith mk_reg regs_to_save (uniqsFromSupply us)
CmmStore (get_GlobalReg_addr platform reg) where
(CmmReg (CmmGlobal (GlobalRegUse reg ty))) mk_reg :: GlobalReg -> Unique -> (CmmNode O O, CmmNode O O)
NaturallyAligned mk_reg reg u =
where ty = globalRegSpillType platform reg let ty = globalRegSpillType platform reg
greg = CmmGlobal (GlobalRegUse reg ty)
restore = blockFromList (map restoreReg regs) lreg = CmmLocal (LocalReg u ty)
save = CmmAssign lreg (CmmReg greg)
restoreReg :: GlobalReg -> CmmNode O O restore = CmmAssign greg (CmmReg lreg)
restoreReg reg = in (save, restore)
CmmAssign (CmmGlobal (GlobalRegUse reg ty))
(CmmLoad (get_GlobalReg_addr platform reg) (save_nodes, restore_nodes) = unzip nodes
ty save = blockFromList save_nodes
NaturallyAligned) restore = blockFromList restore_nodes
where ty = globalRegSpillType platform reg
-- | Mirrors __tsan_memory_order -- | Mirrors __tsan_memory_order
-- <https://github.com/llvm-mirror/compiler-rt/blob/master/include/sanitizer/tsan_interface_atomic.h#L32> -- <https://github.com/llvm-mirror/compiler-rt/blob/master/include/sanitizer/tsan_interface_atomic.h#L32>
......
...@@ -170,7 +170,7 @@ nativeCodeGen logger ts config modLoc h us cmms ...@@ -170,7 +170,7 @@ nativeCodeGen logger ts config modLoc h us cmms
ArchLoongArch64->panic "nativeCodeGen: No NCG for LoongArch64" ArchLoongArch64->panic "nativeCodeGen: No NCG for LoongArch64"
ArchUnknown -> panic "nativeCodeGen: No NCG for unknown arch" ArchUnknown -> panic "nativeCodeGen: No NCG for unknown arch"
ArchJavaScript-> panic "nativeCodeGen: No NCG for JavaScript" ArchJavaScript-> panic "nativeCodeGen: No NCG for JavaScript"
ArchWasm32 -> Wasm32.ncgWasm platform ts us modLoc h cmms ArchWasm32 -> Wasm32.ncgWasm logger platform ts us modLoc h cmms
-- | Data accumulated during code generation. Mostly about statistics, -- | Data accumulated during code generation. Mostly about statistics,
-- but also collects debug data for DWARF generation. -- but also collects debug data for DWARF generation.
......
...@@ -372,6 +372,114 @@ getSomeReg expr = do ...@@ -372,6 +372,114 @@ getSomeReg expr = do
Fixed rep reg code -> Fixed rep reg code ->
return (reg, rep, code) return (reg, rep, code)
{- Note [Aarch64 immediates]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Aarch64 with it's fixed width instruction encoding uses leftover space for
immediates.
If you want the full rundown consult the arch reference document:
"Arm® Architecture Reference Manual" - "C3.4 Data processing - immediate"
The gist of it is that different instructions allow for different immediate encodings.
The ones we care about for better code generation are:
* Simple but potentially repeated bit-patterns for logic instructions.
* 16bit numbers shifted by multiples of 16.
* 12 bit numbers optionally shifted by 12 bits.
It might seem like the ISA allows for 64bit immediates but this isn't the case.
Rather there are some instruction aliases which allow for large unencoded immediates
which will then be transalted to one of the immediate encodings implicitly.
For example mov x1, #0x10000 is allowed but will be assembled to movz x1, #0x1, lsl #16
-}
-- | Move (wide immediate)
-- Allows for 16bit immediate which can be shifted by 0/16/32/48 bits.
-- Used with MOVZ,MOVN, MOVK
-- See Note [Aarch64 immediates]
getMovWideImm :: Integer -> Width -> Maybe Operand
getMovWideImm n w
-- TODO: Handle sign extension/negatives
| n <= 0
= Nothing
-- Fits in 16 bits
| sized_n < 2^(16 :: Int)
= Just $ OpImm (ImmInteger truncated)
-- 0x0000 0000 xxxx 0000
| trailing_zeros >= 16 && sized_n < 2^(32 :: Int)
= Just $ OpImmShift (ImmInteger $ truncated `shiftR` 16) SLSL 16
-- 0x 0000 xxxx 0000 0000
| trailing_zeros >= 32 && sized_n < 2^(48 :: Int)
= Just $ OpImmShift (ImmInteger $ truncated `shiftR` 32) SLSL 32
-- 0x xxxx 0000 0000 0000
| trailing_zeros >= 48
= Just $ OpImmShift (ImmInteger $ truncated `shiftR` 48) SLSL 48
| otherwise
= Nothing
where
truncated = narrowU w n
sized_n = fromIntegral truncated :: Word64
trailing_zeros = countTrailingZeros sized_n
-- | Arithmetic(immediate)
-- Allows for 12bit immediates which can be shifted by 0 or 12 bits.
-- Used with ADD, ADDS, SUB, SUBS, CMP, CMN
-- See Note [Aarch64 immediates]
getArithImm :: Integer -> Width -> Maybe Operand
getArithImm n w
-- TODO: Handle sign extension
| n <= 0
= Nothing
-- Fits in 16 bits
-- Fits in 12 bits
| sized_n < 2^(12::Int)
= Just $ OpImm (ImmInteger truncated)
-- 12 bits shifted by 12 places.
| trailing_zeros >= 12 && sized_n < 2^(24::Int)
= Just $ OpImmShift (ImmInteger $ truncated `shiftR` 12) SLSL 12
| otherwise
= Nothing
where
sized_n = fromIntegral truncated :: Word64
truncated = narrowU w n
trailing_zeros = countTrailingZeros sized_n
-- | Logical (immediate)
-- Allows encoding of some repeated bitpatterns
-- Used with AND, ANDS, EOR, ORR, TST
-- and their aliases which includes at least MOV (bitmask immediate)
-- See Note [Aarch64 immediates]
getBitmaskImm :: Integer -> Width -> Maybe Operand
getBitmaskImm n w
| isAArch64Bitmask truncated = Just $ OpImm (ImmInteger truncated)
| otherwise = Nothing
where
truncated = narrowU w n
-- | Load/store immediate.
-- Depends on the width of the store to some extent.
isOffsetImm :: Int -> Width -> Bool
isOffsetImm off w
-- 8 bits + sign for unscaled offsets
| -256 <= off, off <= 255 = True
-- Offset using 12-bit positive immediate, scaled by width
-- LDR/STR: imm12: if reg is 32bit: 0 -- 16380 in multiples of 4
-- LDR/STR: imm12: if reg is 64bit: 0 -- 32760 in multiples of 8
-- 16-bit: 0 .. 8188, 8-bit: 0 -- 4095
| 0 <= off, off < 4096 * byte_width, off `mod` byte_width == 0 = True
| otherwise = False
where
byte_width = widthInBytes w
-- TODO OPT: we might be able give getRegister -- TODO OPT: we might be able give getRegister
-- a hint, what kind of register we want. -- a hint, what kind of register we want.
getFloatReg :: HasCallStack => CmmExpr -> NatM (Reg, Format, InstrBlock) getFloatReg :: HasCallStack => CmmExpr -> NatM (Reg, Format, InstrBlock)
...@@ -494,8 +602,14 @@ getRegister' config plat expr ...@@ -494,8 +602,14 @@ getRegister' config plat expr
CmmLit lit CmmLit lit
-> case lit of -> case lit of
-- TODO handle CmmInt 0 specially, use wzr or xzr. -- Use wzr xzr for CmmInt 0 if the width matches up, otherwise do a move.
-- TODO: Reenable after https://gitlab.haskell.org/ghc/ghc/-/issues/23632 is fixed.
-- CmmInt 0 W32 -> do
-- let format = intFormat W32
-- return (Fixed format reg_zero (unitOL $ (COMMENT ((text . show $ expr))) ))
-- CmmInt 0 W64 -> do
-- let format = intFormat W64
-- return (Fixed format reg_zero (unitOL $ (COMMENT ((text . show $ expr))) ))
CmmInt i W8 | i >= 0 -> do CmmInt i W8 | i >= 0 -> do
return (Any (intFormat W8) (\dst -> unitOL $ annExpr expr (MOV (OpReg W8 dst) (OpImm (ImmInteger (narrowU W8 i)))))) return (Any (intFormat W8) (\dst -> unitOL $ annExpr expr (MOV (OpReg W8 dst) (OpImm (ImmInteger (narrowU W8 i))))))
CmmInt i W16 | i >= 0 -> do CmmInt i W16 | i >= 0 -> do
...@@ -510,8 +624,13 @@ getRegister' config plat expr ...@@ -510,8 +624,13 @@ getRegister' config plat expr
-- Those need the upper bits set. We'd either have to explicitly sign -- Those need the upper bits set. We'd either have to explicitly sign
-- or figure out something smarter. Lowered to -- or figure out something smarter. Lowered to
-- `MOV dst XZR` -- `MOV dst XZR`
CmmInt i w | i >= 0
, Just imm_op <- getMovWideImm i w -> do
return (Any (intFormat w) (\dst -> unitOL $ annExpr expr (MOVZ (OpReg w dst) imm_op)))
CmmInt i w | isNbitEncodeable 16 i, i >= 0 -> do CmmInt i w | isNbitEncodeable 16 i, i >= 0 -> do
return (Any (intFormat w) (\dst -> unitOL $ annExpr expr (MOV (OpReg W16 dst) (OpImm (ImmInteger i))))) return (Any (intFormat w) (\dst -> unitOL $ annExpr expr (MOV (OpReg W16 dst) (OpImm (ImmInteger i)))))
CmmInt i w | isNbitEncodeable 32 i, i >= 0 -> do CmmInt i w | isNbitEncodeable 32 i, i >= 0 -> do
let half0 = fromIntegral (fromIntegral i :: Word16) let half0 = fromIntegral (fromIntegral i :: Word16)
half1 = fromIntegral (fromIntegral (i `shiftR` 16) :: Word16) half1 = fromIntegral (fromIntegral (i `shiftR` 16) :: Word16)
...@@ -586,7 +705,6 @@ getRegister' config plat expr ...@@ -586,7 +705,6 @@ getRegister' config plat expr
(op, imm_code) <- litToImm' lit (op, imm_code) <- litToImm' lit
let rep = cmmLitType plat lit let rep = cmmLitType plat lit
format = cmmTypeFormat rep format = cmmTypeFormat rep
-- width = typeWidth rep
return (Any format (\dst -> imm_code `snocOL` LDR format (OpReg (formatToWidth format) dst) op)) return (Any format (\dst -> imm_code `snocOL` LDR format (OpReg (formatToWidth format) dst) op))
CmmLabelOff lbl off -> do CmmLabelOff lbl off -> do
...@@ -610,18 +728,11 @@ getRegister' config plat expr ...@@ -610,18 +728,11 @@ getRegister' config plat expr
-> return (Fixed (cmmTypeFormat (cmmRegType reg)) -> return (Fixed (cmmTypeFormat (cmmRegType reg))
(getRegisterReg plat reg) (getRegisterReg plat reg)
nilOL) nilOL)
CmmRegOff reg off | isNbitEncodeable 12 (fromIntegral off) -> do CmmRegOff reg off ->
getRegister' config plat $ -- If we got here we will load the address into a register either way. So we might as well just expand
CmmMachOp (MO_Add width) [CmmReg reg, CmmLit (CmmInt (fromIntegral off) width)] -- and re-use the existing code path to handle "reg + off".
where width = typeWidth (cmmRegType reg) let !width = cmmRegWidth reg
in getRegister' config plat (CmmMachOp (MO_Add width) [CmmReg reg, CmmLit (CmmInt (fromIntegral off) width)])
CmmRegOff reg off -> do
(off_r, _off_format, off_code) <- getSomeReg $ CmmLit (CmmInt (fromIntegral off) width)
(reg, _format, code) <- getSomeReg $ CmmReg reg
return $ Any (intFormat width) (\dst -> off_code `appOL` code `snocOL` ADD (OpReg width dst) (OpReg width reg) (OpReg width off_r))
where width = typeWidth (cmmRegType reg)
-- for MachOps, see GHC.Cmm.MachOp -- for MachOps, see GHC.Cmm.MachOp
-- For CmmMachOp, see GHC.Cmm.Expr -- For CmmMachOp, see GHC.Cmm.Expr
...@@ -693,33 +804,25 @@ getRegister' config plat expr ...@@ -693,33 +804,25 @@ getRegister' config plat expr
-- 0. TODO This should not exist! Rewrite: Reg +- 0 -> Reg -- 0. TODO This should not exist! Rewrite: Reg +- 0 -> Reg
CmmMachOp (MO_Add _) [expr'@(CmmReg (CmmGlobal _r)), CmmLit (CmmInt 0 _)] -> getRegister' config plat expr' CmmMachOp (MO_Add _) [expr'@(CmmReg (CmmGlobal _r)), CmmLit (CmmInt 0 _)] -> getRegister' config plat expr'
CmmMachOp (MO_Sub _) [expr'@(CmmReg (CmmGlobal _r)), CmmLit (CmmInt 0 _)] -> getRegister' config plat expr' CmmMachOp (MO_Sub _) [expr'@(CmmReg (CmmGlobal _r)), CmmLit (CmmInt 0 _)] -> getRegister' config plat expr'
-- 1. Compute Reg +/- n directly. -- Immediates are handled via `getArithImm` in the generic code path.
-- For Add/Sub we can directly encode 12bits, or 12bits lsl #12.
CmmMachOp (MO_Add w) [(CmmReg reg), CmmLit (CmmInt n _)]
| n > 0 && n < 4096 -> return $ Any (intFormat w) (\d -> unitOL $ annExpr expr (ADD (OpReg w d) (OpReg w' r') (OpImm (ImmInteger n))))
-- TODO: 12bits lsl #12; e.g. lower 12 bits of n are 0; shift n >> 12, and set lsl to #12.
where w' = formatToWidth (cmmTypeFormat (cmmRegType reg))
r' = getRegisterReg plat reg
CmmMachOp (MO_Sub w) [(CmmReg reg), CmmLit (CmmInt n _)]
| n > 0 && n < 4096 -> return $ Any (intFormat w) (\d -> unitOL $ annExpr expr (SUB (OpReg w d) (OpReg w' r') (OpImm (ImmInteger n))))
-- TODO: 12bits lsl #12; e.g. lower 12 bits of n are 0; shift n >> 12, and set lsl to #12.
where w' = formatToWidth (cmmTypeFormat (cmmRegType reg))
r' = getRegisterReg plat reg
CmmMachOp (MO_U_Quot w) [x, y] | w == W8 -> do CmmMachOp (MO_U_Quot w) [x, y] | w == W8 -> do
(reg_x, _format_x, code_x) <- getSomeReg x (reg_x, _format_x, code_x) <- getSomeReg x
(reg_y, _format_y, code_y) <- getSomeReg y (reg_y, _format_y, code_y) <- getSomeReg y
return $ Any (intFormat w) (\dst -> code_x `appOL` code_y `snocOL` annExpr expr (UXTB (OpReg w reg_x) (OpReg w reg_x)) `snocOL` (UXTB (OpReg w reg_y) (OpReg w reg_y)) `snocOL` (UDIV (OpReg w dst) (OpReg w reg_x) (OpReg w reg_y))) return $ Any (intFormat w) (\dst -> code_x `appOL` code_y `snocOL` annExpr expr (UXTB (OpReg w reg_x) (OpReg w reg_x)) `snocOL`
(UXTB (OpReg w reg_y) (OpReg w reg_y)) `snocOL`
(UDIV (OpReg w dst) (OpReg w reg_x) (OpReg w reg_y)))
CmmMachOp (MO_U_Quot w) [x, y] | w == W16 -> do CmmMachOp (MO_U_Quot w) [x, y] | w == W16 -> do
(reg_x, _format_x, code_x) <- getSomeReg x (reg_x, _format_x, code_x) <- getSomeReg x
(reg_y, _format_y, code_y) <- getSomeReg y (reg_y, _format_y, code_y) <- getSomeReg y
return $ Any (intFormat w) (\dst -> code_x `appOL` code_y `snocOL` annExpr expr (UXTH (OpReg w reg_x) (OpReg w reg_x)) `snocOL` (UXTH (OpReg w reg_y) (OpReg w reg_y)) `snocOL` (UDIV (OpReg w dst) (OpReg w reg_x) (OpReg w reg_y))) return $ Any (intFormat w) (\dst -> code_x `appOL` code_y `snocOL` annExpr expr (UXTH (OpReg w reg_x) (OpReg w reg_x)) `snocOL`
(UXTH (OpReg w reg_y) (OpReg w reg_y)) `snocOL`
(UDIV (OpReg w dst) (OpReg w reg_x) (OpReg w reg_y)))
-- 2. Shifts. x << n, x >> n. -- 2. Shifts. x << n, x >> n.
CmmMachOp (MO_Shl w) [x, (CmmLit (CmmInt n _))] | w == W32, 0 <= n, n < 32 -> do CmmMachOp (MO_Shl w) [x, (CmmLit (CmmInt n _))]
(reg_x, _format_x, code_x) <- getSomeReg x | w == W32 || w == W64
return $ Any (intFormat w) (\dst -> code_x `snocOL` annExpr expr (LSL (OpReg w dst) (OpReg w reg_x) (OpImm (ImmInteger n)))) , 0 <= n, n < fromIntegral (widthInBits w) -> do
CmmMachOp (MO_Shl w) [x, (CmmLit (CmmInt n _))] | w == W64, 0 <= n, n < 64 -> do
(reg_x, _format_x, code_x) <- getSomeReg x (reg_x, _format_x, code_x) <- getSomeReg x
return $ Any (intFormat w) (\dst -> code_x `snocOL` annExpr expr (LSL (OpReg w dst) (OpReg w reg_x) (OpImm (ImmInteger n)))) return $ Any (intFormat w) (\dst -> code_x `snocOL` annExpr expr (LSL (OpReg w dst) (OpReg w reg_x) (OpImm (ImmInteger n))))
...@@ -729,7 +832,8 @@ getRegister' config plat expr ...@@ -729,7 +832,8 @@ getRegister' config plat expr
CmmMachOp (MO_S_Shr w) [x, y] | w == W8 -> do CmmMachOp (MO_S_Shr w) [x, y] | w == W8 -> do
(reg_x, _format_x, code_x) <- getSomeReg x (reg_x, _format_x, code_x) <- getSomeReg x
(reg_y, _format_y, code_y) <- getSomeReg y (reg_y, _format_y, code_y) <- getSomeReg y
return $ Any (intFormat w) (\dst -> code_x `appOL` code_y `snocOL` annExpr expr (SXTB (OpReg w reg_x) (OpReg w reg_x)) `snocOL` (ASR (OpReg w dst) (OpReg w reg_x) (OpReg w reg_y))) return $ Any (intFormat w) (\dst -> code_x `appOL` code_y `snocOL` annExpr expr (SXTB (OpReg w reg_x) (OpReg w reg_x)) `snocOL`
(ASR (OpReg w dst) (OpReg w reg_x) (OpReg w reg_y)))
CmmMachOp (MO_S_Shr w) [x, (CmmLit (CmmInt n _))] | w == W16, 0 <= n, n < 16 -> do CmmMachOp (MO_S_Shr w) [x, (CmmLit (CmmInt n _))] | w == W16, 0 <= n, n < 16 -> do
(reg_x, _format_x, code_x) <- getSomeReg x (reg_x, _format_x, code_x) <- getSomeReg x
...@@ -737,24 +841,23 @@ getRegister' config plat expr ...@@ -737,24 +841,23 @@ getRegister' config plat expr
CmmMachOp (MO_S_Shr w) [x, y] | w == W16 -> do CmmMachOp (MO_S_Shr w) [x, y] | w == W16 -> do
(reg_x, _format_x, code_x) <- getSomeReg x (reg_x, _format_x, code_x) <- getSomeReg x
(reg_y, _format_y, code_y) <- getSomeReg y (reg_y, _format_y, code_y) <- getSomeReg y
return $ Any (intFormat w) (\dst -> code_x `appOL` code_y `snocOL` annExpr expr (SXTH (OpReg w reg_x) (OpReg w reg_x)) `snocOL` (ASR (OpReg w dst) (OpReg w reg_x) (OpReg w reg_y))) return $ Any (intFormat w) (\dst -> code_x `appOL` code_y `snocOL` annExpr expr (SXTH (OpReg w reg_x) (OpReg w reg_x)) `snocOL`
(ASR (OpReg w dst) (OpReg w reg_x) (OpReg w reg_y)))
CmmMachOp (MO_S_Shr w) [x, (CmmLit (CmmInt n _))] | w == W32, 0 <= n, n < 32 -> do
(reg_x, _format_x, code_x) <- getSomeReg x
return $ Any (intFormat w) (\dst -> code_x `snocOL` annExpr expr (ASR (OpReg w dst) (OpReg w reg_x) (OpImm (ImmInteger n))))
CmmMachOp (MO_S_Shr w) [x, (CmmLit (CmmInt n _))] | w == W64, 0 <= n, n < 64 -> do CmmMachOp (MO_S_Shr w) [x, (CmmLit (CmmInt n _))]
| w == W32 || w == W64
, 0 <= n, n < fromIntegral (widthInBits w) -> do
(reg_x, _format_x, code_x) <- getSomeReg x (reg_x, _format_x, code_x) <- getSomeReg x
return $ Any (intFormat w) (\dst -> code_x `snocOL` annExpr expr (ASR (OpReg w dst) (OpReg w reg_x) (OpImm (ImmInteger n)))) return $ Any (intFormat w) (\dst -> code_x `snocOL` annExpr expr (ASR (OpReg w dst) (OpReg w reg_x) (OpImm (ImmInteger n))))
CmmMachOp (MO_U_Shr w) [x, (CmmLit (CmmInt n _))] | w == W8, 0 <= n, n < 8 -> do CmmMachOp (MO_U_Shr w) [x, (CmmLit (CmmInt n _))] | w == W8, 0 <= n, n < 8 -> do
(reg_x, _format_x, code_x) <- getSomeReg x (reg_x, _format_x, code_x) <- getSomeReg x
return $ Any (intFormat w) (\dst -> code_x `snocOL` annExpr expr (UBFX (OpReg w dst) (OpReg w reg_x) (OpImm (ImmInteger n)) (OpImm (ImmInteger (8-n))))) return $ Any (intFormat w) (\dst -> code_x `snocOL` annExpr expr (UBFX (OpReg w dst) (OpReg w reg_x) (OpImm (ImmInteger n)) (OpImm (ImmInteger (8-n)))))
CmmMachOp (MO_U_Shr w) [x, y] | w == W8 -> do CmmMachOp (MO_U_Shr w) [x, y] | w == W8 -> do
(reg_x, _format_x, code_x) <- getSomeReg x (reg_x, _format_x, code_x) <- getSomeReg x
(reg_y, _format_y, code_y) <- getSomeReg y (reg_y, _format_y, code_y) <- getSomeReg y
return $ Any (intFormat w) (\dst -> code_x `appOL` code_y `snocOL` annExpr expr (UXTB (OpReg w reg_x) (OpReg w reg_x)) `snocOL` (ASR (OpReg w dst) (OpReg w reg_x) (OpReg w reg_y))) return $ Any (intFormat w) (\dst -> code_x `appOL` code_y `snocOL` annExpr expr (UXTB (OpReg w reg_x) (OpReg w reg_x)) `snocOL`
(ASR (OpReg w dst) (OpReg w reg_x) (OpReg w reg_y)))
CmmMachOp (MO_U_Shr w) [x, (CmmLit (CmmInt n _))] | w == W16, 0 <= n, n < 16 -> do CmmMachOp (MO_U_Shr w) [x, (CmmLit (CmmInt n _))] | w == W16, 0 <= n, n < 16 -> do
(reg_x, _format_x, code_x) <- getSomeReg x (reg_x, _format_x, code_x) <- getSomeReg x
...@@ -762,13 +865,12 @@ getRegister' config plat expr ...@@ -762,13 +865,12 @@ getRegister' config plat expr
CmmMachOp (MO_U_Shr w) [x, y] | w == W16 -> do CmmMachOp (MO_U_Shr w) [x, y] | w == W16 -> do
(reg_x, _format_x, code_x) <- getSomeReg x (reg_x, _format_x, code_x) <- getSomeReg x
(reg_y, _format_y, code_y) <- getSomeReg y (reg_y, _format_y, code_y) <- getSomeReg y
return $ Any (intFormat w) (\dst -> code_x `appOL` code_y `snocOL` annExpr expr (UXTH (OpReg w reg_x) (OpReg w reg_x)) `snocOL` (ASR (OpReg w dst) (OpReg w reg_x) (OpReg w reg_y))) return $ Any (intFormat w) (\dst -> code_x `appOL` code_y `snocOL` annExpr expr (UXTH (OpReg w reg_x) (OpReg w reg_x))
`snocOL` (ASR (OpReg w dst) (OpReg w reg_x) (OpReg w reg_y)))
CmmMachOp (MO_U_Shr w) [x, (CmmLit (CmmInt n _))] | w == W32, 0 <= n, n < 32 -> do
(reg_x, _format_x, code_x) <- getSomeReg x
return $ Any (intFormat w) (\dst -> code_x `snocOL` annExpr expr (LSR (OpReg w dst) (OpReg w reg_x) (OpImm (ImmInteger n))))
CmmMachOp (MO_U_Shr w) [x, (CmmLit (CmmInt n _))] | w == W64, 0 <= n, n < 64 -> do CmmMachOp (MO_U_Shr w) [x, (CmmLit (CmmInt n _))]
| w == W32 || w == W64
, 0 <= n, n < fromIntegral (widthInBits w) -> do
(reg_x, _format_x, code_x) <- getSomeReg x (reg_x, _format_x, code_x) <- getSomeReg x
return $ Any (intFormat w) (\dst -> code_x `snocOL` annExpr expr (LSR (OpReg w dst) (OpReg w reg_x) (OpImm (ImmInteger n)))) return $ Any (intFormat w) (\dst -> code_x `snocOL` annExpr expr (LSR (OpReg w dst) (OpReg w reg_x) (OpImm (ImmInteger n))))
...@@ -791,17 +893,51 @@ getRegister' config plat expr ...@@ -791,17 +893,51 @@ getRegister' config plat expr
-- withTempFloatReg w op = OpReg w <$> getNewRegNat (floatFormat w) >>= op -- withTempFloatReg w op = OpReg w <$> getNewRegNat (floatFormat w) >>= op
-- A "plain" operation. -- A "plain" operation.
bitOp w op = do bitOpImm w op encode_imm = do
-- compute x<m> <- x -- compute x<m> <- x
-- compute x<o> <- y -- compute x<o> <- y
-- <OP> x<n>, x<m>, x<o> -- <OP> x<n>, x<m>, x<o>
(reg_x, format_x, code_x) <- getSomeReg x (reg_x, format_x, code_x) <- getSomeReg x
(reg_y, format_y, code_y) <- getSomeReg y (op_y, format_y, code_y) <- case y of
massertPpr (isIntFormat format_x == isIntFormat format_y) $ text "bitOp: incompatible" CmmLit (CmmInt n w)
| Just imm_operand_y <- encode_imm n w
-> return (imm_operand_y, intFormat w, nilOL)
_ -> do
(reg_y, format_y, code_y) <- getSomeReg y
return (OpReg w reg_y, format_y, code_y)
massertPpr (isIntFormat format_x == isIntFormat format_y) $ text "bitOpImm: incompatible"
return $ Any (intFormat w) (\dst -> return $ Any (intFormat w) (\dst ->
code_x `appOL` code_x `appOL`
code_y `appOL` code_y `appOL`
op (OpReg w dst) (OpReg w reg_x) (OpReg w reg_y)) op (OpReg w dst) (OpReg w reg_x) op_y)
-- A (potentially signed) integer operation.
-- In the case of 8- and 16-bit signed arithmetic we must first
-- sign-extend both arguments to 32-bits.
-- See Note [Signed arithmetic on AArch64].
intOpImm :: Bool -> Width -> (Operand -> Operand -> Operand -> OrdList Instr) -> (Integer -> Width -> Maybe Operand) -> NatM (Register)
intOpImm {- is signed -} True w op _encode_imm = intOp True w op
intOpImm False w op encode_imm = do
-- compute x<m> <- x
-- compute x<o> <- y
-- <OP> x<n>, x<m>, x<o>
(reg_x, format_x, code_x) <- getSomeReg x
(op_y, format_y, code_y) <- case y of
CmmLit (CmmInt n w)
| Just imm_operand_y <- encode_imm n w
-> return (imm_operand_y, intFormat w, nilOL)
_ -> do
(reg_y, format_y, code_y) <- getSomeReg y
return (OpReg w reg_y, format_y, code_y)
massertPpr (isIntFormat format_x && isIntFormat format_y) $ text "intOp: non-int"
-- This is the width of the registers on which the operation
-- should be performed.
let w' = opRegWidth w
return $ Any (intFormat w) $ \dst ->
code_x `appOL`
code_y `appOL`
op (OpReg w' dst) (OpReg w' reg_x) (op_y) `appOL`
truncateReg w' w dst -- truncate back to the operand's original width
-- A (potentially signed) integer operation. -- A (potentially signed) integer operation.
-- In the case of 8- and 16-bit signed arithmetic we must first -- In the case of 8- and 16-bit signed arithmetic we must first
...@@ -847,9 +983,9 @@ getRegister' config plat expr ...@@ -847,9 +983,9 @@ getRegister' config plat expr
case op of case op of
-- Integer operations -- Integer operations
-- Add/Sub should only be Integer Options. -- Add/Sub should only be Integer Options.
MO_Add w -> intOp False w (\d x y -> unitOL $ annExpr expr (ADD d x y)) MO_Add w -> intOpImm False w (\d x y -> unitOL $ annExpr expr (ADD d x y)) getArithImm
-- TODO: Handle sub-word case -- TODO: Handle sub-word case
MO_Sub w -> intOp False w (\d x y -> unitOL $ annExpr expr (SUB d x y)) MO_Sub w -> intOpImm False w (\d x y -> unitOL $ annExpr expr (SUB d x y)) getArithImm
-- Note [CSET] -- Note [CSET]
-- ~~~~~~~~~~~ -- ~~~~~~~~~~~
...@@ -891,8 +1027,8 @@ getRegister' config plat expr ...@@ -891,8 +1027,8 @@ getRegister' config plat expr
-- N.B. We needn't sign-extend sub-word size (in)equality comparisons -- N.B. We needn't sign-extend sub-word size (in)equality comparisons
-- since we don't care about ordering. -- since we don't care about ordering.
MO_Eq w -> bitOp w (\d x y -> toOL [ CMP x y, CSET d EQ ]) MO_Eq w -> bitOpImm w (\d x y -> toOL [ CMP x y, CSET d EQ ]) getArithImm
MO_Ne w -> bitOp w (\d x y -> toOL [ CMP x y, CSET d NE ]) MO_Ne w -> bitOpImm w (\d x y -> toOL [ CMP x y, CSET d NE ]) getArithImm
-- Signed multiply/divide -- Signed multiply/divide
MO_Mul w -> intOp True w (\d x y -> unitOL $ MUL d x y) MO_Mul w -> intOp True w (\d x y -> unitOL $ MUL d x y)
...@@ -921,10 +1057,10 @@ getRegister' config plat expr ...@@ -921,10 +1057,10 @@ getRegister' config plat expr
MO_S_Lt w -> intOp True w (\d x y -> toOL [ CMP x y, CSET d SLT ]) MO_S_Lt w -> intOp True w (\d x y -> toOL [ CMP x y, CSET d SLT ])
-- Unsigned comparisons -- Unsigned comparisons
MO_U_Ge w -> intOp False w (\d x y -> toOL [ CMP x y, CSET d UGE ]) MO_U_Ge w -> intOpImm False w (\d x y -> toOL [ CMP x y, CSET d UGE ]) getArithImm
MO_U_Le w -> intOp False w (\d x y -> toOL [ CMP x y, CSET d ULE ]) MO_U_Le w -> intOpImm False w (\d x y -> toOL [ CMP x y, CSET d ULE ]) getArithImm
MO_U_Gt w -> intOp False w (\d x y -> toOL [ CMP x y, CSET d UGT ]) MO_U_Gt w -> intOpImm False w (\d x y -> toOL [ CMP x y, CSET d UGT ]) getArithImm
MO_U_Lt w -> intOp False w (\d x y -> toOL [ CMP x y, CSET d ULT ]) MO_U_Lt w -> intOpImm False w (\d x y -> toOL [ CMP x y, CSET d ULT ]) getArithImm
-- Floating point arithmetic -- Floating point arithmetic
MO_F_Add w -> floatOp w (\d x y -> unitOL $ ADD d x y) MO_F_Add w -> floatOp w (\d x y -> unitOL $ ADD d x y)
...@@ -947,9 +1083,9 @@ getRegister' config plat expr ...@@ -947,9 +1083,9 @@ getRegister' config plat expr
MO_F_Lt w -> floatCond w (\d x y -> toOL [ CMP x y, CSET d OLT ]) -- x < y <=> y >= x MO_F_Lt w -> floatCond w (\d x y -> toOL [ CMP x y, CSET d OLT ]) -- x < y <=> y >= x
-- Bitwise operations -- Bitwise operations
MO_And w -> bitOp w (\d x y -> unitOL $ AND d x y) MO_And w -> bitOpImm w (\d x y -> unitOL $ AND d x y) getBitmaskImm
MO_Or w -> bitOp w (\d x y -> unitOL $ ORR d x y) MO_Or w -> bitOpImm w (\d x y -> unitOL $ ORR d x y) getBitmaskImm
MO_Xor w -> bitOp w (\d x y -> unitOL $ EOR d x y) MO_Xor w -> bitOpImm w (\d x y -> unitOL $ EOR d x y) getBitmaskImm
MO_Shl w -> intOp False w (\d x y -> unitOL $ LSL d x y) MO_Shl w -> intOp False w (\d x y -> unitOL $ LSL d x y)
MO_U_Shr w -> intOp False w (\d x y -> unitOL $ LSR d x y) MO_U_Shr w -> intOp False w (\d x y -> unitOL $ LSR d x y)
MO_S_Shr w -> intOp True w (\d x y -> unitOL $ ASR d x y) MO_S_Shr w -> intOp True w (\d x y -> unitOL $ ASR d x y)
...@@ -999,7 +1135,7 @@ getRegister' config plat expr ...@@ -999,7 +1135,7 @@ getRegister' config plat expr
where where
isNbitEncodeable :: Int -> Integer -> Bool isNbitEncodeable :: Int -> Integer -> Bool
isNbitEncodeable n i = let shift = n - 1 in (-1 `shiftL` shift) <= i && i < (1 `shiftL` shift) isNbitEncodeable n_bits i = let shift = n_bits - 1 in (-1 `shiftL` shift) <= i && i < (1 `shiftL` shift)
-- N.B. MUL does not set the overflow flag. -- N.B. MUL does not set the overflow flag.
do_mul_may_oflo :: Width -> CmmExpr -> CmmExpr -> NatM Register do_mul_may_oflo :: Width -> CmmExpr -> CmmExpr -> NatM Register
...@@ -1118,20 +1254,8 @@ getAmode :: Platform ...@@ -1118,20 +1254,8 @@ getAmode :: Platform
-- OPTIMIZATION WARNING: Addressing modes. -- OPTIMIZATION WARNING: Addressing modes.
-- Addressing options: -- Addressing options:
-- LDUR/STUR: imm9: -256 - 255 getAmode platform w (CmmRegOff reg off)
getAmode platform _ (CmmRegOff reg off) | -256 <= off, off <= 255 | isOffsetImm off w
= return $ Amode (AddrRegImm reg' off') nilOL
where reg' = getRegisterReg platform reg
off' = ImmInt off
-- LDR/STR: imm12: if reg is 32bit: 0 -- 16380 in multiples of 4
getAmode platform W32 (CmmRegOff reg off)
| 0 <= off, off <= 16380, off `mod` 4 == 0
= return $ Amode (AddrRegImm reg' off') nilOL
where reg' = getRegisterReg platform reg
off' = ImmInt off
-- LDR/STR: imm12: if reg is 64bit: 0 -- 32760 in multiples of 8
getAmode platform W64 (CmmRegOff reg off)
| 0 <= off, off <= 32760, off `mod` 8 == 0
= return $ Amode (AddrRegImm reg' off') nilOL = return $ Amode (AddrRegImm reg' off') nilOL
where reg' = getRegisterReg platform reg where reg' = getRegisterReg platform reg
off' = ImmInt off off' = ImmInt off
...@@ -1140,15 +1264,15 @@ getAmode platform W64 (CmmRegOff reg off) ...@@ -1140,15 +1264,15 @@ getAmode platform W64 (CmmRegOff reg off)
-- CmmStore (CmmMachOp (MO_Add w) [CmmLoad expr, CmmLit (CmmInt n w')]) (expr2) -- CmmStore (CmmMachOp (MO_Add w) [CmmLoad expr, CmmLit (CmmInt n w')]) (expr2)
-- E.g. a CmmStoreOff really. This can be translated to `str $expr2, [$expr, #n ] -- E.g. a CmmStoreOff really. This can be translated to `str $expr2, [$expr, #n ]
-- for `n` in range. -- for `n` in range.
getAmode _platform _ (CmmMachOp (MO_Add _w) [expr, CmmLit (CmmInt off _w')]) getAmode _platform w (CmmMachOp (MO_Add _w) [expr, CmmLit (CmmInt off _w')])
| -256 <= off, off <= 255 | isOffsetImm (fromIntegral off) w
= do (reg, _format, code) <- getSomeReg expr = do (reg, _format, code) <- getSomeReg expr
return $ Amode (AddrRegImm reg (ImmInteger off)) code return $ Amode (AddrRegImm reg (ImmInteger off)) code
getAmode _platform _ (CmmMachOp (MO_Sub _w) [expr, CmmLit (CmmInt off _w')]) getAmode _platform w (CmmMachOp (MO_Sub _w) [expr, CmmLit (CmmInt off _w')])
| -256 <= -off, -off <= 255 | isOffsetImm (fromIntegral $ -off) w
= do (reg, _format, code) <- getSomeReg expr = do (reg, _format, code) <- getSomeReg expr
return $ Amode (AddrRegImm reg (ImmInteger (-off))) code return $ Amode (AddrRegImm reg (ImmInteger $ -off)) code
-- Generic case -- Generic case
getAmode _platform _ expr getAmode _platform _ expr
......
...@@ -110,6 +110,7 @@ regUsageOfInstr platform instr = case instr of ...@@ -110,6 +110,7 @@ regUsageOfInstr platform instr = case instr of
LSR dst src1 src2 -> usage (regOp src1 ++ regOp src2, regOp dst) LSR dst src1 src2 -> usage (regOp src1 ++ regOp src2, regOp dst)
MOV dst src -> usage (regOp src, regOp dst) MOV dst src -> usage (regOp src, regOp dst)
MOVK dst src -> usage (regOp src, regOp dst) MOVK dst src -> usage (regOp src, regOp dst)
MOVZ dst src -> usage (regOp src, regOp dst)
MVN dst src -> usage (regOp src, regOp dst) MVN dst src -> usage (regOp src, regOp dst)
ORR dst src1 src2 -> usage (regOp src1 ++ regOp src2, regOp dst) ORR dst src1 src2 -> usage (regOp src1 ++ regOp src2, regOp dst)
ROR dst src1 src2 -> usage (regOp src1 ++ regOp src2, regOp dst) ROR dst src1 src2 -> usage (regOp src1 ++ regOp src2, regOp dst)
...@@ -251,6 +252,7 @@ patchRegsOfInstr instr env = case instr of ...@@ -251,6 +252,7 @@ patchRegsOfInstr instr env = case instr of
LSR o1 o2 o3 -> LSR (patchOp o1) (patchOp o2) (patchOp o3) LSR o1 o2 o3 -> LSR (patchOp o1) (patchOp o2) (patchOp o3)
MOV o1 o2 -> MOV (patchOp o1) (patchOp o2) MOV o1 o2 -> MOV (patchOp o1) (patchOp o2)
MOVK o1 o2 -> MOVK (patchOp o1) (patchOp o2) MOVK o1 o2 -> MOVK (patchOp o1) (patchOp o2)
MOVZ o1 o2 -> MOVZ (patchOp o1) (patchOp o2)
MVN o1 o2 -> MVN (patchOp o1) (patchOp o2) MVN o1 o2 -> MVN (patchOp o1) (patchOp o2)
ORR o1 o2 o3 -> ORR (patchOp o1) (patchOp o2) (patchOp o3) ORR o1 o2 o3 -> ORR (patchOp o1) (patchOp o2) (patchOp o3)
ROR o1 o2 o3 -> ROR (patchOp o1) (patchOp o2) (patchOp o3) ROR o1 o2 o3 -> ROR (patchOp o1) (patchOp o2) (patchOp o3)
...@@ -381,9 +383,8 @@ mkSpillInstr config reg delta slot = ...@@ -381,9 +383,8 @@ mkSpillInstr config reg delta slot =
where where
a .&~. b = a .&. (complement b) a .&~. b = a .&. (complement b)
fmt = case reg of fmt = fmtOfRealReg (case reg of { RegReal r -> r; _ -> panic "Expected real reg"})
RegReal (RealRegSingle n) | n < 32 -> II64
_ -> FF64
mkIp0SpillAddr imm = ANN (text "Spill: IP0 <- SP + " <> int imm) $ ADD ip0 sp (OpImm (ImmInt imm)) mkIp0SpillAddr imm = ANN (text "Spill: IP0 <- SP + " <> int imm) $ ADD ip0 sp (OpImm (ImmInt imm))
mkStrSp imm = ANN (text "Spill@" <> int (off - delta)) $ STR fmt (OpReg W64 reg) (OpAddr (AddrRegImm (regSingle 31) (ImmInt imm))) mkStrSp imm = ANN (text "Spill@" <> int (off - delta)) $ STR fmt (OpReg W64 reg) (OpAddr (AddrRegImm (regSingle 31) (ImmInt imm)))
mkStrIp0 imm = ANN (text "Spill@" <> int (off - delta)) $ STR fmt (OpReg W64 reg) (OpAddr (AddrRegImm (regSingle 16) (ImmInt imm))) mkStrIp0 imm = ANN (text "Spill@" <> int (off - delta)) $ STR fmt (OpReg W64 reg) (OpAddr (AddrRegImm (regSingle 16) (ImmInt imm)))
...@@ -408,9 +409,7 @@ mkLoadInstr config reg delta slot = ...@@ -408,9 +409,7 @@ mkLoadInstr config reg delta slot =
where where
a .&~. b = a .&. (complement b) a .&~. b = a .&. (complement b)
fmt = case reg of fmt = fmtOfRealReg (case reg of { RegReal r -> r; _ -> panic "Expected real reg"})
RegReal (RealRegSingle n) | n < 32 -> II64
_ -> FF64
mkIp0SpillAddr imm = ANN (text "Reload: IP0 <- SP + " <> int imm) $ ADD ip0 sp (OpImm (ImmInt imm)) mkIp0SpillAddr imm = ANN (text "Reload: IP0 <- SP + " <> int imm) $ ADD ip0 sp (OpImm (ImmInt imm))
mkLdrSp imm = ANN (text "Reload@" <> int (off - delta)) $ LDR fmt (OpReg W64 reg) (OpAddr (AddrRegImm (regSingle 31) (ImmInt imm))) mkLdrSp imm = ANN (text "Reload@" <> int (off - delta)) $ LDR fmt (OpReg W64 reg) (OpAddr (AddrRegImm (regSingle 31) (ImmInt imm)))
...@@ -619,7 +618,7 @@ data Instr ...@@ -619,7 +618,7 @@ data Instr
| MOV Operand Operand -- rd = rn or rd = #i | MOV Operand Operand -- rd = rn or rd = #i
| MOVK Operand Operand | MOVK Operand Operand
-- | MOVN Operand Operand -- | MOVN Operand Operand
-- | MOVZ Operand Operand | MOVZ Operand Operand
| MVN Operand Operand -- rd = ~rn | MVN Operand Operand -- rd = ~rn
| ORN Operand Operand Operand -- rd = rn | ~op2 | ORN Operand Operand Operand -- rd = rn | ~op2
| ORR Operand Operand Operand -- rd = rn | op2 | ORR Operand Operand Operand -- rd = rn | op2
...@@ -708,6 +707,7 @@ instrCon i = ...@@ -708,6 +707,7 @@ instrCon i =
LSR{} -> "LSR" LSR{} -> "LSR"
MOV{} -> "MOV" MOV{} -> "MOV"
MOVK{} -> "MOVK" MOVK{} -> "MOVK"
MOVZ{} -> "MOVZ"
MVN{} -> "MVN" MVN{} -> "MVN"
ORN{} -> "ORN" ORN{} -> "ORN"
ORR{} -> "ORR" ORR{} -> "ORR"
...@@ -782,6 +782,9 @@ wzr = OpReg W32 (RegReal (RealRegSingle (-1))) ...@@ -782,6 +782,9 @@ wzr = OpReg W32 (RegReal (RealRegSingle (-1)))
sp = OpReg W64 (RegReal (RealRegSingle 31)) sp = OpReg W64 (RegReal (RealRegSingle 31))
ip0 = OpReg W64 (RegReal (RealRegSingle 16)) ip0 = OpReg W64 (RegReal (RealRegSingle 16))
reg_zero :: Reg
reg_zero = RegReal (RealRegSingle (-1))
_x :: Int -> Operand _x :: Int -> Operand
_x i = OpReg W64 (RegReal (RealRegSingle i)) _x i = OpReg W64 (RegReal (RealRegSingle i))
x0, x1, x2, x3, x4, x5, x6, x7 :: Operand x0, x1, x2, x3, x4, x5, x6, x7 :: Operand
......
...@@ -417,6 +417,7 @@ pprInstr platform instr = case instr of ...@@ -417,6 +417,7 @@ pprInstr platform instr = case instr of
| isFloatOp o1 || isFloatOp o2 -> op2 (text "\tfmov") o1 o2 | isFloatOp o1 || isFloatOp o2 -> op2 (text "\tfmov") o1 o2
| otherwise -> op2 (text "\tmov") o1 o2 | otherwise -> op2 (text "\tmov") o1 o2
MOVK o1 o2 -> op2 (text "\tmovk") o1 o2 MOVK o1 o2 -> op2 (text "\tmovk") o1 o2
MOVZ o1 o2 -> op2 (text "\tmovz") o1 o2
MVN o1 o2 -> op2 (text "\tmvn") o1 o2 MVN o1 o2 -> op2 (text "\tmvn") o1 o2
ORN o1 o2 o3 -> op3 (text "\torn") o1 o2 o3 ORN o1 o2 o3 -> op3 (text "\torn") o1 o2 o3
ORR o1 o2 o3 -> op3 (text "\torr") o1 o2 o3 ORR o1 o2 o3 -> op3 (text "\torr") o1 o2 o3
......
...@@ -77,6 +77,8 @@ litToImm (CmmInt i w) = ImmInteger (narrowS w i) ...@@ -77,6 +77,8 @@ litToImm (CmmInt i w) = ImmInteger (narrowS w i)
-- narrow to the width: a CmmInt might be out of -- narrow to the width: a CmmInt might be out of
-- range, but we assume that ImmInteger only contains -- range, but we assume that ImmInteger only contains
-- in-range values. A signed value should be fine here. -- in-range values. A signed value should be fine here.
-- AK: We do call this with out of range values, however
-- it just truncates as we would expect.
litToImm (CmmFloat f W32) = ImmFloat f litToImm (CmmFloat f W32) = ImmFloat f
litToImm (CmmFloat f W64) = ImmDouble f litToImm (CmmFloat f W64) = ImmDouble f
litToImm (CmmLabel l) = ImmCLbl l litToImm (CmmLabel l) = ImmCLbl l
...@@ -147,6 +149,13 @@ classOfRealReg (RealRegSingle i) ...@@ -147,6 +149,13 @@ classOfRealReg (RealRegSingle i)
| i < 32 = RcInteger | i < 32 = RcInteger
| otherwise = RcDouble | otherwise = RcDouble
fmtOfRealReg :: RealReg -> Format
fmtOfRealReg real_reg =
case classOfRealReg real_reg of
RcInteger -> II64
RcDouble -> FF64
RcFloat -> panic "No float regs on arm"
regDotColor :: RealReg -> SDoc regDotColor :: RealReg -> SDoc
regDotColor reg regDotColor reg
= case classOfRealReg reg of = case classOfRealReg reg of
......
...@@ -245,6 +245,10 @@ pprGNUSectionHeader config t suffix = ...@@ -245,6 +245,10 @@ pprGNUSectionHeader config t suffix =
OtherSection _ -> OtherSection _ ->
panic "PprBase.pprGNUSectionHeader: unknown section type" panic "PprBase.pprGNUSectionHeader: unknown section type"
flags = case t of flags = case t of
Text
| OSMinGW32 <- platformOS platform
-> text ",\"xr\""
| otherwise -> text ",\"ax\"," <> sectionType platform "progbits"
CString CString
| OSMinGW32 <- platformOS platform | OSMinGW32 <- platformOS platform
-> empty -> empty
......
...@@ -1001,7 +1001,7 @@ livenessBack ...@@ -1001,7 +1001,7 @@ livenessBack
livenessBack _ liveregs _ done [] = (liveregs, done) livenessBack _ liveregs _ done [] = (liveregs, done)
livenessBack platform liveregs blockmap acc (instr : instrs) livenessBack platform liveregs blockmap acc (instr : instrs)
= let (liveregs', instr') = liveness1 platform liveregs blockmap instr = let !(!liveregs', instr') = liveness1 platform liveregs blockmap instr
in livenessBack platform liveregs' blockmap (instr' : acc) instrs in livenessBack platform liveregs' blockmap (instr' : acc) instrs
...@@ -1024,15 +1024,15 @@ liveness1 platform liveregs blockmap (LiveInstr instr _) ...@@ -1024,15 +1024,15 @@ liveness1 platform liveregs blockmap (LiveInstr instr _)
= (liveregs1, LiveInstr instr = (liveregs1, LiveInstr instr
(Just $ Liveness (Just $ Liveness
{ liveBorn = emptyUniqSet { liveBorn = emptyUniqSet
, liveDieRead = mkUniqSet r_dying , liveDieRead = r_dying
, liveDieWrite = mkUniqSet w_dying })) , liveDieWrite = w_dying }))
| otherwise | otherwise
= (liveregs_br, LiveInstr instr = (liveregs_br, LiveInstr instr
(Just $ Liveness (Just $ Liveness
{ liveBorn = emptyUniqSet { liveBorn = emptyUniqSet
, liveDieRead = mkUniqSet r_dying_br , liveDieRead = mkUniqSet r_dying_br
, liveDieWrite = mkUniqSet w_dying })) , liveDieWrite = w_dying }))
where where
!(RU read written) = regUsageOfInstr platform instr !(RU read written) = regUsageOfInstr platform instr
...@@ -1044,10 +1044,12 @@ liveness1 platform liveregs blockmap (LiveInstr instr _) ...@@ -1044,10 +1044,12 @@ liveness1 platform liveregs blockmap (LiveInstr instr _)
-- registers that are not live beyond this point, are recorded -- registers that are not live beyond this point, are recorded
-- as dying here. -- as dying here.
r_dying = [ reg | reg <- read, reg `notElem` written, r_dying = mkUniqSet
[ reg | reg <- read, reg `notElem` written,
not (elementOfUniqSet reg liveregs) ] not (elementOfUniqSet reg liveregs) ]
w_dying = [ reg | reg <- written, w_dying = mkUniqSet
[ reg | reg <- written,
not (elementOfUniqSet reg liveregs) ] not (elementOfUniqSet reg liveregs) ]
-- union in the live regs from all the jump destinations of this -- union in the live regs from all the jump destinations of this
...@@ -1067,6 +1069,6 @@ liveness1 platform liveregs blockmap (LiveInstr instr _) ...@@ -1067,6 +1069,6 @@ liveness1 platform liveregs blockmap (LiveInstr instr _)
-- registers that are live only in the branch targets should -- registers that are live only in the branch targets should
-- be listed as dying here. -- be listed as dying here.
live_branch_only = live_from_branch `minusUniqSet` liveregs live_branch_only = live_from_branch `minusUniqSet` liveregs
r_dying_br = nonDetEltsUniqSet (mkUniqSet r_dying `unionUniqSets` r_dying_br = nonDetEltsUniqSet (r_dying `unionUniqSets`
live_branch_only) live_branch_only)
-- See Note [Unique Determinism and code generation] -- See Note [Unique Determinism and code generation]