FreeBSD/ports ab08196 — www/onionshare-cli distinfo Makefile, www/onionshare-cli/files patch-setup.py

www/onionshare-cli: update 2.6_4 to 2.7

2.6 imports werkzeug.urls.url_quote, which is gone in Werkzeug 3, so
onionshare_cli fails to import.  2.6.1 and later work with Werkzeug 3.

- Build with pep517 and drop the setup.py patch.
- Add the Flask-Compress, gevent, packaging, qrcode, waitress and
  werkzeug dependencies 2.7 needs, and follow upstream's minimums for
  flask-socketio, PyNaCl, requests and urllib3.  Keep net/py-cepa (the
  stem fork) as before, now >=1.8.4; Flask-Compress >=1.14.
- Patch the installed metadata to match the tree, so pip check passes:
  relax werkzeug==3.1.9 to >=3.1.8 and flask-compress>=1.24 to >=1.14
  (only Compress().init_app() is used), drop the qrcode<8 cap (the
  tree has 8.2), require cepa instead of stem==1.8.1 (py-cepa installs
  the stem package), and drop setuptools, wheel, cffi, cython and
  pkgconfig, which are not imported at run time.

While here, add concurrent to USE_PYTHON.


    [5 lines not shown]
DeltaFile
+22-14www/onionshare-cli/Makefile
+0-29www/onionshare-cli/files/patch-setup.py
+3-3www/onionshare-cli/distinfo
+25-463 files

FreeBSD/ports abf08ca — devel/electron45 distinfo, devel/electron45/files patch-media_base_media__switches.cc patch-electron_BUILD.gn

devel/electron45: Update to 45.4.1

Changelog:
- https://github.com/electron/electron/releases/tag/v45.3.4
- https://github.com/electron/electron/releases/tag/v45.4.1

Reported by:    GitHub (watch releases)
DeltaFile
+58-132devel/electron45/files/packagejsons/yarn.lock
+9-9devel/electron45/files/patch-v8_BUILD.gn
+13-4devel/electron45/files/patch-electron_spec_chromium.spec.ts
+7-7devel/electron45/files/patch-media_base_media__switches.cc
+7-7devel/electron45/files/patch-electron_BUILD.gn
+7-7devel/electron45/distinfo
+101-16626 files not shown
+196-23332 files

LLVM/project 5689d1b — llvm/lib/Target/ARM ARMISelLowering.cpp, llvm/test/CodeGen/ARM bf16-instructions.ll

