Scalable vector core instruction support + size queries

[huntergr]

Summary

Implements basic size queries to support scalable vectors in LLVM IR.

Adds simple tests for IR instructions usable with scalable vector types to ensure that they can be parsed and printed back out without dropping the scalable flag; used the size queries and getElementCount in a couple of places to get it working.

Adds a few scalable size query calls in codegen and tablegen to keep existing tests working, including the recent SVE calling convention test.

Adds checks in various backends which don't support scalable vectors to skip over them when registering legalization and DAG actions.

[huntergr]

• Unified ScalableSize representation
• Changed to uint64_t + boolean, since we no longer allow scalable vectors in aggregates
• Removed aggregate and mixed unit tests

[rengolin]

This looks ok to me, but I'd rather more people look at it before approving.

Thanks!

[greened]

I know this isn't ready for merge, but since the mailing list discussion has died down it seems like maybe we should move the discussion here. If so, it would be helpful to have comments on all the routines explaining what they do and how they differ from the existing routines, in order to aid discussion.

[huntergr]

Updated based on where scalable size queries were required when running with an SVE-capable loop vectorizer on several codebases (all of LNT, various flavours of SpecCPU, lots of HPC and embedded benchmarks).

[rovka]

Hi Graham,

I think this patch is difficult to review. It covers many different source files with only a small unit test to check the correctness. This isn't very robust against future changes and it makes it hard to know exactly what is and isn't supported.

I would find it much easier to review with an incremental strategy based on regression tests. For instance, with ToT opt, the attached testcase fails (error: '%r' defined with type '<4 x i1>' but expected '<vscale x 4 x i1>'). I would add a patch to fix that, and maybe other similar, really simple cases. We could then proceed to more complex examples, run some of the passes that come after the vectorizer on them, and progressively fix the places required to make them pass, with focused tests for each hurdle that we run into. It shouldn't be too hard to reduce such snippets from the tests you've already been running.

We would eventually end up with something like this patch, but I think that an incremental approach would have the advantage of quicker reviews with more focused discussions, more regression tests, and we would know how much was supported at any point. Does anyone else have a similar opinion?

simplest.ll415 BDownload

[huntergr]

Hi Diana,

Thanks for the comments.

In D53137#1597022, @rovka wrote:

I think this patch is difficult to review. It covers many different source files with only a small unit test to check the correctness. This isn't very robust against future changes and it makes it hard to know exactly what is and isn't supported.

Yeah, I was worried about that -- this is basically the size queries alone without anything actually using scalable vectors. It demonstrates roughly where changes will be needed, but doesn't actually change the surrounding code to use e.g. getElementCount instead of getNumElements.

I would find it much easier to review with an incremental strategy based on regression tests. For instance, with ToT opt, the attached testcase fails (error: '%r' defined with type '<4 x i1>' but expected '<vscale x 4 x i1>'). I would add a patch to fix that, and maybe other similar, really simple cases. We could then proceed to more complex examples, run some of the passes that come after the vectorizer on them, and progressively fix the places required to make them pass, with focused tests for each hurdle that we run into. It shouldn't be too hard to reduce such snippets from the tests you've already been running.

An incremental approach sounds good; assuming nobody objects, I'll remove most of the code in this patch and just leave the core mechanism behind (in enforcing mode) and add in that test case. We can fill in the other cases as we enable codegen/acle/autovec in separate patches.

[rengolin]

In D53137#1597022, @rovka wrote:

I would find it much easier to review with an incremental strategy based on regression tests. For instance, with ToT opt, the attached testcase fails (error: '%r' defined with type '<4 x i1>' but expected '<vscale x 4 x i1>'). I would add a patch to fix that, and maybe other similar, really simple cases. We could then proceed to more complex examples, run some of the passes that come after the vectorizer on them, and progressively fix the places required to make them pass, with focused tests for each hurdle that we run into. It shouldn't be too hard to reduce such snippets from the tests you've already been running.

+1 to incremental approach and more tests!

This change is mostly mechanical, but you're absolutely right we need to be aware of unwanted side effects. I wrongly assumed mechanical == NFC, but this clearly isn't. Thanks for the thorough review!

I think tests need to be strict on what it should support. Not necessarily test for *all* errors, but add test for the supported cases and some negative tests for the obvious unsupported stuff.

Each step of the way, revert negative tests when new features are added (and adding more tests, too!), we can make sure it's stable and robust.

[rovka]

In D53137#1597088, @huntergr wrote:

Hi Diana,

Thanks for the comments.

In D53137#1597022, @rovka wrote:

I think this patch is difficult to review. It covers many different source files with only a small unit test to check the correctness. This isn't very robust against future changes and it makes it hard to know exactly what is and isn't supported.

Yeah, I was worried about that -- this is basically the size queries alone without anything actually using scalable vectors. It demonstrates roughly where changes will be needed, but doesn't actually change the surrounding code to use e.g. getElementCount instead of getNumElements.

I would find it much easier to review with an incremental strategy based on regression tests. For instance, with ToT opt, the attached testcase fails (error: '%r' defined with type '<4 x i1>' but expected '<vscale x 4 x i1>'). I would add a patch to fix that, and maybe other similar, really simple cases. We could then proceed to more complex examples, run some of the passes that come after the vectorizer on them, and progressively fix the places required to make them pass, with focused tests for each hurdle that we run into. It shouldn't be too hard to reduce such snippets from the tests you've already been running.

An incremental approach sounds good; assuming nobody objects, I'll remove most of the code in this patch and just leave the core mechanism behind (in enforcing mode) and add in that test case. We can fill in the other cases as we enable codegen/acle/autovec in separate patches.

Actually my test case falls in the "replace getNumElements with getElementCount" category, rather than size queries per se. I don't think either of them is more important than the other, but you might run into the former while writing tests for the latter.

[huntergr]

• Removed most of the changes in favour of reintroducing them in separate patches later with appropriate tests.
• Added tests for core IR instructions to make sure they don't drop the scalable flag.
• Fixed up a couple places which broke the new tests.

[greened]

llvm/include/llvm/CodeGen/ValueTypes.h

299 ↗

