@fhahn I've simplified the test, thanks for the comments!

In D94708#2509610, @fhahn wrote:

Are there plans to use this for fixed vectors as well? If not, can this be restricted to scalable vectors only? It seems like for fixed vectors, preferring the shufflevector versions would be beneficial, to avoid having to update all transforms lookin at shuffles.

Otherwise, this should probably have some tests for platforms other than AArch64 and also support in GlobalISel, which is the default on AArch64 with -O0 IIRC (or do the transform to shuffles as an IR transform).

Changes:

• Remove unused function declaration for LowerVECTOR_SPLICE.
• Clarify trailing.elts must be an integer constant in LangRef.
• Use DefaultAttrs for intrinsic.
• Use setOperationPromotedToType.

In D90687#2501881, @iajbar wrote:

The patch that causes the assert is patch cba4accda08f90. I tried commit c63799fc52ff247 that is before your patch and there is no assert. Thank you.

In D90687#2501292, @iajbar wrote:

I configured and built llvm with:
cmake -G Ninja -DLLVM_TARGETS_TO_BUILD:STRING=Hexagon -DLLVM_DEFAULT_TARGET_TRIPLE:STRING=hexagon-unknown-elf -DLLVM_TARGET_ARCH:STRING=hexagon-unknown-elf -DLLVM_ENABLE_ASSERTIONS:BOOL=ON -DLLVM_PARALLEL_LINK_JOBS=1 '-DLLVM_ENABLE_PROJECTS=llvm;clang' -DBUILD_SHARED_LIBS:BOOL=ON ..

This patch causes an assert with this testcase:
typedef struct {

char a;

} b;
b *c;
int d, e;
int f() {

int g = 0;
for (; d; d++) {
  e = 0;
  for (; e < c[d].a; e++)
    g++;
}
return g;

}
clang -Os -mhvx -fvectorize -mv67 testcase.i -S -o -

llvm::LoopVectorizationCostModel::computeMaxVF(llvm::ElementCount, unsigned int): Assertion `WideningDecisions.empty() && Uniforms.empty() && Scalars.empty() && "No decisions should have been taken at this point"' failed.

In D94504#2494181, @cameron.mcinally wrote:

LGTM

I'm assuming scheduling the new addvls closer to their uses is a register pressure win?

Rebased. Committed update_llc_test_checks.py changes separately to reduce the diff (thanks for suggestion @sdesmalen).

I've left one minor nit but looks otherwise looks fine to me

In D94168#2484564, @frasercrmck wrote:

@c-rhodes, could you possibly check that the changes to the AArch64 tests are okay? The whilelo one is a bit confusing.

@fhahn thanks for reviewing, I think I've addressed all comments. I'll probably land this over the coming days unless there's any objections between then, cheers.

Address @fhahn comments.

Changes:

• Rebased. Target hook for max vscale has been removed from this patch since it landed in D93030.
• Address Sander's comment w.r.t. falling back to fixed vectorization if scalable vectors are supported, but max vscale is undefined.

Address @fhahn's comments, changes:

Handle scalable VF in a single isScalable block in computeFeasibleMaxVF.

Left a couple of nits but mostly LGTM, cheers

• Rather than disable vectorization if scalable VF isn't supported, let the LV pick a VF as it normally does and process with cost-modelling.
• Added a new LV flag -force-target-supports-scalable-vectors to support writing non-target specific tests with scalable VFs.
• Added a temporary workaround to use MaxVF in place of UserVF until cost modelling loop works for scalable VFs.
• Emit opt remark.

Address comments and added test.

Changes:

• Rebase since D88962 and D91077 have now landed.
• Address @sdesmalen's comments. Added a target hook supportsScalableVectors in D93060 which is used in this patch to bail out of vectorization if unsupported. Also changed the behavior when scalable vectorization is unfeasible given a dependency, it now changes the hint to fixed, where existing behavior applies (i.e. clamping).
• Updated tests.

In D92571#2431860, @dexonsmith wrote:

LGTM too if you drop the libcxxabi change.

If there's an out-of-tree user that needs this we can revert again if it makes sense to (in which case, it'd be better to change getCastOpcode to return an Optional<Instruction::CastOps>, so we're not having to keep two functions in sync like this...).

Remove change to libcxxabi test.

Replace assert with bail out for scalable vector in static variant.

Changes:

• s/FixedVF/MaxSafeElements/
• Rather than bail out, clamp to fixed VF is scalable is unfeasible. Remove change to return Optional<ElementCount> from LoopVectorizationCostModel::computeFeasibleMaxVF.
• In LoopVectorizationPlanner::plan, if a UserVF is specified but isn't legal then use MaxVF (earlier).
• Simplified the IR in the tests.

I think I've addressed all comments now so I'll land this at the beginning of next week unless there's any objections between then, thanks for reviewing all!

Address Florian's comments

Run clang-format

In D91696#2405082, @joechrisellis wrote:

Address @c-rhodes's comments regarding lax conversion when __ARM_FEATURE_SVE_BITS != N for GNU vectors.

I've left one minor comment, if that suggestion works it should be fine to fix it before committing

• Rebased (computeFeasibleMaxVF now returns an ElementCount).
• Address one of @fhahn's comments.
• Added an assert at the top of computeFeasibleMaxVF that UserVF isn't scalable.