[ARM] Promote bf16 fp rounding operations. (#244867)

Similar to other operations we promote bf16 fp round operations to fp32
DeltaFile
+161-30llvm/test/CodeGen/ARM/bf16-instructions.ll
+3-1llvm/lib/Target/ARM/ARMISelLowering.cpp
+164-312 files

FreeBSD/ports fc57207 — net-mgmt/monitoring-plugins Makefile

net-mgmt/monitoring-plugins: Use net/radcli

Use libradcli instead of the outdated libradiusclient-ng, which does not
receive security fixes such as the one for BlastRADIUS.

PR:             286305
Sponsored by:   Netzkommune GmbH
DeltaFile
+2-2net-mgmt/monitoring-plugins/Makefile
+2-21 files

LLVM/project 6fc3a9a — llvm/lib/Transforms/Vectorize VPlanTransforms.cpp, llvm/test/Transforms/LoopVectorize/AArch64 transform-narrow-interleave-to-widen-memory.ll

[VPlan] Only narrow store groups storing a single load group (#244730)

When narrowing a store group whose members are all load interleave group
values, only the defining group of each member was checked to hold it at
the matching index. Members could come from different load groups, but
the store group was narrowed to a copy of the first member's group only.
Require all members to come from the load group of member 0.
DeltaFile
+93-0llvm/test/Transforms/LoopVectorize/AArch64/transform-narrow-interleave-to-widen-memory.ll
+7-9llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp
+100-92 files

LLVM/project 5910012 — llvm/lib/CodeGen TargetInstrInfo.cpp MachineInstr.cpp

Move folding register checks into mayFoldInlineAsmRegOp so that it's available everywhere.
DeltaFile
+9-0llvm/lib/CodeGen/MachineInstr.cpp
+1-7llvm/lib/CodeGen/TargetInstrInfo.cpp
+10-72 files

LLVM/project b7d9b90 — llvm/test/CodeGen/X86 greedy-inline-asm-fold.mir

[TargetInstrInfo] Address review: autogenerate greedy-inline-asm-fold.mir checks

Generate the checks with update_mir_test_checks.py so that the spills and
reloads around each folded inline asm are verified, not just the INLINEASM
itself. Fix the "=r" comment to describe the C "+r" operand, note that which
"+rm" pair greedy folds is its own choice, and add a "+&rm" case on an
uninitialized value showing that folding a pair whose tied use is undef
stores to the slot without loading from it.

Assisted-by: Claude Opus 5.5
DeltaFile
+94-8llvm/test/CodeGen/X86/greedy-inline-asm-fold.mir
+94-81 files

LLVM/project 9f631c7 — llvm/test/CodeGen/X86 greedy-inline-asm-fold.mir

Test a tie whose def moves when a folded operand is before it

Folding a "+rm" pair before a "+r" pair moves the "+r" pair's def, so
both ends of its tie get new indices. The other tests only moved the
use.

Assisted-by: Claude Opus 5.5
DeltaFile
+51-0llvm/test/CodeGen/X86/greedy-inline-asm-fold.mir
+51-01 files

LLVM/project ae0bf55 — llvm/lib/CodeGen TargetInstrInfo.cpp

Update llvm/lib/CodeGen/TargetInstrInfo.cpp

Co-authored-by: Nick Desaulniers <ndesaulniers at google.com>
DeltaFile
+1-1llvm/lib/CodeGen/TargetInstrInfo.cpp
+1-11 files

LLVM/project 7d77a38 — llvm/lib/CodeGen TargetInstrInfo.cpp, llvm/test/CodeGen/X86 greedy-inline-asm-fold.mir

[TargetInstrInfo] Fix folding inline asm operands next to tied operands

foldInlineAsmMemOperand() swapped a register operand for the target's
memory operands with MachineInstr::removeOperand(), which asserts when a
later operand is tied, because moving it would break the tie. Inline asm
lists every input after every output, so folding any operand that comes
before another tied pair asserted, e.g. an "rm" input followed by the
input of a "+r" operand, or one of two "+rm" operands. Without
assertions, the moved operands kept stale tie indices. Untie the
operands, rebuild the operand list, and re-tie the remaining pairs at
their new positions.

It also gave up when the register appears in more than one operand, e.g.
one value passed to two "rm" operands, which left the greedy allocator
unable to spill that value at all. Fold every such operand into the
stack slot.

Finally, take MayLoad from the folded operands rather than from every
read of the register: a folded def whose tied use is another virtual

    [9 lines not shown]
DeltaFile
+85-32llvm/lib/CodeGen/TargetInstrInfo.cpp
+108-0llvm/test/CodeGen/X86/greedy-inline-asm-fold.mir
+193-322 files

LLVM/project 88f0071 — llvm/lib/CodeGen TargetInstrInfo.cpp

Include STLExtras.h for the range helpers

foldInlineAsmMemOperands uses is_contained, min_element, drop_begin,
and enumerate from STLExtras.h, which the file got only through other
headers.

Assisted-by: Claude Opus 5.5
DeltaFile
+1-0llvm/lib/CodeGen/TargetInstrInfo.cpp
+1-01 files

LLVM/project c98faad — llvm/lib/CodeGen TargetInstrInfo.cpp

Use drop_begin() for the operands after the first folded one

Assisted-by: Claude Opus 5.5
DeltaFile
+1-2llvm/lib/CodeGen/TargetInstrInfo.cpp
+1-21 files

LLVM/project 4e8fc18 — llvm/include/llvm/CodeGen MachineInstr.h, llvm/lib/CodeGen CalcSpillWeights.cpp MachineInstr.cpp

Move the later folding fixes to their own PRs

1d50fec74e60 added more fixes for folding inline asm register operands
to this PR. They're split into the PRs stacked on this one, one fix
each, to keep this one to the tied operand fix that was reviewed.

This reverts commit 1d50fec74e601c10811a0d58c37a392b2a1ba146.

Assisted-by: Claude Opus 5.5
DeltaFile
+48-197llvm/test/CodeGen/X86/greedy-inline-asm-fold.mir
+51-102llvm/lib/CodeGen/TargetInstrInfo.cpp
+0-100llvm/test/CodeGen/X86/peephole-inline-asm-fold.mir
+19-37llvm/lib/CodeGen/MachineInstr.cpp
+5-13llvm/lib/CodeGen/CalcSpillWeights.cpp
+2-9llvm/include/llvm/CodeGen/MachineInstr.h
+125-4584 files not shown
+130-47110 files

LLVM/project cffc339 — llvm/include/llvm/CodeGen MachineInstr.h, llvm/lib/CodeGen MachineInstr.cpp

[TargetInstrInfo] Address review: don't fold a subregister that isn't at the start of the slot

A folded operand refers to the start of the stack slot, which holds the
whole register, so a subregister is only there if it's at bit offset 0 on a
little-endian target. Folding x86's sub_8bit_hi read byte 0 instead of byte
1. Folding several operands at once made this worse: two operands holding
different subregisters of one value (e.g. "Qm"(lo), "Qm"(hi)) both read
byte 0.

Check the subregister in mayFoldInlineAsmRegOp, so the spill weights agree
with what folds. A tied def is covered too, since its tied use has the same
subregister.

Assisted-by: Claude Opus 5.5
DeltaFile
+112-0llvm/test/CodeGen/X86/greedy-inline-asm-fold.mir
+11-0llvm/lib/CodeGen/MachineInstr.cpp
+2-1llvm/include/llvm/CodeGen/MachineInstr.h
+125-13 files

LLVM/project 485182f — llvm/include/llvm/CodeGen MachineInstr.h, llvm/lib/CodeGen CalcSpillWeights.cpp MachineInstr.cpp

[CodeGen] Fix more hazards in folding inline asm register operands

Nothing in tree marks an inline asm operand foldable until #229632, so
these were found by a review of the stack rather than by tests:

- The spill weights took a register to be foldable into an asm if any one
  of its operands there was foldable, while the folder needs all of them
  to be. One value passed to an "rm" and an "r" operand could then get
  spilled, not folded, and reloaded into a register the asm didn't have.
  Add MachineInstr::mayFoldInlineAsmReg(), true if every operand of a
  register in an asm can be folded, and use it in the folder,
  CalcSpillWeights, and InlineSpiller.
- The folder now folds every operand of the register, including an undef
  use that InlineSpiller leaves out of the operands it passes, which was
  left behind still referring to the spilled register.
- InlineSpiller rematerialized a value passed to a foldable operand (e.g.
  a constant) into a register right before the asm, which the asm may not
  have had. It's spilled and folded instead.
- An asm that can fold a register no longer adds to the register's spill

    [18 lines not shown]
DeltaFile
+197-48llvm/test/CodeGen/X86/greedy-inline-asm-fold.mir
+101-50llvm/lib/CodeGen/TargetInstrInfo.cpp
+100-0llvm/test/CodeGen/X86/peephole-inline-asm-fold.mir
+38-20llvm/lib/CodeGen/MachineInstr.cpp
+13-5llvm/lib/CodeGen/CalcSpillWeights.cpp
+9-2llvm/include/llvm/CodeGen/MachineInstr.h
+458-1254 files not shown
+471-13010 files

LLVM/project f29928c — llvm/lib/CodeGen TargetInstrInfo.cpp, llvm/test/CodeGen/X86 greedy-inline-asm-fold.mir

[TargetInstrInfo] Address review: don't fold one register of a multi-register operand

A memory operand replaces exactly one register, so return nullptr for a
folded operand whose flag holds more than one, rather than relying on an
assert that release builds drop. Also assert that every folded operand
holds the same register, and say that a caller folding a def whose tied use
is another register must store that register's value into the slot.

Test both the new bail-out and folding a rematerialized load into two "rm"
operands, which takes the fold-a-load path.

Assisted-by: Claude Opus 5.5
DeltaFile
+72-0llvm/test/CodeGen/X86/greedy-inline-asm-fold.mir
+11-1llvm/lib/CodeGen/TargetInstrInfo.cpp
+83-12 files

LLVM/project 32f30e1 — llvm/test/CodeGen/X86 greedy-inline-asm-fold.mir

[TargetInstrInfo] Address review: write the two-register flag symbolically

Now that the operand count of an inline asm flag can be written in MIR, use
"reguse:GR64 foldable ops:2" instead of an immediate whose register class ID
changes whenever a register class is added. Regenerate the checks, which
now print the five operands of each x86 memory reference as "ops:5".

Assisted-by: Claude Opus 5.5
DeltaFile
+10-12llvm/test/CodeGen/X86/greedy-inline-asm-fold.mir
+10-121 files

LLVM/project 8c7974a — llvm/test/CodeGen/MIR/X86 inline-asm-func-kind.ll

Remove unneeded -global-isel=0
DeltaFile
+3-3llvm/test/CodeGen/MIR/X86/inline-asm-func-kind.ll
+3-31 files

LLVM/project ecbe3d3 — llvm/test/CodeGen/MIR/X86 inline-asm-func-kind.ll

Output null filetype instead of piping to /dev/null

Co-authored-by: Matt Arsenault <Matthew.Arsenault at amd.com>
DeltaFile
+1-1llvm/test/CodeGen/MIR/X86/inline-asm-func-kind.ll
+1-11 files

LLVM/project 2e72dbd — llvm/include/llvm/IR InlineAsm.h, llvm/lib/CodeGen MIRPrinter.cpp MachineInstr.cpp

[MIR] Round-trip the "func" kind of inline asm operand flags

An x86 inline asm call or jmp whose target is a function, given as a "p"
operand or as a "*m" operand that ISel turns into an address, gets a flag
of kind Func. Like a Mem flag, it carries a memory constraint. But
getKindName() returned "mem" for it, and the MIR printer printed the
constraint only for a Mem flag. So this:

    call void asm sideeffect "call ${0:P}", "p,~{dirflag},~{fpsr},~{flags}"(ptr @g)

was printed as:

    INLINEASM &"call ${0:P}", sideeffect attdialect, mem ops:5, target-flags(x86-plt) @g, 1, $noreg, 0, $noreg, ...

which parses back as a Mem flag with no constraint. Printing that again
hits llvm_unreachable, and the asm printer asserts in PrintMemReference()
instead of emitting "callq g at PLT". MachineInstr::print() also printed the
constraint as a register class (e.g. "mem:GR8_NOREX").


    [4 lines not shown]
DeltaFile
+38-0llvm/test/CodeGen/MIR/X86/inline-asm-func-kind.ll
+3-2llvm/lib/CodeGen/MachineInstr.cpp
+2-1llvm/lib/CodeGen/MIRParser/MIParser.cpp
+2-1llvm/include/llvm/IR/InlineAsm.h
+1-1llvm/lib/CodeGen/MIRPrinter.cpp
+46-55 files

LLVM/project aefcda1 — llvm/include/llvm/IR InlineAsm.h, llvm/lib/CodeGen MIRPrinter.cpp

[MIR] Serialize the operand count of inline asm operand flags (#235184)

An inline asm operand flag is followed by the number of operands that
it says: e.g. two registers for an i128 or an i386 `"A"` output, or the
five operands of an x86 memory reference. The symbolic flag syntax had
no way to write that count, so the printer dropped it and the parser
assumed one. Printed MIR with such a flag didn't parse back correctly:
the operands after the first were read as further flags or as stray operands,
which the machine verifier rejects. Tests had to write such a flag as an
immediate, which holds its register class's TableGen ID: adding a
register class can change the immediate, though the class stays the same.

Print the count as 'ops:N' at the end of the flag when it isn't 1, and
parse it back, e.g.:

  INLINEASM &"", attdialect, mem:m ops:5, %stack.0, 1, $noreg, 0, $noreg
  INLINEASM &"", attdialect, reguse:GR64 foldable ops:2, %0, %1

A count of 0 is accepted, since the printer emits whatever count the

    [16 lines not shown]
DeltaFile
+34-1llvm/lib/CodeGen/MIRParser/MIParser.cpp
+31-0llvm/test/CodeGen/MIR/Generic/inline-asm-ops-errors.mir
+22-0llvm/test/CodeGen/MIR/X86/inline-asm-operand-count.mir
+15-1llvm/include/llvm/IR/InlineAsm.h
+3-3llvm/test/CodeGen/MIR/X86/inline-asm-rm-exhaustion.mir
+6-0llvm/lib/CodeGen/MIRPrinter.cpp
+111-54 files not shown
+116-1010 files

LLVM/project 9f002cf — llvm/lib/Target/X86 X86InstrACE.td, llvm/utils/TableGen X86RecognizableInstr.cpp

[X86][ACEV1][NFC] Take the TOP4MX vvvv source last

The five mixed-precision outer products listed their sources reversed,
because MRMSrcReg takes the EVEX.vvvv operand ahead of the ModR/M one
and the specification numbers them the other way round. MRMSrcReg4VOp3
takes it last, so every operand list now reads in order, as the other
outer products already do. Pairing that form with a trailing immediate
needs the disassembler emitter to accept a fourth operand, which it
already does for MRMSrcReg. The encodings do not change.
DeltaFile
+5-6llvm/lib/Target/X86/X86InstrACE.td
+2-1llvm/utils/TableGen/X86RecognizableInstr.cpp
+7-72 files

LLVM/project 5b96ec4 — clang/include/clang/Basic BuiltinsX86_64.td, clang/test/CodeGen/X86 acev1_errors.c acev1_api.c

[X86][ACEV1] Diagnose a mixed tile model and check the builtins

One palette is in force at a time, so a function cannot configure both
kinds of tile. Report that after selection, when every model has been
recorded, and report a function mixing the two ACE models only once.

Give the AMX tile-zero builtins their own amx-tile spelling, so an ACE
target no longer selects palette 1 for them, and check the scale group
the mixed-precision forms take. The clang tests now pin the tile shape
and alignment rather than the intrinsic name alone.
DeltaFile
+42-0llvm/test/CodeGen/X86/ACEV1/acev1-amx-mixed-tiles.ll
+20-12clang/test/CodeGen/X86/acev1_tile_movement.c
+16-11clang/test/CodeGen/X86/acev1_api.c
+10-6clang/include/clang/Basic/BuiltinsX86_64.td
+8-6llvm/lib/Target/X86/X86MachineFunctionInfo.cpp
+14-0clang/test/CodeGen/X86/acev1_errors.c
+110-356 files not shown
+154-4012 files

LLVM/project d0b81f5 — llvm/lib/Target/X86 X86InstrACE.td X86LowerTileCopy.cpp, llvm/test/CodeGen/X86/ACEV1 acev1-tile-phi.ll acev1-tile-rmw.ll

[X86][ACEV1] Move palette 2 tiles a row at a time

Palette 2 has no TILELOADD or TILESTORED, so a tile reaches memory only
through TILEMOVROW. The casts substituted a zeroed tile for a loaded one
and dropped the stored result, a tile PHI and a tile-to-tile copy still
asked for TILELOADD, and a constant row index went through a GPR.

Synthesise the 16 row moves in each of those places, and select the
immediate form when the index is constant. The -O0 config now leads the
block, since palette 2 writes no shapes and ldtilecfg resets the BSR.
DeltaFile
+33-47llvm/test/CodeGen/X86/ACEV1/acev1-tile-rmw.ll
+52-9llvm/lib/Target/X86/X86LowerAMXType.cpp
+38-22llvm/lib/Target/X86/X86FastPreTileConfig.cpp
+42-14llvm/lib/Target/X86/X86LowerTileCopy.cpp
+28-9llvm/lib/Target/X86/X86InstrACE.td
+37-0llvm/test/CodeGen/X86/ACEV1/acev1-tile-phi.ll
+230-1016 files not shown
+329-10312 files

LLVM/project bb448c0 — clang/lib/Sema SemaX86.cpp, llvm/include/llvm/IR IntrinsicsX86.td

[X86][ACEV1] Record the program model and correct the outer products

Record the program model as the intrinsics are selected, keyed on the
intrinsic as AMX does, rather than from a 66-entry opcode table kept in
step by hand; using both models is now diagnosed, not asserted. Drop the
K dimension the internal outer products never used, and swap the TOP4MX
pseudos' sources, which reached the instruction reversed because it
takes its VVVV operand first. Widen the insert pseudos' index to i32 so
an out-of-range one truncates as for AMX, check it in clang against the
architectural 0-15, and restore the GCCRegNames grouping BSR0 reflowed.
DeltaFile
+21-129llvm/lib/Target/X86/X86ISelLowering.cpp
+45-12clang/lib/Sema/SemaX86.cpp
+56-0llvm/lib/Target/X86/X86ISelDAGToDAG.cpp
+23-23llvm/test/CodeGen/X86/ACEV1/acev1-outer-product.ll
+21-21llvm/include/llvm/IR/IntrinsicsX86.td
+36-5llvm/test/CodeGen/X86/ACEV1/acev1-intrinsics.ll
+202-19017 files not shown
+398-32523 files

LLVM/project dd65f7f — clang/test/CodeGen/X86 acev1_tile_movement.c, llvm/include/llvm/IR IntrinsicsX86.td

[X86][ACEV1] Give the row and column inserts the tile they write

A tile row or column write keeps the rest of the tile, but the internal
intrinsics took no tile to write into, so X86ExpandPseudo fabricated the
tied source as undef. Nothing linked consecutive inserts, so two tiles
written alternately both got tmm0 and overwrote each other. Add the tile
as an argument, as the outer products take their accumulator.

That same missing operand was why X86LowerAMXType skipped the volatile
tile model on any ACE subtarget, costing plain AMX functions a transform
they need at -O0; volatileTileData already skips ACE tiles per value.
DeltaFile
+44-14llvm/test/CodeGen/X86/ACEV1/acev1-tile-rmw.ll
+7-9llvm/lib/Target/X86/X86LowerAMXType.cpp
+13-2clang/test/CodeGen/X86/acev1_tile_movement.c
+15-0llvm/test/CodeGen/X86/ACEV1/acev1-amx-interop.ll
+2-7llvm/lib/Target/X86/X86ExpandPseudo.cpp
+6-2llvm/include/llvm/IR/IntrinsicsX86.td
+87-343 files not shown
+99-419 files

LLVM/project 7ca5a99 — llvm/lib/Target/X86 X86InstrACE.td

[X86][ACEV1][NFC] Emit the ACE instruction definitions from multiclasses

Most ACE operations need three definitions: the instruction itself, a pseudo
for the user-facing intrinsic that takes an immediate tile ID, and a pseudo
for the internal intrinsic that takes a shape and a tile register so the
register allocator can assign TMMs. All three were written out by hand for
every operation, so the four integer outer products differed only in
mnemonic and prefix, and the twelve row-read pseudos only in the intrinsic.

Emit them from five multiclasses, one per operation shape, deriving the
intrinsic names from the mnemonic as X86InstrAMX.td already does.
DeltaFile
+207-399llvm/lib/Target/X86/X86InstrACE.td
+207-3991 files

LLVM/project 138b1c7 — llvm/lib/Target/X86 X86ISelDAGToDAG.cpp X86InstrInfo.cpp, llvm/test/CodeGen/X86/ACEV1 acev1-tile-spill-fallthrough.ll acev1-amx-interop.ll

[X86][ACEV1] Model the tile row and column writes as read-modify-write

TILEMOVROW and TILEMOVCOL writing into a tile update one row or column and
keep the rest, so the destination is a source as well; the ACE v1
specification encodes operand 1 of all four write forms as REG(r/w). Tie
it. Palette 2 has no TILELOADD, so a reload rebuilds the tile a row at a
time, and without the tie every write but the last looked dead and the
sequence was not valid SSA before register allocation.

Moving a tile also stops asking the subtarget which palette it belongs to.
An ACE target can hold palette 1 tiles, which took the row-by-row route
shaped for palette 2's fixed 16x64 tile. Key it on the programming model,
as the palette byte in the same function already is.
DeltaFile
+89-0llvm/test/CodeGen/X86/ACEV1/acev1-tile-rmw.ll
+39-2llvm/test/CodeGen/X86/ACEV1/acev1-amx-interop.ll
+38-0llvm/test/CodeGen/X86/ACEV1/acev1-tile-spill-fallthrough.ll
+24-12llvm/lib/Target/X86/X86FastPreTileConfig.cpp
+22-6llvm/lib/Target/X86/X86InstrInfo.cpp
+0-19llvm/lib/Target/X86/X86ISelDAGToDAG.cpp
+212-394 files not shown
+239-5010 files

LLVM/project f8bd14e — llvm/lib/Target/X86 X86LowerAMXType.cpp X86ISelLowering.cpp, llvm/test/CodeGen/X86/ACEV1 acev1-tile-spill.ll acev1-tile-basic.ll

[X86][ACEV1] Give ACE spellings to the shared palette-bearing instructions

ACE configures tile palette 2 and AMX palette 1, so an instruction both
extensions spell the same way must stay distinguishable after ISel. Asking
the subtarget answers wrongly for a function built for an ACE target that
holds only plain AMX code, and silently miscompiled it: a tile loaded
through a vector became a tilezero, dropping the load, and a tile read back
as a vector became poison.

Give the seven shared palette-bearing instructions - TILEZERO, TCVTROWD2PS,
TCVTROWPS2BF16H/L, TCVTROWPS2PHH/L and the TILEMOVROW read form - ACE
intrinsics and pseudos of their own, so the palette is chosen from the
intrinsic while still in IR and, after selection, from the ACE programming
model that the pseudo's opcode records in X86MachineFunctionInfo beside the
AMX one. The read direction of TILEMOVROW also gets a user-facing name,
llvm.x86.acev1.tilemovrowextract, as GCC gives it.

The six row reads take the row index by value in one intrinsic, as GCC's
builtins do, and each has an imm8 encoding alongside the r32 one, so they

    [3 lines not shown]
DeltaFile
+132-0llvm/lib/Target/X86/X86InstrACE.td
+79-22llvm/lib/Target/X86/X86ISelLowering.cpp
+53-36llvm/lib/Target/X86/X86LowerAMXType.cpp
+82-0llvm/test/CodeGen/X86/ACEV1/acev1-intrinsics.ll
+68-10llvm/test/CodeGen/X86/ACEV1/acev1-tile-basic.ll
+38-38llvm/test/CodeGen/X86/ACEV1/acev1-tile-spill.ll
+452-10621 files not shown
+793-20027 files

LLVM/project ed7d998 — llvm/lib/Target/X86 X86LowerTileCopy.cpp, llvm/test/CodeGen/X86/ACE acev1-outer-product.ll ace-intrinsics.ll

Address review comments

- Rename the ACE tests and directories to acev1 for consistency
- Build acev1 on top of avx10.1 rather than avx10.2
- Fix test encodings and the BSR0 implicit defs
- Make the scale register type consistent with the spec
- Add memory operand tests for bsrmov
- Confirm the ACEV1 ISA implication chain
- Take the outer product ZMM sources by value instead of by register ID,
  so they are allocated conventionally, and mark the 512-bit ACE builtins
  with RequiredVectorWidth<512>
- Use pseudos for SPILL and RELOAD. Spills use scratch zmm. Don't use
  non-ace ISA.
- Fix missing vector r/m in MRMSrcReg4VOp3.
DeltaFile
+357-0llvm/test/CodeGen/X86/ACEV1/acev1-intrinsics.ll
+262-0llvm/test/MC/Disassembler/X86/acev1.txt
+0-244llvm/test/CodeGen/X86/ACE/ace-intrinsics.ll
+206-0llvm/test/CodeGen/X86/ACEV1/acev1-outer-product.ll
+0-204llvm/test/CodeGen/X86/ACE/acev1-outer-product.ll
+100-76llvm/lib/Target/X86/X86LowerTileCopy.cpp
+925-52439 files not shown
+2,172-1,67845 files