(On Diff #212548)

Needs a comment about what this returns.

305 ↗

(On Diff #212548)

Needs a comment about what this returns.

321 ↗

(On Diff #212548)

Needs a comment about what this returns.

326 ↗

(On Diff #212548)

Needs a comment about what this returns.

336 ↗

(On Diff #212548)

Needs a comment about what this returns.

340 ↗

(On Diff #212548)

Needs a comment about what this returns.

llvm/include/llvm/IR/DataLayout.h

444

Needs comments about what these return.

464

Needs a comment about what this returns.

470

Needs a comment about what this returns.

505

Needs a comment about what this returns.

510

Needs a comment about what this returns.

525

Needs a comment about what this returns.

532

Needs a comment about what this returns.

555

Needs a comment about what this returns.

[greened]

llvm/include/llvm/IR/DataLayout.h

560

Needs a comment about what this returns.

llvm/include/llvm/Support/MachineValueType.h

672 ↗

(On Diff #212548)

Not sure why the other methods here don't have comments but we should probably have one here to say what this does.

720 ↗

(On Diff #212548)

Needs a comment about what this returns.

840 ↗

(On Diff #212548)

Needs a comment about what this returns.

845 ↗

(On Diff #212548)

Needs a comment about what this returns.

855 ↗

(On Diff #212548)

Needs a comment about what this returns.

860 ↗

(On Diff #212548)

Needs a comment about what this returns.

llvm/include/llvm/Support/ScalableSize.h

43

Needs comments about what this is and what the fields represent.

102

This needs an explanatory comment.

107

Needs a comment about what this returns.

llvm/lib/CodeGen/SelectionDAG/LegalizeVectorTypes.cpp

4612 ↗

(On Diff #212548)

This comment should probably be moved right before the if below.

llvm/lib/IR/DataLayout.cpp

750–753

I might help to clarify that this comment only applies to scalable types, at least as far as I understand this changes here.

llvm/lib/Target/Hexagon/HexagonISelLowering.cpp

1438 ↗

(On Diff #212548)

What about other backends? Do they need similar checks (both here and below)?

[rovka]

Several more general comments:

• Should all the getXSize assert when called on a scalable type? I see that for MVT::getSizeInBits and for Type::getPrimitiveSize, but not for the others. This should also be made clear in the comments for each of them.
• Great test for the IR, thanks!
• I don't see any test for the CodeGen stuff though. Is it possible to add one? (If not, maybe add the changes to EVT etc when we can actually test them).
• Ditto for TableGen (or if that's too difficult/hairy to test, just update the commit message to explain exactly why the change belongs in this patch).

llvm/include/llvm/CodeGen/ValueTypes.h

214 ↗

(On Diff #212548)

Why does this one need to change? We're only looking at MinSize anyway, isn't getSizeInBits good enough?

llvm/include/llvm/IR/DataLayout.h

555

Where is this used?

llvm/include/llvm/Support/ScalableSize.h

43

Maybe make this a class, so people can't just get at the MinSize directly? Otherwise, it doesn't make much sense to have accessors for the fields (and especially getFixedSize, which can be completely circumvented via direct access).

50

Isn't this already deleted because we have a constructor just above?

53

I think it's more canonical to say return std::tie(MinSize, Scalable) == std::tie(RHS.MinSize, RHS.Scalable).

59

Should be implemented in terms of operator==.

66

Needs a comment saying that you can't compare scalable sizes and fixed sizes.
You can simplify the code by replacing the check for Scalable with an assert and removing the unreachable at the end.
Also, all the other comparison operators below should be implemented in terms of this.

94

Would be nice to also have a non-member one for symmetry (so you can write 2 * SomeSize, not just SomeSize * 2).

llvm/lib/CodeGen/ValueTypes.cpp

106 ↗

(On Diff #212548)

Should also assert that it's not called on a scalable type.

[huntergr]

Thanks for the reviews; I left a couple of inline comments, and will make the requested changes.

llvm/include/llvm/CodeGen/ValueTypes.h

214 ↗

(On Diff #212548)

getSizeInBits will assert (actually, the underlying MVT version for it will) for a scalable vector type, so can't be used.

However, I introduced the 'getMinSizeInBits' function after writing this, so it should be used here.

llvm/lib/Target/Hexagon/HexagonISelLowering.cpp

1438 ↗

(On Diff #212548)

I'll take a look, but the Hexagon backend was the only one which asserted when running make check-all.

[huntergr]

• Added comments explaining the new methods
• Added tests for the MVT/EVT/DataLayout interfaces
• Refactored ScalableSize class operators to build on '==' and '<'
• Added checks in various backends that don't support scalable vectors to prevent legalizing operations involving scalable MVTs

[sdesmalen]

Thanks @huntergr for working on this!

This patch can probably be split into two separate patches, which make them easier to review;

• One that fixes the Targets to ignore scalable types (see comment)
• Another one that adds the interface for scalable size queries.

On the interfaces itself, I personally find ScalableSize a bit of a misnomer (see comment for other suggestions) because it describes both scalable and fixed-width sizes, which is not what the name suggests. But perhaps more importantly, my concern is that with the interface as defined in this patch, there is little incentive to move the LLVM codebase to work on ScalableSize. Especially for new code that gets added, the interface should let developers make a conscious decision whether their code is fixed-width only, scalable-width only, or agnostic to this property. I would much rather see getSizeInBits() return a ScalableSize object, which in turn only has getFixedSize() and getMinScalableSize() as query methods. If the code is agnostic to whether the size of an object is fixed or scalable, the code should simply operate on the ScalableSize object itself, rather than operating on MinSize.

I realise that the entire code-base currently expects 'unsigned' or 'int', but this can easily be fixed by adding a (hopefully temporary) overloaded cast operator to the struct that produces a scalar value, like:

/// Casts to a uint64_t if this is a fixed-width size.
///
/// NOTE: This interface is obsolescent and will be removed
/// in a future version of LLVM in favour of getFixedSize().
operator uint64_t() const {
  assert(isFixed() && "Expected fixed size data type");
  return getFixedSize();
}

We can then update the codebase piece by piece, incrementally making use of ScalableSize or its interfaces. When all that is done, the codebase should compile without errors when building for LLVM_TARGETS_TO_BUILD=AArch64 after we remove the overloaded operator.

llvm/include/llvm/Support/ScalableSize.h

83

All the comparison operators assert that the types are both fixed-width or both scalable.
Is there value in also adding the following interfaces?

// Returns true if A is known to be at least as big as B, e.g.
// If A is scalable, and B is not, returns A.MinSize >= B.MinSize
// If A is not scalable, and B is, returns false regardless of MinSize.
bool knownGreaterOrEqual(const ScalableSize &B) const { ... }
// or alternatively: "atLeastAsBigAs"?

and

// Returns true if A is known to always be larger than B, e.g.
// If A is scalable, and B is not, returns A.MinSize > B.MinSize
// If A is not scalable, and B is, returns false regardless of MinSize.
bool knownGreater(const ScalableSize &B) const { ... }

120

I think this only really makes sense in the context of scalable vectors, and don't think we want to expose it as a property for both fixed/scalable vectors, e.g.:

uint64_t getMinSize() const {
  assert (isScalable() && "MinSize only makes sense in the context of a scalable vector,"
                          " use getFixedSize() instead");
  return MinSize;
}

For cases where we need to use it in a comparison (to know if it is at least a given number of bytes) we can do this in a separate comparison interface.

125

bool ScalableSize::isScalable() proves to me that the name ScalableSize is a misnomer. If you have a ScalableSize object, I'd expect it to always represent a scalable size.

Can we rename this to something more generic like ObjectSize or PrimitiveSize? (suggestions welcome)

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

9177 ↗

(On Diff #213589)

OutputArg::PartOffset is defined explicitly as a byte offset, so until we change that, this should be getFixedSize().

llvm/lib/IR/Instructions.cpp

3039

MinSize suggests that it could be larger at runtime, so SrcBits.getMinSize() == 0 would always be true. If you instead overload operator bool() which checks for Fixed size and Scalable size to be 0, you can rewrite this as (!SrcBits || !DestBits) .

llvm/lib/Target/X86/X86ISelLowering.cpp

721 ↗

(On Diff #213589)

Adding MVT::fixedwidth_[integer_|fp_]vector_valuetypes() seems like a more natural interface than skipping based on isScalableVector(). There already seem to be iterators for MVT::(integer_|fp_)_scalable_vector_valuetypes.

You can do that in a separate patch, so this patch can focus solely on scalable size queries.

[huntergr]

llvm/include/llvm/Support/ScalableSize.h

83

If you can think of an immediate use case, sure.

Otherwise I'd leave it to another patch which requires that information.

120

This is used for the alignment checks at the moment, where we just need to know the minimum for scalable and exact for fixed.

I'd rather not have code that looks like

unsigned Align;
if (VTy->isScalable())
  Align = getMinSize(VTy);
else
  Align = getFixedSize(VTy);

in several places, when it could be done with one.

We can certainly bikeshed the names, though, and come up with a more explicit one which acknowledges it can represent a known quantity from fixed or scalable vectors.

I would also need to convert a larger part of the codebase to use scalable types in order to use this right now, and I've already had pushback on the size of the changes.

125

Yeah, I figured it needed a rename, but plain 'Size' was likely to cause problems. ObjectSize or TypeSize might work.

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

9177 ↗

(On Diff #213589)

Then we would assert when running unit tests.

I'm trying to juggle between an enormous patch that fixes everything 'properly', and something which gets us partway and keeps us running but needs fixes elsewhere later (which seemed to be what other reviewers would prefer).

I could certainly add a comment here to explain that changes are needed, though.

llvm/lib/IR/Instructions.cpp

3039

No. 0 * vscale is still 0 for any value of vscale.

The ScalableSize class says the Scalable flag indicates the total size is an integer multiple of the known minimum size.

I suspect a better way of doing this test would be to explicitly check for the elements of one being pointer type and not the other, instead of relying on a hack with the size.

llvm/lib/Target/X86/X86ISelLowering.cpp

721 ↗

(On Diff #213589)

Yeah, I thought of that after I'd submitted the patch. Will do.

[huntergr]

In D53137#1621351, @sdesmalen wrote:

Thanks @huntergr for working on this!

This patch can probably be split into two separate patches, which make them easier to review;

• One that fixes the Targets to ignore scalable types (see comment)
• Another one that adds the interface for scalable size queries.

Ok, will do.

On the interfaces itself, I personally find ScalableSize a bit of a misnomer (see comment for other suggestions) because it describes both scalable and fixed-width sizes, which is not what the name suggests. But perhaps more importantly, my concern is that with the interface as defined in this patch, there is little incentive to move the LLVM codebase to work on ScalableSize. Especially for new code that gets added, the interface should let developers make a conscious decision whether their code is fixed-width only, scalable-width only, or agnostic to this property. I would much rather see getSizeInBits() return a ScalableSize object, which in turn only has getFixedSize() and getMinScalableSize() as query methods. If the code is agnostic to whether the size of an object is fixed or scalable, the code should simply operate on the ScalableSize object itself, rather than operating on MinSize.

See some of the inline comments -- there are a few places where we'd just end up duplicating code if used that way. The names can certainly be improved for clarity, though, and we could state that the (scalable|fixed)-only interfaces should be used in preference to a joint one.

I realise that the entire code-base currently expects 'unsigned' or 'int', but this can easily be fixed by adding a (hopefully temporary) overloaded cast operator to the struct that produces a scalar value, like:

/// Casts to a uint64_t if this is a fixed-width size.
///
/// NOTE: This interface is obsolescent and will be removed
/// in a future version of LLVM in favour of getFixedSize().
operator uint64_t() const {
  assert(isFixed() && "Expected fixed size data type");
  return getFixedSize();
}

We can then update the codebase piece by piece, incrementally making use of ScalableSize or its interfaces. When all that is done, the codebase should compile without errors when building for LLVM_TARGETS_TO_BUILD=AArch64 after we remove the overloaded operator.

I'm fine with that approach if others approve; I was trying to minimize the overall impact on the codebase though.

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

9177 ↗

(On Diff #213589)

A followup thought on this; would it be preferable to split the EVT/MVT side of this patch out into a separate one, and fix this properly there?

[sdesmalen]

In D53137#1622713, @huntergr wrote:

See some of the inline comments -- there are a few places where we'd just end up duplicating code if used that way. The names can certainly be improved for clarity, though, and we could state that the (scalable|fixed)-only interfaces should be used in preference to a joint one.

Yes, adding some words to state that in the description of the method would be good. There are indeed cases where MinSize is needed directly (like in DAGCombiner.cpp where it uses MaximumLegalStoreInBits = MinSize), but such a case is very explicit (it needs to specifically query the known part of the size), which I think is not very common. We should strive to reduce those uses as much as possible. For Alignment for example, I think we can use a separate method (see comment).

I realise that the entire code-base currently expects 'unsigned' or 'int', but this can easily be fixed by adding a (hopefully temporary) overloaded cast operator to the struct that produces a scalar value, like:

/// Casts to a uint64_t if this is a fixed-width size.
///
/// NOTE: This interface is obsolescent and will be removed
/// in a future version of LLVM in favour of getFixedSize().
operator uint64_t() const {
  assert(isFixed() && "Expected fixed size data type");
  return getFixedSize();
}

We can then update the codebase piece by piece, incrementally making use of ScalableSize or its interfaces. When all that is done, the codebase should compile without errors when building for LLVM_TARGETS_TO_BUILD=AArch64 after we remove the overloaded operator.

I'm fine with that approach if others approve; I was trying to minimize the overall impact on the codebase though.

Great! Looking forward to hear how others feel about it.

llvm/include/llvm/Support/ScalableSize.h

83

One use-case is in DAGCombiner.cpp, where it currently has:

VT.getMinSizeInBits() >= MaximumLegalStoreInBits

which would become:

VT.getSizeInBits().isKnownGreaterOrEqual(MaximumLegalStoreInBits)

This removes another use-case for using MinSize directly.

120

For Alignment, because it is so common, I think it is worth adding a separate method:

unsigned getNaturalAlignment() const { return (unsigned) getKnownSize(); };

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

9177 ↗

(On Diff #213589)

Right, I see. At some point this class should probably use StackOffset to represent such offsets. For now, I'd say this line warrants a "FIXME" comment.

9177 ↗

(On Diff #213589)

A followup thought on this; would it be preferable to split the EVT/MVT side of this patch out into a separate one, and fix this properly there?

I think so.

llvm/lib/IR/Instructions.cpp

3039

Perhaps I am a little pedantic with how I read this, because I expect the minimum size of every object to be 0, always :)

So perhaps instead of using the name MinSize, a name like KnownSize would be better suited. (which would also nicely match with the isKnownGreaterOrEqual() suggestion for DAGCombiner.cpp).

llvm/lib/Target/X86/X86ISelLowering.cpp

721 ↗

(On Diff #213589)

Thanks!

[huntergr]

Created D66339 to split out the code to skip scalable vector types in other backends.

[huntergr]

• Split out backend code into separate patches
• Renamed 'Min' to 'KnownMin' in method names.
• Added a few more comments.

I tried to replace the comparison of minimum sizes to 0 in Instructions.cpp (for the bitcast checks), but that statement represents quite a lot. Could be scalar pointers, could be a vector of pointers (both of which I checked for in experiments), but there are several other types which report a size of 0 and which are checked for in some unit tests, so the number of checks ended up being fairly substantial. I've left it alone for now, but if reviewers would prefer I extract a method to explicitly check for all conditions represented by the size check I can do so.

[huntergr]

Does anyone like Sander's suggestion to make ScalableSize (or whatever we end up naming it) the return value for all size queries and provide an overloaded cast operator to transparently work with existing code comparing against unsigned values? Or is it preferable to keep the current split?

[rovka]

In D53137#1650774, @huntergr wrote:

Does anyone like Sander's suggestion to make ScalableSize (or whatever we end up naming it) the return value for all size queries and provide an overloaded cast operator to transparently work with existing code comparing against unsigned values? Or is it preferable to keep the current split?

+1 from me, I definitely like Sander's suggestion. I thought we were heading towards ScalableSize-only functions anyway and that this was just a temporary path until we cleaned up the codebase from unsigned. Using a cast operator from the start seems like an even better way of getting there, since that way at least we hopefully won't get that many new uses of unsigned in the interim.

[greened]

In D53137#1652189, @rovka wrote:

+1 from me, I definitely like Sander's suggestion. I thought we were heading towards ScalableSize-only functions anyway and that this was just a temporary path until we cleaned up the codebase from unsigned. Using a cast operator from the start seems like an even better way of getting there, since that way at least we hopefully won't get that many new uses of unsigned in the interim.

+1

[huntergr]

• Changed existing interface to return ScalableSize objects and added a (mostly) transparent conversion, as per Sander's suggestion.
• Removed new interfaces for DataLayout and Type.
• Fixed cases where the transparent conversion doesn't quite work (e.g. std::max/min, where the types must be the same)

I suspect 'ScalableSize' is the wrong term now; 'TypeSize' may be better. Thoughts?

[rovka]

I suspect 'ScalableSize' is the wrong term now; 'TypeSize' may be better. Thoughts?

I agree, TypeSize sounds better. Maybe we can replace the public constructor with 2 static methods, TypeSize::Fixed(Size) and TypeSize::Scalable(Size), so we don't always have to spell out /* Scalable =*/.

llvm/include/llvm/IR/DataLayout.h

463

We already overload operator /, why not overload + as well so we don't have to change the body of this method?

523

Can we add a version of alignTo that works with ScalableSize instead?

724

Maybe just return VTy->getElementCount() * getTypeSizeInBits(VTy->getElementType()).getFixedSize().

[huntergr]

llvm/include/llvm/IR/DataLayout.h

463

Scaling a size with * or / has a clear meaning to me, since it's independent of vscale; getting a vector that's half the size or four times larger just works.

Using + (or -) on the other hand doesn't seem to be as clear; I wasn't sure if a standalone int should be automatically treated as being the same as the TypeSize, or always considered Fixed. If we try for the former I can imagine quite a few bugs arising.

I could add a roundBitsToNearestByteSize method to move the arithmetic elsewhere if that would be acceptable?

724

There's no support for generating a TypeSize from an ElementCount in that way; is that an interface you feel is useful?

(I'll certainly change the getKnownMinSize to getFixedSize though, since we're just referring to a scalar)

[huntergr]

• Renamed ScalableSize to TypeSize, including header name.
• added alignTo function that takes and returns a TypeSize. I wasn't sure if this should be added to MathExtras.h where the other variants live, so just kept it in TypeSize.h for now

[rovka]

This looks good to me, maybe wait a while to see if anyone else has any further comments.

llvm/include/llvm/IR/DataLayout.h

463

You're right, + on TypeSizes would be confusing. This looks ok as-is then, no need to fiddle with it more.

724

Actually, no, now that I think about it a bit more it might be clearer to spell it out this way.

llvm/include/llvm/Support/TypeSize.h

122 ↗

(On Diff #222593)

Microscopic nit: punctuation.

143 ↗

(On Diff #222593)

Ditto.

148 ↗

(On Diff #222593)

Ditto.

[sdesmalen]

Thanks @huntergr , I think this interface looks really nice. LGTM!

llvm/include/llvm/IR/DataLayout.h

462

nit: use TypeSize instead of auto.

690

Nice, I like the interface of TypeSize::Fixed() for fixed-size types.

llvm/lib/IR/Instructions.cpp

2972–2973

nit: auto -> TypeSize ?

3034–3035

nit: auto -> TypeSize ?

[huntergr]

Hmm, forgot to add the last round of minor fixes before committing. Sorry about that, will push them as well.

llvm/include/llvm/IR/DataLayout.h

 #include "llvm/ADT/StringRef.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Type.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/Alignment.h"
+#include "llvm/Support/ScalableSize.h"
 #include <cassert>
 #include <cstdint>
 #include <string>
 
 // This needs to be outside of the namespace, to avoid conflict with llvm-c
 // decl.
 using LLVMTargetDataRef = struct LLVMOpaqueTargetData *;
 
public:
   ///
   /// [*] The alloc size depends on the alignment, and thus on the target.
   ///     These values are for x86-32 linux.
 
   /// Returns the number of bits necessary to hold the specified type.
   ///
   /// For example, returns 36 for i36 and 80 for x86_fp80. The type passed must
   /// have a size (Type::isSized() must return true).
+  ///
+  /// An assert will occur if this is called on a scalable vector type.
   uint64_t getTypeSizeInBits(Type *Ty) const;
 
+  /// Returns the minimum number of bits necessary to hold the specified type
+  /// and a boolean indicating whether the runtime size is exactly that size
+  /// (if false) or if it's an integer multiple of that minimum (true).
+  ScalableSize getScalableTypeSizeInBits(Type *Ty) const;
+
+  /// Returns the size of the type in bits. If the type is scalable, this
+  /// quantity represents the known minimum size. If the type is not scalable,
+  /// it represents the exact size.
+  uint64_t getKnownMinTypeSizeInBits(Type *Ty) const;
+
   /// Returns the maximum number of bytes that may be overwritten by
   /// storing the specified type.
   ///
   /// For example, returns 5 for i36 and 10 for x86_fp80.
+  ///
+  /// An assert will occur if this is called on a scalable vector type.
   uint64_t getTypeStoreSize(Type *Ty) const {
     return (getTypeSizeInBits(Ty) + 7) / 8;
   }
 
+  /// Returns the number of bytes overwritten by a store of the specified type,
+  /// along with a boolean indicating whether the runtime size written to is
+  /// exactly that size (if false) or if it's an integer multiple of that
+  /// size (true).
+  ScalableSize getScalableTypeStoreSize(Type *Ty) const {
+    auto Bits = getScalableTypeSizeInBits(Ty);
+    return ScalableSize((Bits.getKnownMinSize()+7)/8, Bits.isScalable());
+  }
+
+  /// Returns the number of bytes overwritten by a store of the specified type.
+  /// If the type is scalable, this quantity represents the known minimum size.
+  /// If not scalable, it represents the exact size.
+  uint64_t getKnownMinTypeStoreSize(Type *Ty) const {
+    return (getScalableTypeSizeInBits(Ty).getKnownMinSize()+7)/8;
+  }
+
   /// Returns the maximum number of bits that may be overwritten by
   /// storing the specified type; always a multiple of 8.
   ///
   /// For example, returns 40 for i36 and 80 for x86_fp80.
+  ///
+  /// An assert will occur if this is called on a scalable vector type.
   uint64_t getTypeStoreSizeInBits(Type *Ty) const {
     return 8 * getTypeStoreSize(Ty);
   }
+    /// Returns the number of bits overwritten by a store of the specified type,
+    /// along with a boolean indicating whether the runtime size written to is
+    /// exactly that size (if false) or if it's an integer multiple of that
+    /// size (true).
+  ScalableSize getScalableTypeStoreSizeInBits(Type *Ty) const {
+    auto Bytes = getScalableTypeStoreSize(Ty);
+    return {Bytes.getKnownMinSize() * 8, Bytes.isScalable()};
+  }
+
+    /// Returns the number of bits overwritten by a store of the specified type.
+    /// If the type is scalable, this quantity represents the known minimum
+    /// size. If not scalable, it represents the exact size.
+  uint64_t getKnownMinTypeStoreSizeInBits(Type *Ty) const {
+    return 8 * getKnownMinTypeStoreSize(Ty);
+  }
 
   /// Returns true if no extra padding bits are needed when storing the
   /// specified type.
   ///
   /// For example, returns false for i19 that has a 24-bit store size.
   bool typeSizeEqualsStoreSize(Type *Ty) const {
-    return getTypeSizeInBits(Ty) == getTypeStoreSizeInBits(Ty);
+    return getScalableTypeSizeInBits(Ty) == getScalableTypeStoreSizeInBits(Ty);
   }
 
   /// Returns the offset in bytes between successive objects of the
   /// specified type, including alignment padding.
   ///
   /// This is the amount that alloca reserves for this type. For example,
   /// returns 12 or 16 for x86_fp80, depending on alignment.
+  ///
+  /// An assert will occur if this is called on a scalable vector type.
   uint64_t getTypeAllocSize(Type *Ty) const {
     // Round up to the next alignment boundary.
     return alignTo(getTypeStoreSize(Ty), getABITypeAlignment(Ty));
   }
 
+  /// Returns the offset in bytes between successive object of the specified
+  /// type (including alignment padding), along with a boolean indicating
+  /// whether the runtime size written to is exactly that size (if false) or if
+  /// it's an integer multiple of that size (true).
+  ScalableSize getScalableTypeAllocSize(Type *Ty) const {
+    auto Bytes = getScalableTypeStoreSize(Ty);
+    uint64_t MinAlignedSize = alignTo(Bytes.getKnownMinSize(),
+                                      getABITypeAlignment(Ty));
+    return ScalableSize(MinAlignedSize, Bytes.isScalable());
+  }
+
+  /// Returns the offset in bytes between successive objects of the
+  /// specified type, including alignment padding.
+  /// If the type is scalable, this quantity represents the known minimum size.
+  /// If not scalable, it represents the exact size.
+  uint64_t getKnownMinTypeAllocSize(Type *Ty) const {
+    return alignTo(getKnownMinTypeStoreSize(Ty), getABITypeAlignment(Ty));
+  }
+
   /// Returns the offset in bits between successive objects of the
   /// specified type, including alignment padding; always a multiple of 8.
   ///
   /// This is the amount that alloca reserves for this type. For example,
   /// returns 96 or 128 for x86_fp80, depending on alignment.
+  ///
+  /// An assert will occur if this is called on a scalable vector type.
   uint64_t getTypeAllocSizeInBits(Type *Ty) const {
     return 8 * getTypeAllocSize(Ty);
   }
 
+  /// Returns the offset in bits between successive object of the specified
+  /// type (including alignment padding), along with a boolean indicating
+  /// whether the runtime size written to is exactly that size (if false) or if
+  /// it's an integer multiple of that size (true).
+  ScalableSize getScalableTypeAllocSizeInBits(Type *Ty) const {
+    auto Bytes = getScalableTypeAllocSize(Ty);
+    return {Bytes.getKnownMinSize() * 8, Bytes.isScalable()};
+  }
+
+  /// Returns the offset in bits between successive objects of the
+  /// specified type, including alignment padding.
+  /// If the type is scalable, this quantity represents the known minimum size.
+  /// If not scalable, it represents the exact size.
+  uint64_t getKnownMinTypeAllocSizeInBits(Type *Ty) const {
+    return 8 * getKnownMinTypeAllocSize(Ty);
+  }
+
   /// Returns the minimum ABI-required alignment for the specified type.
   unsigned getABITypeAlignment(Type *Ty) const;
 
   /// Returns the minimum ABI-required alignment for an integer type of
   /// the specified bitwidth.
   unsigned getABIIntegerTypeAlignment(unsigned BitWidth) const;
 
   /// Returns the preferred stack/global alignment for the specified

 };
 
 // The implementation of this method is provided inline as it is particularly
 // well suited to constant folding when called on a specific Type subclass.
 inline uint64_t DataLayout::getTypeSizeInBits(Type *Ty) const {
   assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
   switch (Ty->getTypeID()) {
   case Type::LabelTyID:
     return getPointerSizeInBits(0);
   case Type::PointerTyID:
     return getPointerSizeInBits(Ty->getPointerAddressSpace());
   case Type::ArrayTyID: {
     ArrayType *ATy = cast<ArrayType>(Ty);
     return ATy->getNumElements() *
            getTypeAllocSizeInBits(ATy->getElementType());
   }
   case Type::StructTyID:
inline uint64_t DataLayout::getTypeSizeInBits(Type *Ty) const {
   case Type::FP128TyID:
     return 128;
   // In memory objects this is always aligned to a higher boundary, but
   // only 80 bits contain information.
   case Type::X86_FP80TyID:
     return 80;
   case Type::VectorTyID: {
     VectorType *VTy = cast<VectorType>(Ty);
+    assert(!VTy->isScalable() &&
+           "Scalable vector sizes cannot be represented by a scalar");
     return VTy->getNumElements() * getTypeSizeInBits(VTy->getElementType());
   }
   default:
     llvm_unreachable("DataLayout::getTypeSizeInBits(): Unsupported type");
   }
 }
 
+inline ScalableSize DataLayout::getScalableTypeSizeInBits(Type *Ty) const {
+  switch(Ty->getTypeID()) {
+  default:
+    return {getTypeSizeInBits(Ty), false};
+  case Type::VectorTyID: {
+    VectorType *VTy = cast<VectorType>(Ty);
+    auto EltCnt = VTy->getElementCount();
+    uint64_t MinBits = EltCnt.Min * getTypeSizeInBits(VTy->getElementType());
+    return {MinBits, EltCnt.Scalable};
+  }
+  }
+}
+
+inline uint64_t DataLayout::getKnownMinTypeSizeInBits(Type *Ty) const {
+  return getScalableTypeSizeInBits(Ty).getKnownMinSize();
+}
+
 } // end namespace llvm
 
 #endif // LLVM_IR_DATALAYOUT_H

llvm/include/llvm/IR/InstrTypes.h

public:
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 
   /// Create a result type for fcmp/icmp
   static Type* makeCmpResultType(Type* opnd_type) {
     if (VectorType* vt = dyn_cast<VectorType>(opnd_type)) {
       return VectorType::get(Type::getInt1Ty(opnd_type->getContext()),
-                             vt->getNumElements());
+                             vt->getElementCount());
     }
     return Type::getInt1Ty(opnd_type->getContext());
   }
 
 private:
   // Shadow Value::setValueSubclassData with a private forwarding method so that
   // subclasses cannot accidentally use it.
   void setValueSubclassData(unsigned short D) {

llvm/include/llvm/IR/Type.h

 
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/Support/CBindingWrapping.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/ScalableSize.h"
 #include <cassert>
 #include <cstdint>
 #include <iterator>
 
 namespace llvm {
 
 template<class GraphType> struct GraphTraits;
 class IntegerType;
public:
   /// This will return zero if the type does not have a size or is not a
   /// primitive type.
   ///
   /// Note that this may not reflect the size of memory allocated for an
   /// instance of the type or the number of bytes that are written when an
   /// instance of the type is stored to memory. The DataLayout class provides
   /// additional query functions to provide this information.
   ///
+  /// An assert will occur if this is called on a scalable vector type.
   unsigned getPrimitiveSizeInBits() const LLVM_READONLY;
 
+  // Returns a ScalableSize for the type in question. This should be used in
+  // place of getPrimitiveSizeInBits in places where the type may be a
+  // VectorType with the Scalable flag set.
+  ScalableSize getScalableSizeInBits() const LLVM_READONLY;
+
+  /// Returns the minimum known size in bits, ignoring whether the type might
+  /// be a scalable vector.
+  unsigned getKnownMinSizeInBits() const LLVM_READONLY;
+
+  /// Returns the minimum known size in bits, asserting if called on a scalable
+  /// vector type.
+  unsigned getFixedSizeInBits() const LLVM_READONLY;
+
   /// If this is a vector type, return the getPrimitiveSizeInBits value for the
   /// element type. Otherwise return the getPrimitiveSizeInBits value for this
   /// type.
   unsigned getScalarSizeInBits() const LLVM_READONLY;
 
   /// Return the width of the mantissa of this type. This is only valid on
   /// floating-point types. If the FP type does not have a stable mantissa (e.g.
   /// ppc long double), this method returns -1.

llvm/include/llvm/Support/ScalableSize.h

 // which may be scalable vectors. It provides convenience operators so that
 // it can be used in much the same way as a single scalar value.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_SCALABLESIZE_H
 #define LLVM_SUPPORT_SCALABLESIZE_H
 
+#include <tuple>
+
 namespace llvm {
 
 class ElementCount {
 public:
   unsigned Min;  // Minimum number of vector elements.
   bool Scalable; // If true, NumElements is a multiple of 'Min' determined
                  // at runtime rather than compile time.
 
   ElementCount(unsigned Min, bool Scalable)
   : Min(Min), Scalable(Scalable) {}
 
   ElementCount operator*(unsigned RHS) {
     return { Min * RHS, Scalable };
   }
   ElementCount operator/(unsigned RHS) {
     return { Min / RHS, Scalable };
   }
 
   bool operator==(const ElementCount& RHS) const {
     return Min == RHS.Min && Scalable == RHS.Scalable;
   }
 };
 
+// This class is used to represent the size of types. If the type is of fixed
+// size, it will represent the exact size. If the type is a scalable vector,
+// it will represent the known minimum size.
+class ScalableSize {
+  uint64_t MinSize; // The known minimum size.
+  bool Scalable;    // If true, then the runtime size is an integer multiple
+                    // of MinSize.
+
+public:
+  constexpr ScalableSize(uint64_t MinSize, bool Scalable)
+    : MinSize(MinSize), Scalable(Scalable) {}
+
+  // Scalable vector types with the same minimum size as a fixed size type are
+  // not guaranteed to be the same size at runtime, so they are never
+  // considered to be equal.
+  friend bool operator==(const ScalableSize &LHS, const ScalableSize &RHS) {
+    return std::tie(LHS.MinSize, LHS.Scalable) ==
+           std::tie(RHS.MinSize, RHS.Scalable);
+  }
+
+  friend bool operator!=(const ScalableSize &LHS, const ScalableSize &RHS) {
+    return !(LHS == RHS);
+  }
+
+  // For many cases, size ordering between scalable and fixed size types cannot
+  // be determined at compile time, so such comparisons aren't allowed.
+  //
+  // e.g. <vscale x 2 x i16> could be bigger than <4 x i32> with a runtime
+  // vscale >= 5, equal sized with a vscale of 4, and smaller with
+  // a vscale <= 3.
+  //
+  // If the scalable flags match, just perform the requested comparison
+  // between the minimum sizes.
+  friend bool operator<(const ScalableSize &LHS, const ScalableSize &RHS) {
+    assert(LHS.Scalable == RHS.Scalable &&
+           "Ordering comparison of scalable and fixed types");
+
+    return LHS.MinSize < RHS.MinSize;
+  }
+
+  friend bool operator>(const ScalableSize &LHS, const ScalableSize &RHS) {
+    return RHS < LHS;
+  }
+
+  friend bool operator<=(const ScalableSize &LHS, const ScalableSize &RHS) {
+    return !(RHS < LHS);
+  }
+
+  friend bool operator>=(const ScalableSize &LHS, const ScalableSize& RHS) {
+    return !(LHS < RHS);
+  }
+
+  // Convenience operators to obtain relative sizes independently of
+  // the scalable flag.
+  ScalableSize operator*(unsigned RHS) const {
+    return { MinSize * RHS, Scalable };
+  }
+
+  friend ScalableSize operator*(const unsigned LHS, const ScalableSize &RHS) {
+    return { RHS.MinSize * LHS, RHS.Scalable };
+  }
+
+  ScalableSize operator/(unsigned RHS) const {
+    return { MinSize / RHS, Scalable };
+  }
+
+  // Return the minimum size with the assumption that the size is exact.
+  // Use in places where a scalable size doesn't make sense (e.g. non-vector
+  // types, or vectors in backends which don't support scalable vectors)
+  uint64_t getFixedSize() const {
+    assert(!Scalable && "Request for a fixed size on a scalable object");
+    return MinSize;
+  }
+
+  // Return the known minimum size. Use in places where the scalable property
+  // doesn't matter (e.g. determining alignment) or in conjunction with the
+  // isScalable method below.
+  uint64_t getKnownMinSize() const {
+    return MinSize;
+  }
+
+  // Return whether or not the size is scalable.
+  bool isScalable() const {
+    return Scalable;
+  }
+};
+
 } // end namespace llvm
 
 #endif // LLVM_SUPPORT_SCALABLESIZE_H

llvm/lib/IR/DataLayout.cpp

 #include "llvm/IR/GetElementPtrTypeIterator.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Type.h"
 #include "llvm/IR/Value.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
+#include "llvm/Support/ScalableSize.h"
 #include <algorithm>
 #include <cassert>
 #include <cstdint>
 #include <cstdlib>
 #include <tuple>
 #include <utility>
 
 using namespace llvm;
unsigned DataLayout::getAlignment(Type *Ty, bool abi_or_pref) const {
   case Type::X86_MMXTyID:
   case Type::VectorTyID:
     AlignType = VECTOR_ALIGN;
     break;
   default:
     llvm_unreachable("Bad type for getAlignment!!!");
   }
 
-  return getAlignmentInfo(AlignType, getTypeSizeInBits(Ty), abi_or_pref, Ty);
+  // If we're dealing with a scalable vector, we just need the known minimum
+  // size for determining alignment. If not, we'll get the exact size.
+  return getAlignmentInfo(AlignType, getKnownMinTypeSizeInBits(Ty),
+                          abi_or_pref, Ty);
 }
 
 unsigned DataLayout::getABITypeAlignment(Type *Ty) const {
   return getAlignment(Ty, true);
 }
 
 /// getABIIntegerTypeAlignment - Return the minimum ABI-required alignment for
 /// an integer type of the specified bitwidth.

llvm/lib/IR/Instructions.cpp

 #include "llvm/IR/Module.h"
 #include "llvm/IR/Operator.h"
 #include "llvm/IR/Type.h"
 #include "llvm/IR/Value.h"
 #include "llvm/Support/AtomicOrdering.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
+#include "llvm/Support/ScalableSize.h"
 #include <algorithm>
 #include <cassert>
 #include <cstdint>
 #include <vector>
 
 using namespace llvm;
 
 static cl::opt<bool> SwitchInstProfUpdateWrapperStrict(

 //===----------------------------------------------------------------------===//
 //                      ShuffleVectorInst Implementation
 //===----------------------------------------------------------------------===//
 
 ShuffleVectorInst::ShuffleVectorInst(Value *V1, Value *V2, Value *Mask,
                                      const Twine &Name,
                                      Instruction *InsertBefore)
 : Instruction(VectorType::get(cast<VectorType>(V1->getType())->getElementType(),
-                cast<VectorType>(Mask->getType())->getNumElements()),
+                cast<VectorType>(Mask->getType())->getElementCount()),
               ShuffleVector,
               OperandTraits<ShuffleVectorInst>::op_begin(this),
               OperandTraits<ShuffleVectorInst>::operands(this),
               InsertBefore) {
   assert(isValidOperands(V1, V2, Mask) &&
          "Invalid shuffle vector instruction operands!");
   Op<0>() = V1;
   Op<1>() = V2;
   Op<2>() = Mask;
   setName(Name);
 }
 
 ShuffleVectorInst::ShuffleVectorInst(Value *V1, Value *V2, Value *Mask,
                                      const Twine &Name,
                                      BasicBlock *InsertAtEnd)
 : Instruction(VectorType::get(cast<VectorType>(V1->getType())->getElementType(),
-                cast<VectorType>(Mask->getType())->getNumElements()),
+                cast<VectorType>(Mask->getType())->getElementCount()),
               ShuffleVector,
               OperandTraits<ShuffleVectorInst>::op_begin(this),
               OperandTraits<ShuffleVectorInst>::operands(this),
               InsertAtEnd) {
   assert(isValidOperands(V1, V2, Mask) &&
          "Invalid shuffle vector instruction operands!");
 
   Op<0>() = V1;
if (VectorType *SrcVecTy = dyn_cast<VectorType>(SrcTy))
     if (VectorType *DestVecTy = dyn_cast<VectorType>(DestTy))
       if (SrcVecTy->getNumElements() == DestVecTy->getNumElements()) {
         // An element by element cast.  Valid if casting the elements is valid.
         SrcTy = SrcVecTy->getElementType();
         DestTy = DestVecTy->getElementType();
       }
 
   // Get the bit sizes, we'll need these
-  unsigned SrcBits = SrcTy->getPrimitiveSizeInBits();   // 0 for ptr
-  unsigned DestBits = DestTy->getPrimitiveSizeInBits(); // 0 for ptr
+  auto SrcBits = SrcTy->getScalableSizeInBits();   // 0 for ptr
+  auto DestBits = DestTy->getScalableSizeInBits(); // 0 for ptr
 
   // Run through the possibilities ...
   if (DestTy->isIntegerTy()) {               // Casting to integral
     if (SrcTy->isIntegerTy())                // Casting from integral
         return true;
     if (SrcTy->isFloatingPointTy())   // Casting from floating pt
       return true;
     if (SrcTy->isVectorTy())          // Casting from vector
bool CastInst::isBitCastable(Type *SrcTy, Type *DestTy) {
   if (!SrcTy->isFirstClassType() || !DestTy->isFirstClassType())
     return false;
 
   if (SrcTy == DestTy)
     return true;
 
   if (VectorType *SrcVecTy = dyn_cast<VectorType>(SrcTy)) {
     if (VectorType *DestVecTy = dyn_cast<VectorType>(DestTy)) {
-      if (SrcVecTy->getNumElements() == DestVecTy->getNumElements()) {
+      if (SrcVecTy->getElementCount() == DestVecTy->getElementCount()) {
         // An element by element cast. Valid if casting the elements is valid.
         SrcTy = SrcVecTy->getElementType();
         DestTy = DestVecTy->getElementType();
       }
     }
   }
 
   if (PointerType *DestPtrTy = dyn_cast<PointerType>(DestTy)) {
     if (PointerType *SrcPtrTy = dyn_cast<PointerType>(SrcTy)) {
       return SrcPtrTy->getAddressSpace() == DestPtrTy->getAddressSpace();
     }
   }
 
-  unsigned SrcBits = SrcTy->getPrimitiveSizeInBits();   // 0 for ptr
-  unsigned DestBits = DestTy->getPrimitiveSizeInBits(); // 0 for ptr
+  auto SrcBits = SrcTy->getScalableSizeInBits();   // 0 for ptr
+  auto DestBits = DestTy->getScalableSizeInBits(); // 0 for ptr
 
   // Could still have vectors of pointers if the number of elements doesn't
   // match
-  if (SrcBits == 0 || DestBits == 0)
+  if (SrcBits.getKnownMinSize() == 0 || DestBits.getKnownMinSize() == 0)
     return false;
 
   if (SrcBits != DestBits)
     return false;
 
   if (DestTy->isX86_MMXTy() || SrcTy->isX86_MMXTy())
     return false;
 
case Instruction::BitCast: {
     // BitCast implies a no-op cast of type only. No bits change.
     // However, you can't cast pointers to anything but pointers.
     if (!SrcPtrTy != !DstPtrTy)
       return false;
 
     // For non-pointer cases, the cast is okay if the source and destination bit
     // widths are identical.
     if (!SrcPtrTy)
-      return SrcTy->getPrimitiveSizeInBits() == DstTy->getPrimitiveSizeInBits();
+      return SrcTy->getScalableSizeInBits() == DstTy->getScalableSizeInBits();
 
     // If both are pointers then the address spaces must match.
     if (SrcPtrTy->getAddressSpace() != DstPtrTy->getAddressSpace())
       return false;
 
     // A vector of pointers must have the same number of elements.
     VectorType *SrcVecTy = dyn_cast<VectorType>(SrcTy);
     VectorType *DstVecTy = dyn_cast<VectorType>(DstTy);

llvm/lib/IR/Type.cpp

 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Value.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/raw_ostream.h"
+#include "llvm/Support/ScalableSize.h"
 #include <cassert>
 #include <utility>
 
 using namespace llvm;
 
 //===----------------------------------------------------------------------===//
 //                         Type Class Implementation
 //===----------------------------------------------------------------------===//
unsigned Type::getPrimitiveSizeInBits() const {
   case Type::HalfTyID: return 16;
   case Type::FloatTyID: return 32;
   case Type::DoubleTyID: return 64;
   case Type::X86_FP80TyID: return 80;
   case Type::FP128TyID: return 128;
   case Type::PPC_FP128TyID: return 128;
   case Type::X86_MMXTyID: return 64;
   case Type::IntegerTyID: return cast<IntegerType>(this)->getBitWidth();
-  case Type::VectorTyID:  return cast<VectorType>(this)->getBitWidth();
+  case Type::VectorTyID: {
+    const VectorType *VTy = cast<VectorType>(this);
+    assert(!VTy->isScalable() && "Scalable vectors are not a primitive type");
+    return VTy->getBitWidth();
+  }
   default: return 0;
   }
 }
 
 unsigned Type::getScalarSizeInBits() const {
   return getScalarType()->getPrimitiveSizeInBits();
 }
 
+ScalableSize Type::getScalableSizeInBits() const {
+  if (auto *VTy = dyn_cast<VectorType>(this))
+    return {VTy->getBitWidth(), VTy->isScalable()};
+
+  return {getPrimitiveSizeInBits(), false};
+}
+
+unsigned Type::getKnownMinSizeInBits() const {
+  return getScalableSizeInBits().getKnownMinSize();
+}
+
+unsigned Type::getFixedSizeInBits() const {
+  return getScalableSizeInBits().getFixedSize();
+}
+
 int Type::getFPMantissaWidth() const {
   if (auto *VTy = dyn_cast<VectorType>(this))
     return VTy->getElementType()->getFPMantissaWidth();
   assert(isFloatingPointTy() && "Not a floating point type!");
   if (getTypeID() == HalfTyID) return 11;
   if (getTypeID() == FloatTyID) return 24;
   if (getTypeID() == DoubleTyID) return 53;
   if (getTypeID() == X86_FP80TyID) return 64;

llvm/test/Other/scalable-vectors-core-ir.ll

+; RUN: opt -S -verify < %s | FileCheck %s
+target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
+target triple = "aarch64--linux-gnu"
+
+;; Check supported instructions are accepted without dropping 'vscale'.
+;; Same order as the LangRef
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Unary Operations
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+
+define <vscale x 2 x double> @fneg(<vscale x 2 x double> %val) {
+; CHECK-LABEL: @fneg
+; CHECK: %r = fneg <vscale x 2 x double> %val
+; CHECK-NEXT: ret <vscale x 2 x double> %r
+  %r = fneg <vscale x 2 x double> %val
+  ret <vscale x 2 x double> %r
+}
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Binary Operations
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+define <vscale x 8 x i16> @add(<vscale x 8 x i16> %a, <vscale x 8 x i16> %b) {
+; CHECK-LABEL: @add
+; CHECK: %r = add <vscale x 8 x i16> %a, %b
+; CHECK-NEXT: ret <vscale x 8 x i16> %r
+  %r = add <vscale x 8 x i16> %a, %b
+  ret <vscale x 8 x i16> %r
+}
+
+define <vscale x 4 x float> @fadd(<vscale x 4 x float> %a, <vscale x 4 x float> %b) {
+; CHECK-LABEL: @fadd
+; CHECK: %r = fadd <vscale x 4 x float> %a, %b
+; CHECK-NEXT: ret <vscale x 4 x float> %r
+  %r = fadd <vscale x 4 x float> %a, %b
+  ret <vscale x 4 x float> %r
+}
+
+define <vscale x 4 x i32> @sub(<vscale x 4 x i32> %a, <vscale x 4 x i32> %b) {
+; CHECK-LABEL: @sub
+; CHECK: %r = sub <vscale x 4 x i32> %a, %b
+; CHECK-NEXT: ret <vscale x 4 x i32> %r
+  %r = sub <vscale x 4 x i32> %a, %b
+  ret <vscale x 4 x i32> %r
+}
+
+define <vscale x 4 x float> @fsub(<vscale x 4 x float> %a, <vscale x 4 x float> %b) {
+; CHECK-LABEL: @fsub
+; CHECK: %r = fsub <vscale x 4 x float> %a, %b
+; CHECK-NEXT: ret <vscale x 4 x float> %r
+  %r = fsub <vscale x 4 x float> %a, %b
+  ret <vscale x 4 x float> %r
+}
+
+define <vscale x 4 x i32> @mul(<vscale x 4 x i32> %a, <vscale x 4 x i32> %b) {
+; CHECK-LABEL: @mul
+; CHECK: %r = mul <vscale x 4 x i32> %a, %b
+; CHECK-NEXT: ret <vscale x 4 x i32> %r
+  %r = mul <vscale x 4 x i32> %a, %b
+  ret <vscale x 4 x i32> %r
+}
+
+define <vscale x 4 x float> @fmul(<vscale x 4 x float> %a, <vscale x 4 x float> %b) {
+; CHECK-LABEL: @fmul
+; CHECK: %r = fmul <vscale x 4 x float> %a, %b
+; CHECK-NEXT: ret <vscale x 4 x float> %r
+  %r = fmul <vscale x 4 x float> %a, %b
+  ret <vscale x 4 x float> %r
+}
+
+define <vscale x 4 x i32> @udiv(<vscale x 4 x i32> %a, <vscale x 4 x i32> %b) {
+; CHECK-LABEL: @udiv
+; CHECK: %r = udiv <vscale x 4 x i32> %a, %b
+; CHECK-NEXT: ret <vscale x 4 x i32> %r
+  %r = udiv <vscale x 4 x i32> %a, %b
+  ret <vscale x 4 x i32> %r
+}
+
+define <vscale x 4 x i32> @sdiv(<vscale x 4 x i32> %a, <vscale x 4 x i32> %b) {
+; CHECK-LABEL: @sdiv
+; CHECK: %r = sdiv <vscale x 4 x i32> %a, %b
+; CHECK-NEXT: ret <vscale x 4 x i32> %r
+  %r = sdiv <vscale x 4 x i32> %a, %b
+  ret <vscale x 4 x i32> %r
+}
+
+define <vscale x 4 x float> @fdiv(<vscale x 4 x float> %a, <vscale x 4 x float> %b) {
+; CHECK-LABEL: @fdiv
+; CHECK: %r = fdiv <vscale x 4 x float> %a, %b
+; CHECK-NEXT: ret <vscale x 4 x float> %r
+  %r = fdiv <vscale x 4 x float> %a, %b
+  ret <vscale x 4 x float> %r
+}
+
+define <vscale x 4 x i32> @urem(<vscale x 4 x i32> %a, <vscale x 4 x i32> %b) {
+; CHECK-LABEL: @urem
+; CHECK: %r = urem <vscale x 4 x i32> %a, %b
+; CHECK-NEXT: ret <vscale x 4 x i32> %r
+  %r = urem <vscale x 4 x i32> %a, %b
+  ret <vscale x 4 x i32> %r
+}
+
+define <vscale x 4 x i32> @srem(<vscale x 4 x i32> %a, <vscale x 4 x i32> %b) {
+; CHECK-LABEL: @srem
+; CHECK: %r = srem <vscale x 4 x i32> %a, %b
+; CHECK-NEXT: ret <vscale x 4 x i32> %r
+  %r = srem <vscale x 4 x i32> %a, %b
+  ret <vscale x 4 x i32> %r
+}
+
+define <vscale x 4 x float> @frem(<vscale x 4 x float> %a, <vscale x 4 x float> %b) {
+; CHECK-LABEL: @frem
+; CHECK: %r = frem <vscale x 4 x float> %a, %b
+; CHECK-NEXT: ret <vscale x 4 x float> %r
+  %r = frem <vscale x 4 x float> %a, %b
+  ret <vscale x 4 x float> %r
+}
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Bitwise Binary Operations
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+define <vscale x 4 x i32> @shl(<vscale x 4 x i32> %a, <vscale x 4 x i32> %b) {
+; CHECK-LABEL: @shl
+; CHECK: %r = shl <vscale x 4 x i32> %a, %b
+; CHECK-NEXT: ret <vscale x 4 x i32> %r
+  %r = shl <vscale x 4 x i32> %a, %b
+  ret <vscale x 4 x i32> %r
+}
+
+define <vscale x 4 x i32> @lshr(<vscale x 4 x i32> %a, <vscale x 4 x i32> %b) {
+; CHECK-LABEL: @lshr
+; CHECK: %r = lshr <vscale x 4 x i32> %a, %b
+; CHECK-NEXT: ret <vscale x 4 x i32> %r
+  %r = lshr <vscale x 4 x i32> %a, %b
+  ret <vscale x 4 x i32> %r
+}
+
+define <vscale x 4 x i32> @ashr(<vscale x 4 x i32> %a, <vscale x 4 x i32> %b) {
+; CHECK-LABEL: @ashr
+; CHECK: %r = ashr <vscale x 4 x i32> %a, %b
+; CHECK-NEXT: ret <vscale x 4 x i32> %r
+  %r = ashr <vscale x 4 x i32> %a, %b
+  ret <vscale x 4 x i32> %r
+}
+
+define <vscale x 4 x i32> @and(<vscale x 4 x i32> %a, <vscale x 4 x i32> %b) {
+; CHECK-LABEL: @and
+; CHECK: %r = and <vscale x 4 x i32> %a, %b
+; CHECK-NEXT: ret <vscale x 4 x i32> %r
+  %r = and <vscale x 4 x i32> %a, %b
+  ret <vscale x 4 x i32> %r
+}
+
+define <vscale x 4 x i32> @or(<vscale x 4 x i32> %a, <vscale x 4 x i32> %b) {
+; CHECK-LABEL: @or
+; CHECK: %r = or <vscale x 4 x i32> %a, %b
+; CHECK-NEXT: ret <vscale x 4 x i32> %r
+  %r = or <vscale x 4 x i32> %a, %b
+  ret <vscale x 4 x i32> %r
+}
+
+define <vscale x 4 x i32> @xor(<vscale x 4 x i32> %a, <vscale x 4 x i32> %b) {
+; CHECK-LABEL: @xor
+; CHECK: %r = xor <vscale x 4 x i32> %a, %b
+; CHECK-NEXT: ret <vscale x 4 x i32> %r
+  %r = xor <vscale x 4 x i32> %a, %b
+  ret <vscale x 4 x i32> %r
+}
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Vector Operations
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+define i64 @extractelement(<vscale x 2 x i64> %val) {
+; CHECK-LABEL: @extractelement
+; CHECK: %r = extractelement <vscale x 2 x i64> %val, i32 0
+; CHECK-NEXT: ret i64 %r
+  %r = extractelement <vscale x 2 x i64> %val, i32 0
+  ret i64 %r
+}
+
+define <vscale x 16 x i8> @insertelement(<vscale x 16 x i8> %vec, i8 %ins) {
+; CHECK-LABEL: @insertelement
+; CHECK: %r = insertelement <vscale x 16 x i8> %vec, i8 %ins, i32 0
+; CHECK-NEXT: ret <vscale x 16 x i8> %r
+  %r = insertelement <vscale x 16 x i8> %vec, i8 %ins, i32 0
+  ret <vscale x 16 x i8> %r
+}
+
+define <vscale x 8 x half> @shufflevector(half %val) {
+; CHECK-LABEL: @shufflevector
+; CHECK: %insvec = insertelement <vscale x 8 x half> undef, half %val, i32 0
+; CHECK-NEXT: %r = shufflevector <vscale x 8 x half> %insvec, <vscale x 8 x half> undef, <vscale x 8 x i32> zeroinitializer
+; CHECK-NEXT: ret <vscale x 8 x half> %r
+  %insvec = insertelement <vscale x 8 x half> undef, half %val, i32 0
+  %r = shufflevector <vscale x 8 x half> %insvec, <vscale x 8 x half> undef, <vscale x 8 x i32> zeroinitializer
+  ret <vscale x 8 x half> %r
+}
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Memory Access and Addressing Operations
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+define void @alloca() {
+; CHECK-LABEL: @alloca
+; CHECK: %vec = alloca <vscale x 4 x i32>
+; CHECK-NEXT: ret void
+  %vec = alloca <vscale x 4 x i32>
+  ret void
+}
+
+define <vscale x 2 x double> @load(<vscale x 2 x double>* %ptr) {
+; CHECK-LABEL: @load
+; CHECK: %r = load <vscale x 2 x double>, <vscale x 2 x double>* %ptr
+; CHECK-NEXT: ret <vscale x 2 x double> %r
+  %r = load <vscale x 2 x double>, <vscale x 2 x double>* %ptr
+  ret <vscale x 2 x double> %r
+}
+
+define void @store(<vscale x 4 x i32> %data, <vscale x 4 x i32>* %ptr) {
+; CHECK-LABEL: @store
+; CHECK: store <vscale x 4 x i32> %data, <vscale x 4 x i32>* %ptr
+; CHECK-NEXT: ret void
+  store <vscale x 4 x i32> %data, <vscale x 4 x i32>* %ptr
+  ret void
+}
+
+define <vscale x 4 x float>* @getelementptr(<vscale x 4 x float>* %base) {
+; CHECK-LABEL: @getelementptr
+; CHECK: %r = getelementptr <vscale x 4 x float>, <vscale x 4 x float>* %base, i64 0
+; CHECK-NEXT: ret <vscale x 4 x float>* %r
+  %r = getelementptr <vscale x 4 x float>, <vscale x 4 x float>* %base, i64 0
+  ret <vscale x 4 x float>* %r
+}
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Conversion Operations
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+define <vscale x 4 x i32> @truncto(<vscale x 4 x i64> %val) {
+; CHECK-LABEL: @truncto
+; CHECK: %r = trunc <vscale x 4 x i64> %val to <vscale x 4 x i32>
+; CHECK-NEXT: ret <vscale x 4 x i32> %r
+  %r = trunc <vscale x 4 x i64> %val to <vscale x 4 x i32>
+  ret <vscale x 4 x i32> %r
+}
+
+define <vscale x 2 x i64> @zextto(<vscale x 2 x i16> %val) {
+; CHECK-LABEL: @zextto
+; CHECK: %r = zext <vscale x 2 x i16> %val to <vscale x 2 x i64>
+; CHECK-NEXT: ret <vscale x 2 x i64> %r
+  %r = zext <vscale x 2 x i16> %val to <vscale x 2 x i64>
+  ret <vscale x 2 x i64> %r
+}
+
+define <vscale x 4 x i32> @sextto(<vscale x 4 x i8> %val) {
+; CHECK-LABEL: @sextto
+; CHECK: %r = sext <vscale x 4 x i8> %val to <vscale x 4 x i32>
+; CHECK-NEXT: ret <vscale x 4 x i32> %r
+  %r = sext <vscale x 4 x i8> %val to <vscale x 4 x i32>
+  ret <vscale x 4 x i32> %r
+}
+
+define <vscale x 4 x half> @fptruncto(<vscale x 4 x float> %val) {
+; CHECK-LABEL: @fptruncto
+; CHECK: %r = fptrunc <vscale x 4 x float> %val to <vscale x 4 x half>
+; CHECK-NEXT: ret <vscale x 4 x half> %r
+  %r = fptrunc <vscale x 4 x float> %val to <vscale x 4 x half>
+  ret <vscale x 4 x half> %r
+}
+
+define <vscale x 2 x double> @fpextto(<vscale x 2 x half> %val) {
+; CHECK-LABEL: @fpextto
+; CHECK: %r = fpext <vscale x 2 x half> %val to <vscale x 2 x double>
+; CHECK-NEXT: ret <vscale x 2 x double> %r
+  %r = fpext <vscale x 2 x half> %val to <vscale x 2 x double>
+  ret <vscale x 2 x double> %r
+}
+
+define <vscale x 4 x i32> @fptouito(<vscale x 4 x float> %val) {
+; CHECK-LABEL: @fptoui
+; CHECK: %r = fptoui <vscale x 4 x float> %val to <vscale x 4 x i32>
+; CHECK-NEXT: ret <vscale x 4 x i32> %r
+  %r = fptoui <vscale x 4 x float> %val to <vscale x 4 x i32>
+  ret <vscale x 4 x i32> %r
+}
+
+define <vscale x 4 x i32> @fptosito(<vscale x 4 x float> %val) {
+; CHECK-LABEL: @fptosi
+; CHECK: %r = fptosi <vscale x 4 x float> %val to <vscale x 4 x i32>
+; CHECK-NEXT: ret <vscale x 4 x i32> %r
+  %r = fptosi <vscale x 4 x float> %val to <vscale x 4 x i32>
+  ret <vscale x 4 x i32> %r
+}
+
+define <vscale x 4 x float> @uitofpto(<vscale x 4 x i32> %val) {
+; CHECK-LABEL: @uitofp
+; CHECK: %r = uitofp <vscale x 4 x i32> %val to <vscale x 4 x float>
+; CHECK-NEXT: ret <vscale x 4 x float> %r
+  %r = uitofp <vscale x 4 x i32> %val to <vscale x 4 x float>
+  ret <vscale x 4 x float> %r
+}
+
+define <vscale x 4 x float> @sitofpto(<vscale x 4 x i32> %val) {
+; CHECK-LABEL: @sitofp
+; CHECK: %r = sitofp <vscale x 4 x i32> %val to <vscale x 4 x float>
+; CHECK-NEXT: ret <vscale x 4 x float> %r
+  %r = sitofp <vscale x 4 x i32> %val to <vscale x 4 x float>
+  ret <vscale x 4 x float> %r
+}
+
+define <vscale x 2 x i64> @ptrtointto(<vscale x 2 x i32*> %val) {
+; CHECK-LABEL: @ptrtointto
+; CHECK: %r = ptrtoint <vscale x 2 x i32*> %val to <vscale x 2 x i64>
+; CHECK-NEXT: ret <vscale x 2 x i64> %r
+  %r = ptrtoint <vscale x 2 x i32*> %val to <vscale x 2 x i64>
+  ret <vscale x 2 x i64> %r
+}
+
+define <vscale x 2 x i32*> @inttoptrto(<vscale x 2 x i64> %val) {
+; CHECK-LABEL: @inttoptrto
+; CHECK: %r = inttoptr <vscale x 2 x i64> %val to <vscale x 2 x i32*>
+; CHECK-NEXT: ret <vscale x 2 x i32*> %r
+  %r = inttoptr <vscale x 2 x i64> %val to <vscale x 2 x i32*>
+  ret <vscale x 2 x i32*> %r
+}
+
+define <vscale x 2 x i64> @bitcastto(<vscale x 2 x double> %a) {
+; CHECK-LABEL: @bitcast
+; CHECK: %r = bitcast <vscale x 2 x double> %a to <vscale x 2 x i64>
+; CHECK-NEXT: ret <vscale x 2 x i64> %r
+  %r = bitcast <vscale x 2 x double> %a to <vscale x 2 x i64>
+  ret <vscale x 2 x i64> %r
+}
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Other Operations
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+define <vscale x 4 x i1> @icmp(<vscale x 4 x i32> %a, <vscale x 4 x i32> %b) {
+; CHECK-LABEL: @icmp
+; CHECK: %r = icmp eq <vscale x 4 x i32> %a, %b
+; CHECK-NEXT: ret <vscale x 4 x i1> %r
+  %r = icmp eq <vscale x 4 x i32> %a, %b
+  ret <vscale x 4 x i1> %r
+}
+
+define <vscale x 4 x i1> @fcmp(<vscale x 4 x float> %a, <vscale x 4 x float> %b) {
+; CHECK-LABEL: @fcmp
+; CHECK: %r = fcmp une <vscale x 4 x float> %a, %b
+; CHECK-NEXT: ret <vscale x 4 x i1> %r
+  %r = fcmp une <vscale x 4 x float> %a, %b
+  ret <vscale x 4 x i1> %r
+}
+
+define <vscale x 16 x i8> @phi(<vscale x 16 x i8> %a, i32 %val) {
+; CHECK-LABEL: @phi
+; CHECK: %r = phi <vscale x 16 x i8> [ %a, %entry ], [ %added, %iszero ]
+; CHECK-NEXT: ret <vscale x 16 x i8> %r
+entry:
+  %cmp = icmp eq i32 %val, 0
+  br i1 %cmp, label %iszero, label %end
+
+iszero:
+  %ins = insertelement <vscale x 16 x i8> undef, i8 1, i32 0
+  %splatone = shufflevector <vscale x 16 x i8> %ins, <vscale x 16 x i8> undef, <vscale x 16 x i32> zeroinitializer
+  %added = add <vscale x 16 x i8> %a, %splatone
+  br label %end
+
+end:
+  %r = phi <vscale x 16 x i8> [ %a, %entry ], [ %added, %iszero ]
+  ret <vscale x 16 x i8> %r
+}
+
+define <vscale x 8 x half> @select(<vscale x 8 x half> %a, <vscale x 8 x half> %b, <vscale x 8 x i1> %sval) {
+; CHECK-LABEL: @select
+; CHECK: %r = select <vscale x 8 x i1> %sval, <vscale x 8 x half> %a, <vscale x 8 x half> %b
+; CHECK-NEXT: ret <vscale x 8 x half> %r
+  %r = select <vscale x 8 x i1> %sval, <vscale x 8 x half> %a, <vscale x 8 x half> %b
+  ret <vscale x 8 x half> %r
+}
+
+declare <vscale x 4 x i32> @callee(<vscale x 4 x i32>)
+define <vscale x 4 x i32> @call(<vscale x 4 x i32> %val) {
+; CHECK-LABEL: @call
+; CHECK: %r = call <vscale x 4 x i32> @callee(<vscale x 4 x i32> %val)
+; CHECK-NEXT: ret <vscale x 4 x i32> %r
+  %r = call <vscale x 4 x i32> @callee(<vscale x 4 x i32> %val)
+  ret <vscale x 4 x i32> %r
+}
 No newline at end of file

llvm/unittests/IR/VectorTypesTest.cpp

 //===--- llvm/unittest/IR/VectorTypesTest.cpp - vector types unit tests ---===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/Support/ScalableSize.h"
 #include "gtest/gtest.h"
 using namespace llvm;
 
 namespace {
 TEST(VectorTypesTest, FixedLength) {
TEST(VectorTypesTest, Scalable) {
   ASSERT_TRUE(ConvTy->isScalable());
   EXPECT_EQ(ConvTy->getNumElements(), 4U);
   EXPECT_EQ(ConvTy->getElementType()->getScalarSizeInBits(), 64U);
 
   EltCnt = ScV8Int64Ty->getElementCount();
   EXPECT_EQ(EltCnt.Min, 8U);
   ASSERT_TRUE(EltCnt.Scalable);
 }
+TEST(VectorTypesTest, FixedLenComparisons) {
+  LLVMContext Ctx;
+  DataLayout DL("");
+
+  Type *Int32Ty = Type::getInt32Ty(Ctx);
+  Type *Int64Ty = Type::getInt64Ty(Ctx);
+
+  VectorType *V2Int32Ty = VectorType::get(Int32Ty, 2);
+  VectorType *V4Int32Ty = VectorType::get(Int32Ty, 4);
+
+  VectorType *V2Int64Ty = VectorType::get(Int64Ty, 2);
+
+  ScalableSize V2I32Len = V2Int32Ty->getScalableSizeInBits();
+  EXPECT_EQ(V2I32Len.getKnownMinSize(), 64U);
+  EXPECT_FALSE(V2I32Len.isScalable());
+
+  EXPECT_LT(V2Int32Ty->getScalableSizeInBits(),
+            V4Int32Ty->getScalableSizeInBits());
+  EXPECT_GT(V2Int64Ty->getScalableSizeInBits(),
+            V2Int32Ty->getScalableSizeInBits());
+  EXPECT_EQ(V4Int32Ty->getScalableSizeInBits(),
+            V2Int64Ty->getScalableSizeInBits());
+  EXPECT_NE(V2Int32Ty->getScalableSizeInBits(),
+            V2Int64Ty->getScalableSizeInBits());
+
+  // Check that a fixed-only comparison works for fixed size vectors.
+  EXPECT_EQ(V2Int64Ty->getFixedSizeInBits(),
+            V4Int32Ty->getFixedSizeInBits());
+
+  // Check the DataLayout interfaces.
+  EXPECT_EQ(DL.getScalableTypeSizeInBits(V2Int64Ty),
+            DL.getScalableTypeSizeInBits(V4Int32Ty));
+  EXPECT_EQ(DL.getKnownMinTypeSizeInBits(V2Int32Ty), 64U);
+  EXPECT_EQ(DL.getTypeSizeInBits(V2Int64Ty), 128U);
+  EXPECT_EQ(DL.getScalableTypeStoreSize(V2Int64Ty),
+            DL.getScalableTypeStoreSize(V4Int32Ty));
+  EXPECT_NE(DL.getScalableTypeStoreSizeInBits(V2Int32Ty),
+            DL.getScalableTypeStoreSizeInBits(V2Int64Ty));
+  EXPECT_EQ(DL.getKnownMinTypeStoreSizeInBits(V2Int32Ty), 64U);
+  EXPECT_EQ(DL.getKnownMinTypeStoreSize(V2Int64Ty), 16U);
+  EXPECT_EQ(DL.getScalableTypeAllocSize(V4Int32Ty),
+            DL.getScalableTypeAllocSize(V2Int64Ty));
+  EXPECT_NE(DL.getScalableTypeAllocSizeInBits(V2Int32Ty),
+            DL.getScalableTypeAllocSizeInBits(V2Int64Ty));
+  EXPECT_EQ(DL.getKnownMinTypeAllocSizeInBits(V4Int32Ty), 128U);
+  EXPECT_EQ(DL.getKnownMinTypeAllocSize(V2Int32Ty), 8U);
+  ASSERT_TRUE(DL.typeSizeEqualsStoreSize(V4Int32Ty));
+}
+
+TEST(VectorTypesTest, ScalableComparisons) {
+  LLVMContext Ctx;
+  DataLayout DL("");
+
+  Type *Int32Ty = Type::getInt32Ty(Ctx);
+  Type *Int64Ty = Type::getInt64Ty(Ctx);
+
+  VectorType *ScV2Int32Ty = VectorType::get(Int32Ty, {2, true});
+  VectorType *ScV4Int32Ty = VectorType::get(Int32Ty, {4, true});
+
+  VectorType *ScV2Int64Ty = VectorType::get(Int64Ty, {2, true});
+
+  ScalableSize ScV2I32Len = ScV2Int32Ty->getScalableSizeInBits();
+  EXPECT_EQ(ScV2I32Len.getKnownMinSize(), 64U);
+  EXPECT_TRUE(ScV2I32Len.isScalable());
+
+  EXPECT_LT(ScV2Int32Ty->getScalableSizeInBits(),
+            ScV4Int32Ty->getScalableSizeInBits());
+  EXPECT_GT(ScV2Int64Ty->getScalableSizeInBits(),
+            ScV2Int32Ty->getScalableSizeInBits());
+  EXPECT_EQ(ScV4Int32Ty->getScalableSizeInBits(),
+            ScV2Int64Ty->getScalableSizeInBits());
+  EXPECT_NE(ScV2Int32Ty->getScalableSizeInBits(),
+            ScV2Int64Ty->getScalableSizeInBits());
+
+  // Check the DataLayout interfaces.
+  EXPECT_EQ(DL.getScalableTypeSizeInBits(ScV2Int64Ty),
+            DL.getScalableTypeSizeInBits(ScV4Int32Ty));
+  EXPECT_EQ(DL.getKnownMinTypeSizeInBits(ScV2Int32Ty), 64U);
+  EXPECT_EQ(DL.getScalableTypeStoreSize(ScV2Int64Ty),
+            DL.getScalableTypeStoreSize(ScV4Int32Ty));
+  EXPECT_NE(DL.getScalableTypeStoreSizeInBits(ScV2Int32Ty),
+            DL.getScalableTypeStoreSizeInBits(ScV2Int64Ty));
+  EXPECT_EQ(DL.getKnownMinTypeStoreSizeInBits(ScV2Int32Ty), 64U);
+  EXPECT_EQ(DL.getKnownMinTypeStoreSize(ScV2Int64Ty), 16U);
+  EXPECT_EQ(DL.getScalableTypeAllocSize(ScV4Int32Ty),
+            DL.getScalableTypeAllocSize(ScV2Int64Ty));
+  EXPECT_NE(DL.getScalableTypeAllocSizeInBits(ScV2Int32Ty),
+            DL.getScalableTypeAllocSizeInBits(ScV2Int64Ty));
+  EXPECT_EQ(DL.getKnownMinTypeAllocSizeInBits(ScV4Int32Ty), 128U);
+  EXPECT_EQ(DL.getKnownMinTypeAllocSize(ScV2Int32Ty), 8U);
+  ASSERT_TRUE(DL.typeSizeEqualsStoreSize(ScV4Int32Ty));
+}
+
+TEST(VectorTypesTest, CrossComparisons) {
+  LLVMContext Ctx;
+
+  Type *Int32Ty = Type::getInt32Ty(Ctx);
+
+  VectorType *V4Int32Ty = VectorType::get(Int32Ty, {4, false});
+  VectorType *ScV4Int32Ty = VectorType::get(Int32Ty, {4, true});
+
+  // Even though the minimum size is the same, a scalable vector could be
+  // larger so we don't consider them to be the same size.
+  EXPECT_NE(V4Int32Ty->getScalableSizeInBits(),
+            ScV4Int32Ty->getScalableSizeInBits());
+  // If we are only checking the minimum, then they are the same size.
+  EXPECT_EQ(V4Int32Ty->getKnownMinSizeInBits(),
+            ScV4Int32Ty->getKnownMinSizeInBits());
+
+  // We can't use ordering comparisons (<,<=,>,>=) between scalable and
+  // non-scalable vector sizes.
+}
 
 } // end anonymous namespace