[Clang] Allow "vector_size" applied to Booleans

[simoll]

Summary

This is the vector_size alternative to D88905.

This patch extends Clang to allow 'bool' as a valid vector element type (attribute vector_size).

This is intended as the canonical type for SIMD masks and facilitates clean vector intrinsic declarations.
Vectors of i1 are supported on IR level and below down to many SIMD ISAs, such as AVX512, ARM SVE (fixed vector length) and the VE target (NEC SX-Aurora TSUBASA).

The RFC on cfe-dev: https://lists.llvm.org/pipermail/cfe-dev/2020-May/065434.html

[simoll]

NFC. Undid stray change.

[simoll]

clang/lib/CodeGen/CGExprScalar.cpp

4648

Accidental change. Will undo.

clang/lib/CodeGen/CGRecordLayoutBuilder.cpp

590 ↗

(On Diff #268140)

This is an old comment that is no longer helpful. Will remove.

[lenary]

clang/docs/LanguageExtensions.rst

473

It would be nice if this aside about non-bool vectors was more prominently displayed - it's something I hadn't realised before.

[simoll]

clang/docs/LanguageExtensions.rst

473

Yep. that caught me by surprise too. I'll move that sentence to the paragraph about GCC vectors above.

[simoll]

• Improved documentation for the size argument of vector_size.
• Rebased

[simoll]

• Rebased
• Implement EmitFromMemory

[simoll]

Updated clang test

[simoll]

NFC

• Style updates
• Rebased

[kaz7]

Thank you for implementing EmitFromMemory. We are locally trying to use this patch to implement vector mask intrinsic instructions on Aurora VE. It is working well with regression tests. We will try test-suite next.

[rsandifo-arm]

clang/docs/LanguageExtensions.rst

473

Sorry for the extremely late comment. Like @lenary I hadn't thought about this. I'd assumed that the vector woiuld still be a multiple of 8 bits in size, but I agree that's probably too restrictive to be the only option available.

In that case, would it make sense to add a separate attribute instead? I think it's too surprising to change the units of the existing attribute based on the element type. Perhaps we should even make it take two parameters: the total number of elements, and the number of bits per element. That might be more natural for some AVX and SVE combinations. We wouldn't need to supporrt all combinations from the outset, it's just a question whether we should make the syntax general enough to support it in future.

Perhaps we could do both: support vector_size for bool using byte sizes (and not allowing subbyte vector lengths), and add a new, more general attribute that allows subbyte lengths and explicit subbyte element sizes.

[simoll]

clang/docs/LanguageExtensions.rst

473

In that case, would it make sense to add a separate attribute instead? I think it's too surprising to change the units of the existing attribute based on the element type. Perhaps we should even make it take two parameters: the total number of elements, and the number of bits per element. That might be more natural for some AVX and SVE combinations. We wouldn't need to supporrt all combinations from the outset, it's just a question whether we should make the syntax general enough to support it in future.

I guess adding a new attribute makes sense mid to long term. For now, i'd want something that just does the job... ie, what is proposed here. We should absolutely document the semantics of vector_size properly.. it already is counterintuitive (broken, if you ask me).

Perhaps we could do both: support vector_size for bool using byte sizes (and not allowing subbyte vector lengths), and add a new, more general attribute that allows subbyte lengths and explicit subbyte element sizes.

Disallowing subbyte bool vectors actually makes this more complicated because these types are produced implicitly by compares of (legal) vector types. Consider this:

typedef int int3 __attribute__((vector_size(3 * sizeof(int))));
int3 A = ...;
int3 B = ...;
auto Z = A < B; // vector compare yielding a `bool vector_size(3)`-typed value.

Regarding your proposal for a separate subbyte element size and subbyte length, that may or may not make sense but it is surely something that should be discussed more broadly with its own proposal.

[rsandifo-arm]

clang/docs/LanguageExtensions.rst

473

Perhaps we could do both: support vector_size for bool using byte sizes (and not allowing subbyte vector lengths), and add a new, more general attribute that allows subbyte lengths and explicit subbyte element sizes.

Disallowing subbyte bool vectors actually makes this more complicated because these types are produced implicitly by compares of (legal) vector types. Consider this:

typedef int int3 __attribute__((vector_size(3 * sizeof(int))));
int3 A = ...;
int3 B = ...;
auto Z = A < B; // vector compare yielding a `bool vector_size(3)`-typed value.

Yeah, I understand the need for some way of creating subbyte vectors. I'm just not sure using the existing vector_size attribute would be the best choice for that case. I.e. the objection wasn't based on “keeping things simple” but more “keeping things consistent“.

That doesn't mean that the above code should be invalid. It just means that it wouldn't be possible to write the type of Z using the existing vector_size attribute.

(FWIW, vector_size was originally a GNUism and GCC stil requires vector sizes to be a power of 2, but I realise that isn't relevant here. And the same principle applies with s/3/4 in the above example anyway.)

Regarding your proposal for a separate subbyte element size and subbyte length, that may or may not make sense but it is surely something that should be discussed more broadly with its own proposal.

Yeah, I agree any new attribute would need to be discussed more widely.

[simoll]

clang/docs/LanguageExtensions.rst

473

Perhaps we could do both: support vector_size for bool using byte sizes (and not allowing subbyte vector lengths), and add a new, more general attribute that allows subbyte lengths and explicit subbyte element sizes.

Disallowing subbyte bool vectors actually makes this more complicated because these types are produced implicitly by compares of (legal) vector types. Consider this:

typedef int int3 __attribute__((vector_size(3 * sizeof(int))));
int3 A = ...;
int3 B = ...;
auto Z = A < B; // vector compare yielding a `bool vector_size(3)`-typed value.

Yeah, I understand the need for some way of creating subbyte vectors. I'm just not sure using the existing vector_size attribute would be the best choice for that case. I.e. the objection wasn't based on “keeping things simple” but more “keeping things consistent“.

That doesn't mean that the above code should be invalid. It just means that it wouldn't be possible to write the type of Z using the existing vector_size attribute.

IMHO being able to spell out every type ranks higher than being consistent with regards to a non-standard extension. That is, you could not do the assignment of A < B in C because there is no way to specify the type without auto or other C++ machinery.

(FWIW, vector_size was originally a GNUism and GCC stil requires vector sizes to be a power of 2, but I realise that isn't relevant here. And the same principle applies with s/3/4 in the above example anyway.)

Right, i overlooked the power-of-two constraint.

How much of a blocker are the subbyte sizes and the power-of-two constraint to you? I am asking because vector_size with those constraints would be good enough for us. Keeping the patch as it is mostly makes this extension potentially more useful to other SIMD/Vector users (and of course saves the work of changing it).
We could still lift that constraint (or switch to a new attribute) should the need arise.

[rsandifo-arm]

clang/docs/LanguageExtensions.rst

473

How much of a blocker are the subbyte sizes and the power-of-two constraint to you? I am asking because vector_size with those constraints would be good enough for us. Keeping the patch as it is mostly makes this extension potentially more useful to other SIMD/Vector users (and of course saves the work of changing it).
We could still lift that constraint (or switch to a new attribute) should the need arise.

The non-power-of-2 thing seems fine. It's simply removing a constraint and giving non-power-of-2 sizes their obvious meaning.

But I think changing the units in the vector_size is too surprising. I think a good indication is that we'd never have designed it like that if we were adding vector_size now. I think it's something that would often trip users up and that we'd have to keep explaining away.

It's just a personal opinion though.

[simoll]

clang/docs/LanguageExtensions.rst

473

But I think changing the units in the vector_size is too surprising. I think a good indication is that we'd never have designed it like that if we were adding vector_size now. I think it's something that would often trip users up and that we'd have to keep explaining away.

Ok. To make sure we are talking about the same thing here, you are suggesting:

typedef bool bool16 __attribute__((vector_size(2)));

Would be a vector of 16 bits stored in two bytes. Correct? If so, that's fine with me and i'll change the patch right away.

[rsandifo-arm]

clang/docs/LanguageExtensions.rst

473

But I think changing the units in the vector_size is too surprising. I think a good indication is that we'd never have designed it like that if we were adding vector_size now. I think it's something that would often trip users up and that we'd have to keep explaining away.

Ok. To make sure we are talking about the same thing here, you are suggesting:

typedef bool bool16 __attribute__((vector_size(2)));

Would be a vector of 16 bits stored in two bytes. Correct?

Yeah. And if anyone wants something like a vector of 4 bools in a 4-bit vector (which would certainly be reasonable in principle), we could leave that to some future, more general attribute syntax that doesn't have the same historical baggage as vector_size.

[simoll]

Thanks for the feedback!
Planned change: interpret the N in vector_size(N) as the number of bytes in the type, such that, for example, a vector_size(2) bool vector holds 16 bits

[simoll]

• Fixed debug info representation for bool vectors (and added debug info test).
• Interpret 8*N with the N of vector_size(N) as the numbers of bool elements of the vector.

[simoll]

NFC. Cleanup.

[simoll]

• Fixed type printing & added type printing test.
• Rebased.

[kaz7]

Thank you preparing this i1 patch and doing it on clang side only. We were testing this patch and sending problem reports. Now, we can use this patch without modifying llvm code. We can define vector mask types like below. Then, we can define intrinsic functions using this type. Those are converted to mask type, e.g v256i1, in the back end without adding bitcasts in ISelLowering.cpp. It helps developers very much. I hope this extension is accepted.

typedef double __vr __attribute__((__vector_size__(2048)));
#if __STDC_VERSION__ >= 199901L
// For C99
typedef _Bool __vm    __attribute__((__vector_size__(32)));
typedef _Bool __vm256 __attribute__((__vector_size__(32)));
typedef _Bool __vm512 __attribute__((__vector_size__(64)));
#else
#ifdef __cplusplus
// For C++
typedef bool __vm    __attribute__((__vector_size__(32)));
typedef bool __vm256 __attribute__((__vector_size__(32)));
typedef bool __vm512 __attribute__((__vector_size__(64)));
#else
#error need C++ or C99 to use vector intrinsics for VE
#endif
#endif

[rsandifo-arm]

I'm not qualified to review the CodeGen stuff (or accept the patch, obvs. :-)) but FWIW, here are some comments on the doc and Sema side.

It might be good to have more Sema tests for valid and invalid usage, e.g. for which operators are valid and which aren't.

Thanks again for doing this btw.

clang/docs/LanguageExtensions.rst

459

Maybe “Unlike GCC,”? Not much in it though.

489

~ is listed twice. I guess “operators” (without qualification) might make people think of the C++ keyword, in which case assignment and [] are allowed too.

492

It might be worth clarifying this. With the alignment referring specifically to “integer type”, I wasn't sure what something like:

bool __attribute__((vector_size(256)))

would mean on targets that don't provide 256-byte integer types. Is the type still 256-byte aligned?

clang/include/clang/AST/Type.h

3259

Maybe isGenericBooleanVector(), so that the terminology is consistent? Just a suggestion though, not sure if it's an improvement.

clang/lib/Sema/SemaExpr.cpp

9801

Is this deliberately wider than isVectorSizeBoolean(), or does it amount to the same thing?

11983

In practice, won't this either be a no-op (e.g. for 4-byte-per-bool targets) or always trump the fallback CharTy case? I wasn't sure why the case was needed.

12007

Seems like it might be useful to support comparisons too (with false < true, as for scalars). E.g. I guess x == y would otherwise need to be written ~(x ^ y), which seems less readable. Supporting more operators would also help in templated contexts.

clang/lib/Sema/SemaExprCXX.cpp

6288

Any reason not to support this for booleans? ?: seems like a natural operation for all vector element types.

[simoll]

clang/docs/LanguageExtensions.rst

492

Not exactly: It is the alignment of the corresponding integer type.
For example the following C code:

typedef bool bool256 __attribute__((vector_size(256)));
bool256 P;

gives you (x86_64 host, no machine flags specified):

%P = alloca i2048, align 32

clang/include/clang/AST/Type.h

3259

I gave it this specific name so where ever it is used, it documents that whatever depends on it is specific to vector_size bool. This should be cleaned up when a better boolean vector type is introduced.

clang/lib/Sema/SemaExpr.cpp

9801

That's an artifact. Will narrow this down to isVectorSizeBoolean().

11983

I guess so. Will remove this case.

12007

Agreed.

clang/lib/Sema/SemaExprCXX.cpp

6288

Sure, will allow it.

[rsandifo-arm]

clang/docs/LanguageExtensions.rst

492

I guess my point is pedantic, but what I meant was: does the concept of “the corresponding integer type” necessarily exist at the C/C++ level? E.g. how would you end up with the same LLVM IR statement using C integer types instead of vectors?

My worry was that “the alignment of the corresponding integer type” would only be meaningful to the user if they could identify what the corresponding (C) integer type actually was, and be able to determine its alignment that way.

[simoll]

clang/docs/LanguageExtensions.rst

492

To be honest, i hadn't given alignment much thought before. Actually, i am not too happy about bringing in integer types here.

I guess it's sensible to do no different than for the other vector types: take the size rounded up to the next power-ot-two capped by the target's maximum vector alignment.

[simoll]

• Rebased.
• Allow comparisons on boolean vectors.
• Restored result type for vector comparisons on other types.
• Added operator, alignment and constexpr tests.

[simoll]

In D81083#2227760, @rsandifo-arm wrote:

I'm not qualified to review the CodeGen stuff (or accept the patch, obvs. :-)) but FWIW, here are some comments on the doc and Sema side.

Thanks for your comments! Maybe you know people who could review the CodeGen side of this..?

[simoll]

The Hexagon builtins explicitly require bool vectors to have 8-bit wide bool elements. That clashes with our new vector type because bool vectors in builtin functions and vector_size bool vectors have the same internal representation in Clang. However, AFAIK Hexagon is the only target that actually need 8-bit bools. I see two possible ways out of this:

1. Introduce a Bit type in Clang that is only constructible as a vector element type. This way, any existing users of generic bool vectors are undisturbed. VE can use Bit in its builtin declarations to match the vector_size bool type. We may re-purpose the Bit type for a proper boolean vector type in the future.
2. Add a new target property: BoolInVectorSize that is the size of a bool element in boolean vectors. Hexagon, as most targets, would define BoolInVectorSize = BoolSize. VE would define BoolInVectorSize = 1 for the intended behavior.

My preference is for 2. since it means small changes to the current patch and less surprises than the other option. Opinions?

[simoll]

• made bool-vector layout target dependent (one byte per bool element on Hexagon, one bit everywhere else).
• Added hvx-specific debug info test.
• Updated docs.

[simoll]

NFC. Make clang-tidy happy.

[rsmith]

Have you considered using the ext_vector_type attribute instead of vector_size for this? That would have a couple of advantages:

• It's not a GCC attribute, so there's no risk that GCC would give different meaning to the same syntax (such as using one byte per vector element, which would be the natural meaning for a vector of bool as an extension of existing functionality).
• ext_vector_type takes as an argument a number of elements, not a size in bytes, so you could support vectors of non-multiple-of-8 bools.

However, using either an ext_vector_type of bool or a vector_size of bool would still seem problematic in a couple of other ways:

• Those types always produce a vector whose element type is the specified type; you can form an lvalue denoting the element, the element is always represented the same as the underlying type, and you can pun between a vector of N T and an array of N T. GCC even permits forming a pointer or reference to a vector element, and you should assume that Clang will eventually support that too. That would not be possible for bool if packed as a bit-vector.
• You can already perform logical operations between our existing vector types -- for example, comparing two vectors of 4 ints. If vectors of bool are valid, it would be logical and natural to expect a vector of 4 bools to have some connection to the result of such a comparison, but it won't: the type of a comparison of two vectors of 4 ints is a vector of 4 ints each of which is either 0 or -1, and we can't convert that to a vector of 4 bools represented as our existing vector types, because such conversions would be interpreted as bitcasts, and we'd reject because the bitwidth of the vectors is different.
• Vectors of integer types (such as bool) generally support arithmetic operators, which you presumably do not want to support here.
• Our existing vector types carry a lot of baggage (for example, lax vector conversions, and the egregious attribute-on-typedef-changes-the-type hack) that we would not want a new type to include.

So I think you should seriously consider using a new syntax to form a bit-vector type. It seems to me that an N-bit bit-vector is quite similar to an _ExtInt(N), but without the arithmetic support and with a different expected IR type. Maybe following that syntactic path and adding _BitVector(N) syntax would work out better?

[simoll]

In D81083#2237284, @rsmith wrote:

Thanks for dropping by!

Have you considered using the ext_vector_type attribute instead of vector_size for this? That would have a couple of advantages:

• It's not a GCC attribute, so there's no risk that GCC would give different meaning to the same syntax (such as using one byte per vector element, which would be the natural meaning for a vector of bool as an extension of existing functionality).
• ext_vector_type takes as an argument a number of elements, not a size in bytes, so you could support vectors of non-multiple-of-8 bools.

Whichever solution is going to land in Clang, we will end up in the situation that Clang supports bool vectors and GCC does not. Any code that uses this feature and is supposed to compile with GCC will need some #ifdef guard. This is why i am not too worried about (ab-)using the vector_size attribute for this.

However, using either an ext_vector_type of bool or a vector_size of bool would still seem problematic in a couple of other ways:

• Those types always produce a vector whose element type is the specified type; you can form an lvalue denoting the element, the element is always represented the same as the underlying type, and you can pun between a vector of N T and an array of N T. GCC even permits forming a pointer or reference to a vector element, and you should assume that Clang will eventually support that too. That would not be possible for bool if packed as a bit-vector.
• You can already perform logical operations between our existing vector types -- for example, comparing two vectors of 4 ints. If vectors of bool are valid, it would be logical and natural to expect a vector of 4 bools to have some connection to the result of such a comparison, but it won't: the type of a comparison of two vectors of 4 ints is a vector of 4 ints each of which is either 0 or -1, and we can't convert that to a vector of 4 bools represented as our existing vector types, because such conversions would be interpreted as bitcasts, and we'd reject because the bitwidth of the vectors is different.
• Vectors of integer types (such as bool) generally support arithmetic operators, which you presumably do not want to support here.
• Our existing vector types carry a lot of baggage (for example, lax vector conversions, and the egregious attribute-on-typedef-changes-the-type hack) that we would not want a new type to include.

I agree that the vector_size syntax for bool vectors raises some expectations on the behavior of the bool vector. However, i see this more as an issue of proper documentation. The moment somebody uses vector_size attributes they know they are deep in compiler-extension land and far from standard C/C++ semantics.
Now about the vector representation issues in Clang and how we could make this work for bool vectors: earlier, i suggested that we could introduce a Clang-internal Bit datatype that can only be used as a vector element type. By doing so, we wouldn't violate the invariant that bits(vector) == size_of_vector * bits(element_type).

So I think you should seriously consider using a new syntax to form a bit-vector type. It seems to me that an N-bit bit-vector is quite similar to an _ExtInt(N), but without the arithmetic support and with a different expected IR type. Maybe following that syntactic path and adding _BitVector(N) syntax would work out better?

I am open to a different syntax, if piggy backing on the vector_size syntax is the main point of contention. Up to now, the plan was to have vector_size bool now and work on a proper bool vector type to replace it.

[simoll]

Rebased

[simoll]

I'd like to hear your feedback on how to proceed with this patch.

Here is what i would do:

For this patch, we switch to ext_vector_type for bool vectors to not clash head on with GCC should GCC decide to allow vector_size bool with a different semantics in the future.
For the future, we propose a _BitVector(N) extension possibly aiming for a C/C++ TS. We can build on our experience with the ext_vector_type bool for this.

[simoll]

This comment was removed by simoll.

[simoll]

(wrong Diff attached in earlier update)

• rebased

[simoll]

D88905 uses ext_vector_type instead of vector_size following up on @rsmith 's suggestion. The review should continue there.

I'll keep D81083 around for reference.

[simoll]

Taking this off the review queues - we will use the ext_vector_type attribute instead (D88905).

clang/docs/LanguageExtensions.rst

.. code-block:: c++
   typedef __attribute__((neon_polyvector_type(16))) poly8_t poly8x16_t;
 
   int8x8_t foo(int8x8_t a) {
     int8x8_t v;
     v = a;
     return v;
   }
 
+GCC vector types are created using the ``vector_size(N)`` attribute.  The
+argument ``N`` specifies the number of bytes that will be allocated for an
+object of this type.  The size has to be multiple of the size of the vector
+element type. For example:
+
+.. code-block:: c++
+
+  // OK: This declares a vector type with four 'int' elements
+  typedef int int4 __attribute__((vector_size(4 * sizeof(int))));
+
+  // ERROR: '11' is not a multiple of sizeof(int)
+  typedef int int_impossible __attribute__((vector_size(11)));
+
+  int4 foo(int4 a) {
+    int4 v;
+    v = a;
+    return v;
+  }
+
+
+Boolean Vectors
+---------------
+
+Unlike GCC, Clang also allows the attribute to be used with boolean
+element types. For example:
+
+.. code-block:: c++
+
+  // legal for Clang, error for GCC:
+  typedef bool bool8 __attribute__((vector_size(1)));
+  // Objects of bool8 type hold 8 bits, sizeof(bool8) == 1
+
+  typedef bool bool32 __attribute__((vector_size(4)));
+  // Objects of bool32 type hold 32 bits, sizeof(bool32) == 4
+
+  bool8 foo(bool8 a) {
+    bool8 v;
+    v = a;
+    return v;
+  }
+
+Boolean vectors are a Clang extension of the GCC vector type.  Boolean vectors
+are intended, though not guaranteed, to map to vector mask registers.  The size
+parameter of a boolean vector type is the number of bytes in the vector.  The
+number of elements in a boolean vector of a given size depends on the target.
+For most targets, the boolean vector is dense and each bit in the boolean
+vector is one vector element.  However, some targets (eg Hexagon hvx64), use
+one byte per boolean element.
+
+The semantics of boolean vectors differs from the GCC vector of integer or
+floating point type.  This is mostly because bits are smaller than the smallest
+addressable unit in memory on most architectures.  The semantics of boolean
+vectors borrows from C bit-fields with the following differences:
+
+* Distinct boolean vectors are always distinct memory objects (there is no
+  packing).
+* Only the operators `!`, `~`, `|`, `&`, `^` and comparison are allowed on
+  boolean vectors.
+
+The memory representation of a dense boolean vector is the smallest fitting
+integer.  The alignment is the number of bits rounded up to the next
+power-of-two but at most the maximum vector alignment of the target.  This
+permits the use of boolean vectors whose element count is a power of two in
+allocated arrays using the common ``sizeof(Array)/sizeof(ElementType)``
+pattern.
+
+
 Vector Literals
 ---------------
 
 Vector literals can be used to create vectors from a set of scalars, or
 vectors.  Either parentheses or braces form can be used.  In the parentheses
 form the number of literal values specified must be one, i.e. referring to a
 scalar value, or must match the size of the vector type being created.  If a
 single scalar literal value is specified, the scalar literal value will be

 ==, !=, >, <, >=, <=             yes     yes       yes         --
 =                                yes     yes       yes         yes
 ?: [#]_                          yes     --        yes         --
 sizeof                           yes     yes       yes         yes
 C-style cast                     yes     yes       yes         no
 reinterpret_cast                 yes     no        yes         no
 static_cast                      yes     no        yes         no
 const_cast                       no      no        no          no
+address &v[i]                    no      no        no [#]_     no
 ============================== ======= ======= ============= =======
 
 See also :ref:`langext-__builtin_shufflevector`, :ref:`langext-__builtin_convertvector`.
 
 .. [#] ternary operator(?:) has different behaviors depending on condition
   operand's vector type. If the condition is a GNU vector (i.e. __vector_size__),
   it's only available in C++ and uses normal bool conversions (that is, != 0).
   If it's an extension (OpenCL) vector, it's only available in C and OpenCL C.
   And it selects base on signedness of the condition operands (OpenCL v1.1 s6.3.9).
+.. [#] Clang does not allow the address of an element to be taken while GCC
+   allows this. This is intentional for vectors with a boolean element type and
+   not implemented otherwise.
 
 Matrix Types
 ============
 
 Clang provides an extension for matrix types, which is currently being
 implemented. See :ref:`the draft specification <matrixtypes>` for more details.
 
 For example, the code below uses the matrix types extension to multiply two 4x4

clang/include/clang/AST/Type.h

public:
 
   bool isSugared() const { return false; }
   QualType desugar() const { return QualType(this, 0); }
 
   VectorKind getVectorKind() const {
     return VectorKind(VectorTypeBits.VecKind);
   }
 
+  bool isVectorSizeBoolean() const {
+    return (getVectorKind() == VectorKind::GenericVector) &&
+           getElementType()->isBooleanType();
+  }
+
   void Profile(llvm::FoldingSetNodeID &ID) {
     Profile(ID, getElementType(), getNumElements(),
             getTypeClass(), getVectorKind());
   }
 
   static void Profile(llvm::FoldingSetNodeID &ID, QualType ElementType,
                       unsigned NumElements, TypeClass TypeClass,
                       VectorKind VecKind) {

clang/include/clang/Basic/TargetInfo.h

struct TransferrableTargetInfo {
   // Fixed point bit widths
   unsigned char ShortAccumWidth, ShortAccumAlign;
   unsigned char AccumWidth, AccumAlign;
   unsigned char LongAccumWidth, LongAccumAlign;
   unsigned char ShortFractWidth, ShortFractAlign;
   unsigned char FractWidth, FractAlign;
   unsigned char LongFractWidth, LongFractAlign;
 
+  // Whether the elements of a boolean vector are bits.
+  bool DenseBoolVector;
+
   // If true, unsigned fixed point types have the same number of fractional bits
   // as their signed counterparts, forcing the unsigned types to have one extra
   // bit of padding. Otherwise, unsigned fixed point types have
   // one more fractional bit than its corresponding signed type. This is false
   // by default.
   bool PaddingOnUnsignedFixedPoint;
 
   // Fixed point integral and fractional bit sizes
public:
 
   /// Get integer value for null pointer.
   /// \param AddrSpace address space of pointee in source language.
   virtual uint64_t getNullPointerValue(LangAS AddrSpace) const { return 0; }
 
   /// Return the size of '_Bool' and C++ 'bool' for this target, in bits.
   unsigned getBoolWidth() const { return BoolWidth; }
 
+  /// Return whether the size of an element of a bool vector is just one bit.
+  bool hasDenseBoolVectors() const { return DenseBoolVector; }
+
   /// Return the alignment of '_Bool' and C++ 'bool' for this target.
   unsigned getBoolAlign() const { return BoolAlign; }
 
   unsigned getCharWidth() const { return 8; } // FIXME
   unsigned getCharAlign() const { return 8; } // FIXME
 
   /// Return the size of 'signed short' and 'unsigned short' for this
   /// target, in bits.

clang/include/clang/Sema/Sema.h

 
   void DiagnoseAlwaysNonNullPointer(Expr *E,
                                     Expr::NullPointerConstantKind NullType,
                                     bool IsEqual, SourceRange Range);
 
   /// type checking for vector binary operators.
   QualType CheckVectorOperands(ExprResult &LHS, ExprResult &RHS,
                                SourceLocation Loc, bool IsCompAssign,
-                               bool AllowBothBool, bool AllowBoolConversion);
+                               bool AllowBothBool, bool AllowBoolConversion,
+                               bool AllowBoolOperation, bool ReportInvalid);
   QualType GetSignedVectorType(QualType V);
   QualType CheckVectorCompareOperands(ExprResult &LHS, ExprResult &RHS,
                                       SourceLocation Loc,
                                       BinaryOperatorKind Opc);
   QualType CheckVectorLogicalOperands(ExprResult &LHS, ExprResult &RHS,
                                       SourceLocation Loc);
 
   /// Type checking for matrix binary operators.

clang/lib/AST/ASTContext.cpp

if (!getTargetInfo().getCXXABI().isMicrosoft() ||
       Width = llvm::alignTo(Width, Align);
     break;
   }
 
   case Type::ExtVector:
   case Type::Vector: {
     const auto *VT = cast<VectorType>(T);
     TypeInfo EltInfo = getTypeInfo(VT->getElementType());
-    Width = EltInfo.Width * VT->getNumElements();
+    Width = (Target->hasDenseBoolVectors() && VT->isVectorSizeBoolean())
+                ? VT->getNumElements()
+                : EltInfo.Width * VT->getNumElements();
     Align = Width;
     // If the alignment is not a power of 2, round up to the next power of 2.
     // This happens for non-power-of-2 length vectors.
     if (Align & (Align-1)) {
       Align = llvm::NextPowerOf2(Align);
       Width = llvm::alignTo(Width, Align);
     }
     // Adjust the alignment based on the target max.

clang/lib/AST/TypePrinter.cpp

case VectorType::NeonVector:
     printBefore(T->getElementType(), OS);
     break;
   case VectorType::NeonPolyVector:
     OS << "__attribute__((neon_polyvector_type(" <<
           T->getNumElements() << "))) ";
     printBefore(T->getElementType(), OS);
     break;
   case VectorType::GenericVector: {
+    auto NumVectorElems = T->getNumElements();
     // FIXME: We prefer to print the size directly here, but have no way
     // to get the size of the type.
-    OS << "__attribute__((__vector_size__("
-       << T->getNumElements()
-       << " * sizeof(";
+    // FIXME: Only the target knows whether the elements of 'Bool' vectors occpy
+    // one bit or sizeof(char).
+    OS << "__attribute__((__vector_size__(" << NumVectorElems;
+    if (!T->isVectorSizeBoolean()) {
+      OS << " * sizeof(";
       print(T->getElementType(), OS, StringRef());
-    OS << ")))) ";
+      OS << ")";
+    }
+    OS << "))) ";
     printBefore(T->getElementType(), OS);
     break;
   }
   case VectorType::SveFixedLengthDataVector:
   case VectorType::SveFixedLengthPredicateVector:
     // FIXME: We prefer to print the size directly here, but have no way
     // to get the size of the type.
     OS << "__attribute__((__arm_sve_vector_bits__(";

clang/lib/Basic/TargetInfo.cpp

TargetInfo::TargetInfo(const llvm::Triple &T) : TargetOpts(), Triple(T) {
   // Fixed point default bit widths
   ShortAccumWidth = ShortAccumAlign = 16;
   AccumWidth = AccumAlign = 32;
   LongAccumWidth = LongAccumAlign = 64;
   ShortFractWidth = ShortFractAlign = 8;
   FractWidth = FractAlign = 16;
   LongFractWidth = LongFractAlign = 32;
 
+  // By default, each element of a boolean vector occpies one bit. Target that
+  // represent boolean elements as bytes may want to disable this.
+  DenseBoolVector = true;
+
   // Fixed point default integral and fractional bit sizes
   // We give the _Accum 1 fewer fractional bits than their corresponding _Fract
   // types by default to have the same number of fractional bits between _Accum
   // and _Fract types.
   PaddingOnUnsignedFixedPoint = false;
   ShortAccumScale = 7;
   AccumScale = 15;
   LongAccumScale = 31;

clang/lib/Basic/Targets/Hexagon.h

HexagonTargetInfo(const llvm::Triple &Triple, const TargetOptions &)
     ZeroLengthBitfieldBoundary = 32;
     MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
 
     // These are the default values anyway, but explicitly make sure
     // that the size of the boolean type is 8 bits. Bool vectors are used
     // for modeling predicate registers in HVX, and the bool -> byte
     // correspondence matches the HVX architecture.
     BoolWidth = BoolAlign = 8;
+    // Make sure that the bool elements of bool vectors have the same size as
+    // the plain boolean type.
+    DenseBoolVector = false;
   }
 
   ArrayRef<Builtin::Info> getTargetBuiltins() const override;
 
   bool validateAsmConstraint(const char *&Name,
                              TargetInfo::ConstraintInfo &Info) const override {
     switch (*Name) {
     case 'v':

clang/lib/CodeGen/CGDebugInfo.cpp

llvm::DIType *CGDebugInfo::CreateTypeDefinition(const ObjCInterfaceType *Ty,
   DBuilder.replaceArrays(RealDecl, Elements);
 
   LexicalBlockStack.pop_back();
   return RealDecl;
 }
 
 llvm::DIType *CGDebugInfo::CreateType(const VectorType *Ty,
                                       llvm::DIFile *Unit) {
+  if (CGM.getTarget().hasDenseBoolVectors() && Ty->isVectorSizeBoolean()) {
+    // vector_size(N) are special because their real element type (bits of bit
+    // size) is not their Clang element type (_Bool of size byte). For now, we
+    // pretend the boolean vector were actually a vector of bytes (where each
+    // byte represents 8 bits of the actual vector).
+    // FIXME Debug info should actually represent this proper as a vector mask
+    // type.
+    auto &Ctx = CGM.getContext();
+    uint64_t Size = CGM.getContext().getTypeSize(Ty);
+    uint64_t NumVectorBytes = Size / Ctx.getCharWidth();
+
+    // construct the vector of 'unsigned char' type
+    QualType CharVecTy = Ctx.getVectorType(Ctx.CharTy, NumVectorBytes,
+                                           VectorType::GenericVector);
+    return CreateType(CharVecTy->getAs<VectorType>(), Unit);
+  }
+
   llvm::DIType *ElementTy = getOrCreateType(Ty->getElementType(), Unit);
   int64_t Count = Ty->getNumElements();
 
   llvm::Metadata *Subscript;
   QualType QTy(Ty, 0);
   auto SizeExpr = SizeExprCache.find(QTy);
   if (SizeExpr != SizeExprCache.end())
     Subscript = DBuilder.getOrCreateSubrange(

clang/lib/CodeGen/CGExpr.cpp

 }
 
 llvm::Value *CodeGenFunction::EmitLoadOfScalar(Address Addr, bool Volatile,
                                                QualType Ty,
                                                SourceLocation Loc,
                                                LValueBaseInfo BaseInfo,
                                                TBAAAccessInfo TBAAInfo,
                                                bool isNontemporal) {
-  if (!CGM.getCodeGenOpts().PreserveVec3Type) {
-    // For better performance, handle vector loads differently.
-    if (Ty->isVectorType()) {
-      const llvm::Type *EltTy = Addr.getElementType();
+  const auto *ClangVecTy = Ty->getAs<VectorType>();
+  if (ClangVecTy) {
+    // Boolean vectors use `iN` as storage type
+    if (Target.hasDenseBoolVectors() && ClangVecTy->isVectorSizeBoolean()) {
+      llvm::Type *ValTy = ConvertType(Ty);
+      unsigned ValNumElems =
+          cast<llvm::FixedVectorType>(ValTy)->getNumElements();
+      // Load the `iP` storage object (P is the padded vector size).
+      auto *RawIntV = Builder.CreateLoad(Addr, Volatile, "load_bits");
+      const auto *RawIntTy = RawIntV->getType();
+      assert(RawIntTy->isIntegerTy() && "compressed iN storage for bitvectors");
+      // Bitcast iP --> <P x i1>
+      auto *PaddedVecTy = llvm::FixedVectorType::get(
+          Builder.getInt1Ty(), RawIntTy->getPrimitiveSizeInBits());
+      llvm::Value *V = Builder.CreateBitCast(RawIntV, PaddedVecTy);
+      // Shuffle <P x i1> --> <N x i1> (N is the actual bit size)
+      V = emitBoolVecConversion(V, ValNumElems, "extractvec");
 
-      const auto *VTy = cast<llvm::FixedVectorType>(EltTy);
+      return EmitFromMemory(V, Ty);
+    }
 
-      // Handle vectors of size 3 like size 4 for better performance.
-      if (VTy->getNumElements() == 3) {
+    const llvm::Type *EltTy = Addr.getElementType();
+    const auto *VTy = cast<llvm::FixedVectorType>(EltTy);
+
+    if (!CGM.getCodeGenOpts().PreserveVec3Type && VTy->getNumElements() == 3) {
 
-        // Bitcast to vec4 type.
-        auto *vec4Ty = llvm::FixedVectorType::get(VTy->getElementType(), 4);
-        Address Cast = Builder.CreateElementBitCast(Addr, vec4Ty, "castToVec4");
-        // Now load value.
-        llvm::Value *V = Builder.CreateLoad(Cast, Volatile, "loadVec4");
+      llvm::VectorType *vec4Ty =
+          llvm::FixedVectorType::get(VTy->getElementType(), 4);
 
-        // Shuffle vector to get vec3.
-        V = Builder.CreateShuffleVector(V, llvm::UndefValue::get(vec4Ty),
-                                        ArrayRef<int>{0, 1, 2}, "extractVec");
-        return EmitFromMemory(V, Ty);
-      }
-    }
-  }
 
   // Atomic operations have to be done on integral types.
   LValue AtomicLValue =
       LValue::MakeAddr(Addr, Ty, getContext(), BaseInfo, TBAAInfo);
   if (Ty->isAtomicType() || LValueIsSuitableForInlineAtomic(AtomicLValue)) {
     return EmitAtomicLoad(AtomicLValue, Loc).getScalarVal();
   }
 
if (Value->getType()->isIntegerTy(1))
       return Builder.CreateZExt(Value, ConvertTypeForMem(Ty), "frombool");
     assert(Value->getType()->isIntegerTy(getContext().getTypeSize(Ty)) &&
            "wrong value rep of bool");
   }
 
   return Value;
 }
 
+static bool isBooleanVector(QualType Ty) {
+  const auto *VecTy = Ty->getAs<VectorType>();
+  if (!VecTy)
+    return false;
+  return VecTy->isVectorSizeBoolean();
+}
+
 llvm::Value *CodeGenFunction::EmitFromMemory(llvm::Value *Value, QualType Ty) {
   // Bool has a different representation in memory than in registers.
   if (hasBooleanRepresentation(Ty)) {
     assert(Value->getType()->isIntegerTy(getContext().getTypeSize(Ty)) &&
            "wrong value rep of bool");
     return Builder.CreateTrunc(Value, Builder.getInt1Ty(), "tobool");
   }
+  if (Target.hasDenseBoolVectors() && isBooleanVector(Ty)) {
+    const auto *RawIntTy = Value->getType();
+    // Bitcast iP --> <P x i1>
+    auto *PaddedVecTy = llvm::FixedVectorType::get(
+        Builder.getInt1Ty(), RawIntTy->getPrimitiveSizeInBits());
+    auto *V = Builder.CreateBitCast(Value, PaddedVecTy);
+    // Shuffle <P x i1> --> <N x i1> (N is the actual bit size)
+    llvm::Type *ValTy = ConvertType(Ty);
+    unsigned ValNumElems = cast<llvm::FixedVectorType>(ValTy)->getNumElements();
+    return emitBoolVecConversion(V, ValNumElems, "extractvec");
+  }
 
   return Value;
 }
 
 // Convert the pointer of \p Addr to a pointer to a vector (the value type of
 // MatrixType), if it points to a array (the memory type of MatrixType).
 static Address MaybeConvertMatrixAddress(Address Addr, CodeGenFunction &CGF,
                                          bool IsVector = true) {
CGF.EmitStoreOfScalar(value, Addr, lvalue.isVolatile(), lvalue.getType(),
                         lvalue.isNontemporal());
 }
 
 void CodeGenFunction::EmitStoreOfScalar(llvm::Value *Value, Address Addr,
                                         bool Volatile, QualType Ty,
                                         LValueBaseInfo BaseInfo,
                                         TBAAAccessInfo TBAAInfo,
                                         bool isInit, bool isNontemporal) {
-  if (!CGM.getCodeGenOpts().PreserveVec3Type) {
-    // Handle vectors differently to get better performance.
-    if (Ty->isVectorType()) {
-      llvm::Type *SrcTy = Value->getType();
-      auto *VecTy = dyn_cast<llvm::VectorType>(SrcTy);
+  const auto *ClangVecTy = Ty->getAs<VectorType>();
+  if (ClangVecTy) {
+    auto *VecTy = dyn_cast<llvm::FixedVectorType>(SrcTy);
+    if (Target.hasDenseBoolVectors() && ClangVecTy->isVectorSizeBoolean()) {
+      auto *MemIntTy =
+          cast<llvm::IntegerType>(Addr.getType()->getPointerElementType());
+      // Expand to the memory bit width
+      unsigned MemNumElems = MemIntTy->getPrimitiveSizeInBits();
+      // <N x i1> --> <P x i1>
+      Value = emitBoolVecConversion(Value, MemNumElems, "insertvec");
+      // <P x i1> --> iP
+      Value = Builder.CreateBitCast(Value, MemIntTy);
+    } else if (!CGM.getCodeGenOpts().PreserveVec3Type) {
       // Handle vec3 special.
       if (VecTy && cast<llvm::FixedVectorType>(VecTy)->getNumElements() == 3) {
         // Our source is a vec3, do a shuffle vector to make it a vec4.
         Value = Builder.CreateShuffleVector(Value, llvm::UndefValue::get(VecTy),
                                             ArrayRef<int>{0, 1, 2, -1},
                                             "extractVec");
         SrcTy = llvm::FixedVectorType::get(VecTy->getElementType(), 4);
       }

 /// is 'Ty'.
 void CodeGenFunction::EmitStoreThroughLValue(RValue Src, LValue Dst,
                                              bool isInit) {
   if (!Dst.isSimple()) {
     if (Dst.isVectorElt()) {
       // Read/modify/write the vector, inserting the new element.
       llvm::Value *Vec = Builder.CreateLoad(Dst.getVectorAddress(),
                                             Dst.isVolatileQualified());
+      auto *IRStoreTy = dyn_cast<llvm::IntegerType>(Vec->getType());
+      if (IRStoreTy) {
+        auto *IRVecTy = llvm::FixedVectorType::get(
+            Builder.getInt1Ty(), IRStoreTy->getPrimitiveSizeInBits());
+        Vec = Builder.CreateBitCast(Vec, IRVecTy);
+        // iN --> <N x i1>
+      }
       Vec = Builder.CreateInsertElement(Vec, Src.getScalarVal(),
                                         Dst.getVectorIdx(), "vecins");
+      if (IRStoreTy) {
+        // <N x i1> --> <iN>
+        Vec = Builder.CreateBitCast(Vec, IRStoreTy);
+      }
       Builder.CreateStore(Vec, Dst.getVectorAddress(),
                           Dst.isVolatileQualified());
       return;
     }
 
     // If this is an update of extended vector elements, insert them as
     // appropriate.
     if (Dst.isExtVectorElt())

clang/lib/CodeGen/CGExprScalar.cpp

case CK_LValueToRValueBitCast: {
     DestLV.setTBAAInfo(TBAAAccessInfo::getMayAliasInfo());
     return EmitLoadOfLValue(DestLV, CE->getExprLoc());
   }
 
   case CK_CPointerToObjCPointerCast:
   case CK_BlockPointerToObjCPointerCast:
   case CK_AnyPointerToBlockPointerCast:
   case CK_BitCast: {
-    Value *Src = Visit(const_cast<Expr*>(E));
+    Value *Src = Visit(const_cast<Expr *>(E));
     llvm::Type *SrcTy = Src->getType();
     llvm::Type *DstTy = ConvertType(DestTy);
     if (SrcTy->isPtrOrPtrVectorTy() && DstTy->isPtrOrPtrVectorTy() &&
         SrcTy->getPointerAddressSpace() != DstTy->getPointerAddressSpace()) {
       llvm_unreachable("wrong cast for pointers in different address spaces"
                        "(must be an address space cast)!");
     }
 
if ((isa<llvm::FixedVectorType>(SrcTy) &&
 
       Address Addr = EmitLValue(E).getAddress(CGF);
       Addr = Builder.CreateElementBitCast(Addr, CGF.ConvertTypeForMem(DestTy));
       LValue DestLV = CGF.MakeAddrLValue(Addr, DestTy);
       DestLV.setTBAAInfo(TBAAAccessInfo::getMayAliasInfo());
       return EmitLoadOfLValue(DestLV, CE->getExprLoc());
     }
 
-    return Builder.CreateBitCast(Src, DstTy);
+    // SExt/Trunc Boolean vectors to fit the expected type
+    auto *VecSrcTy = dyn_cast<llvm::VectorType>(Src->getType());
+    auto *VecDstTy = dyn_cast<llvm::VectorType>(DstTy);
+    bool VectorElementCast =
+        VecSrcTy && VecDstTy &&
+        (VecSrcTy->getElementCount() == VecDstTy->getElementCount());
+    bool IsDenseBoolVectorTarget =
+        CGF.getContext().getTargetInfo().hasDenseBoolVectors();
+    if (IsDenseBoolVectorTarget && VecSrcTy &&
+        VecSrcTy->getElementType()->isIntegerTy(1)) {
+      // When casting with the same element count extend this to the native
+      // result size Otw, signextend to 'i8' as an intermediary
+      unsigned DstElemBits =
+          VectorElementCast ? DstTy->getScalarSizeInBits() : 8;
+
+      auto *PlainIntTy = llvm::VectorType::get(Builder.getIntNTy(DstElemBits),
+                                               VecSrcTy->getElementCount());
+      Src = Builder.CreateSExt(Src, PlainIntTy);
+    }
+    Src = Builder.CreateBitCast(Src, DstTy);
+    if (IsDenseBoolVectorTarget && VectorElementCast &&
+        VecDstTy->getElementType()->isIntegerTy(1)) {
+      auto *PlainIntTy =
+          llvm::VectorType::get(Builder.getIntNTy(SrcTy->getScalarSizeInBits()),
+                                VecSrcTy->getElementCount());
+      Src = Builder.CreateTrunc(Src, PlainIntTy);
+    }
+    return Src;
   }
   case CK_AddressSpaceConversion: {
     Expr::EvalResult Result;
     if (E->EvaluateAsRValue(Result, CGF.getContext()) &&
         Result.Val.isNullPointer()) {
       // If E has side effect, it is emitted even if its final result is a
       // null pointer. In that case, a DCE pass should be able to
       // eliminate the useless instructions emitted during translating E.
static Value *createCastsForTypeOfSameSize(CGBuilderTy &Builder,
 
   // Case 4b.
   if (!SrcTy->isIntegerTy())
     Src = Builder.CreateBitCast(Src, DL.getIntPtrType(DstTy));
   // Cases 4a and 4b.
   return Builder.CreateIntToPtr(Src, DstTy, Name);
 }
 
+static bool IsGenericBoolVector(QualType Ty) {
+  const auto *ClangVecTy = dyn_cast<VectorType>(Ty);
+  if (!ClangVecTy)
+    return false;
+
+  return ClangVecTy->isVectorSizeBoolean();
+}
+
 Value *ScalarExprEmitter::VisitAsTypeExpr(AsTypeExpr *E) {
   Value *Src  = CGF.EmitScalarExpr(E->getSrcExpr());
   llvm::Type *DstTy = ConvertType(E->getType());
 
   llvm::Type *SrcTy = Src->getType();
   unsigned NumElementsSrc =
       isa<llvm::VectorType>(SrcTy)
           ? cast<llvm::FixedVectorType>(SrcTy)->getNumElements()
           : 0;
   unsigned NumElementsDst =
       isa<llvm::VectorType>(DstTy)
           ? cast<llvm::FixedVectorType>(DstTy)->getNumElements()
           : 0;
 
+  // Use bit vector expansion for generic boolean vectors
+  if (CGF.getTarget().hasDenseBoolVectors() &&
+      IsGenericBoolVector(E->getType())) {
+    return CGF.emitBoolVecConversion(Src, NumElementsDst, "astype");
+  }
+
   // Going from vec3 to non-vec3 is a special case and requires a shuffle
   // vector to get a vec4, then a bitcast if the target type is different.
   if (NumElementsSrc == 3 && NumElementsDst != 3) {
     Src = ConvertVec3AndVec4(Builder, CGF, Src, 4);
 
     if (!CGF.CGM.getCodeGenOpts().PreserveVec3Type) {
       Src = createCastsForTypeOfSameSize(Builder, CGF.CGM.getDataLayout(), Src,
                                          DstTy);
     }
 
     Src->setName("astype");
     return Src;
   }
 
   // Going from non-vec3 to vec3 is a special case and requires a bitcast
   // to vec4 if the original type is not vec4, then a shuffle vector to
   // get a vec3.
   if (NumElementsSrc != 3 && NumElementsDst == 3) {
     if (!CGF.CGM.getCodeGenOpts().PreserveVec3Type) {
       auto *Vec4Ty = llvm::FixedVectorType::get(
           cast<llvm::VectorType>(DstTy)->getElementType(), 4);
       Src = createCastsForTypeOfSameSize(Builder, CGF.CGM.getDataLayout(), Src,
                                          Vec4Ty);
     }
 
     Src = ConvertVec3AndVec4(Builder, CGF, Src, 3);
     Src->setName("astype");
     return Src;

clang/lib/CodeGen/CodeGenFunction.h

public:
   void SetFPAccuracy(llvm::Value *Val, float Accuracy);
 
   /// SetFPModel - Control floating point behavior via fp-model settings.
   void SetFPModel();
 
   /// Set the codegen fast-math flags.
   void SetFastMathFlags(FPOptions FPFeatures);
 
+  // Truncate or extend a boolean vector to the requested number of elements.
+  llvm::Value *emitBoolVecConversion(llvm::Value *SrcVec,
+                                     unsigned NumElementsDst,
+                                     const llvm::Twine &Name = "");
+
 private:
   llvm::MDNode *getRangeForLoadFromType(QualType Ty);
   void EmitReturnOfRValue(RValue RV, QualType Ty);
 
   void deferPlaceholderReplacement(llvm::Instruction *Old, llvm::Value *New);
 
   llvm::SmallVector<std::pair<llvm::Instruction *, llvm::Value *>, 4>
   DeferredReplacements;

clang/lib/CodeGen/CodeGenFunction.cpp

 }
 
 llvm::DebugLoc CodeGenFunction::SourceLocToDebugLoc(SourceLocation Location) {
   if (CGDebugInfo *DI = getDebugInfo())
     return DI->SourceLocToDebugLoc(Location);
 
   return llvm::DebugLoc();
 }
+
+llvm::Value *CodeGenFunction::emitBoolVecConversion(llvm::Value *SrcVec,
+                                                    unsigned NumElementsDst,
+                                                    const llvm::Twine &Name) {
+  auto *SrcTy = cast<llvm::FixedVectorType>(SrcVec->getType());
+  unsigned NumElementsSrc = SrcTy->getNumElements();
+  if (NumElementsSrc == NumElementsDst) {
+    return SrcVec;
+  }
+
+  std::vector<int> ShuffleMask(NumElementsDst, -1);
+  for (unsigned MaskIdx = 0;
+       MaskIdx < std::min<>(NumElementsDst, NumElementsSrc); ++MaskIdx) {
+    ShuffleMask[MaskIdx] = MaskIdx;
+  }
+
+  return Builder.CreateShuffleVector(SrcVec, llvm::UndefValue::get(SrcTy),
+                                     ShuffleMask, Name);
+}

clang/lib/CodeGen/CodeGenTypes.cpp

if (T->isConstantMatrixType()) {
     const Type *Ty = Context.getCanonicalType(T).getTypePtr();
     const ConstantMatrixType *MT = cast<ConstantMatrixType>(Ty);
     return llvm::ArrayType::get(ConvertType(MT->getElementType()),
                                 MT->getNumRows() * MT->getNumColumns());
   }
 
   llvm::Type *R = ConvertType(T);
 
+  // Check for the boolean vector case
+  bool DenseBoolVector = CGM.getTarget().hasDenseBoolVectors();
+  auto *FixedVT = dyn_cast<llvm::FixedVectorType>(R);
+  if (DenseBoolVector && T->isVectorType() && FixedVT &&
+      FixedVT->getElementType()->isIntegerTy(1)) {
+
+    // Pad to at least one byte.
+    uint64_t BytePadded = std::max<uint64_t>(FixedVT->getNumElements(), 8);
+    return llvm::IntegerType::get(FixedVT->getContext(), BytePadded);
+  }
+
   // If this is a bool type, or an ExtIntType in a bitfield representation,
   // map this integer to the target-specified size.
   if ((ForBitField && T->isExtIntType()) ||
       (!T->isExtIntType() && R->isIntegerTy(1)))
     return llvm::IntegerType::get(getLLVMContext(),
                                   (unsigned)Context.getTypeSize(T));
 
   // Else, don't map it.
case Type::ConstantArray: {
     }
 
     ResultType = llvm::ArrayType::get(EltTy, A->getSize().getZExtValue());
     break;
   }
   case Type::ExtVector:
   case Type::Vector: {
     const VectorType *VT = cast<VectorType>(Ty);
-    ResultType = llvm::FixedVectorType::get(ConvertType(VT->getElementType()),
-                                            VT->getNumElements());
+    llvm::Type *IRElemTy = VT->getElementType()->isBooleanType()
+                               ? llvm::Type::getInt1Ty(getLLVMContext())
+                               : ConvertType(VT->getElementType());
+    ResultType = llvm::FixedVectorType::get(IRElemTy, VT->getNumElements());
     break;
   }
   case Type::ConstantMatrix: {
     const ConstantMatrixType *MT = cast<ConstantMatrixType>(Ty);
     ResultType =
         llvm::FixedVectorType::get(ConvertType(MT->getElementType()),
                                    MT->getNumRows() * MT->getNumColumns());
     break;

clang/lib/Sema/SemaExpr.cpp

case Type::STK_FixedPoint:
       return CK_IntegralCast;
     }
     llvm_unreachable("Should have returned before this");
   }
 
   llvm_unreachable("Unhandled scalar cast");
 }
 
-static bool breakDownVectorType(QualType type, uint64_t &len,
-                                QualType &eltType) {
+static bool breakDownVectorType(QualType type, uint64_t &len, QualType &eltType,
+                                bool &IsVectorSizeBool) {
   // Vectors are simple.
+  IsVectorSizeBool = false;
   if (const VectorType *vecType = type->getAs<VectorType>()) {
     len = vecType->getNumElements();
+    IsVectorSizeBool = vecType->isVectorSizeBoolean();
     eltType = vecType->getElementType();
     assert(eltType->isScalarType());
     return true;
   }
 
   // We allow lax conversion to and from non-vector types, but only if
   // they're real types (i.e. non-complex, non-pointer scalar types).
   if (!type->isRealType()) return false;
bool Sema::areLaxCompatibleVectorTypes(QualType srcTy, QualType destTy) {
   // depend on them).  Most scalar OP ExtVector cases are handled by the
   // splat path anyway, which does what we want (convert, not bitcast).
   // What this rules out for ExtVectors is crazy things like char4*float.
   if (srcTy->isScalarType() && destTy->isExtVectorType()) return false;
   if (destTy->isScalarType() && srcTy->isExtVectorType()) return false;
 
   uint64_t srcLen, destLen;
   QualType srcEltTy, destEltTy;
-  if (!breakDownVectorType(srcTy, srcLen, srcEltTy)) return false;
-  if (!breakDownVectorType(destTy, destLen, destEltTy)) return false;
+  bool srcBoolVector, destBoolVector;
+  if (!breakDownVectorType(srcTy, srcLen, srcEltTy, srcBoolVector))
+    return false;
+  if (!breakDownVectorType(destTy, destLen, destEltTy, destBoolVector))
+    return false;
+
+  bool HasBitVectors = Context.getTargetInfo().hasDenseBoolVectors();
 
   // ASTContext::getTypeSize will return the size rounded up to a
   // power of 2, so instead of using that, we need to use the raw
   // element size multiplied by the element count.
-  uint64_t srcEltSize = Context.getTypeSize(srcEltTy);
-  uint64_t destEltSize = Context.getTypeSize(destEltTy);
+  uint64_t srcEltSize =
+      (HasBitVectors & srcBoolVector) ? 1 : Context.getTypeSize(srcEltTy);
+  uint64_t destEltSize =
+      (HasBitVectors & destBoolVector) ? 1 : Context.getTypeSize(destEltTy);
 
   return (srcLen * srcEltSize == destLen * destEltSize);
 }
 
 /// Is this a legal conversion between two types, one of which is
 /// known to be a vector type?
 bool Sema::isLaxVectorConversion(QualType srcTy, QualType destTy) {
   assert(destTy->isVectorType() || srcTy->isVectorType());
OpenCLCheckVectorConditional(Sema &S, ExprResult &Cond,
   if (checkOpenCLConditionVector(S, Cond.get(), QuestionLoc))
     return QualType();
 
   // If either operand is a vector then find the vector type of the
   // result as specified in OpenCL v1.1 s6.3.i.
   if (LHS.get()->getType()->isVectorType() ||
       RHS.get()->getType()->isVectorType()) {
     QualType VecResTy = S.CheckVectorOperands(LHS, RHS, QuestionLoc,
-                                              /*isCompAssign*/false,
-                                              /*AllowBothBool*/true,
-                                              /*AllowBoolConversions*/false);
+                                              /*isCompAssign*/ false,
+                                              /*AllowBothBool*/ true,
+                                              /*AllowBoolConversions*/ false,
+                                              /*AllowBooleanOperation*/ false,
+                                              /*ReportInvalid*/ true);
     if (VecResTy.isNull()) return QualType();
     // The result type must match the condition type as specified in
     // OpenCL v1.1 s6.11.6.
     if (checkVectorResult(S, CondTy, VecResTy, QuestionLoc))
       return QualType();
     return VecResTy;
   }
 
QualType Sema::CheckConditionalOperands(ExprResult &Cond, ExprResult &LHS,
   if (Cond.isInvalid())
     return QualType();
   if (checkCondition(*this, Cond.get(), QuestionLoc))
     return QualType();
 
   // Now check the two expressions.
   if (LHS.get()->getType()->isVectorType() ||
       RHS.get()->getType()->isVectorType())
-    return CheckVectorOperands(LHS, RHS, QuestionLoc, /*isCompAssign*/false,
-                               /*AllowBothBool*/true,
-                               /*AllowBoolConversions*/false);
+    return CheckVectorOperands(LHS, RHS, QuestionLoc, /*isCompAssign*/ false,
+                               /*AllowBothBool*/ true,
+                               /*AllowBoolConversions*/ false,
+                               /*AllowBooleanOperation*/ false,
+                               /*ReportInvalid*/ true);
 
   QualType ResTy =
       UsualArithmeticConversions(LHS, RHS, QuestionLoc, ACK_Conditional);
   if (LHS.isInvalid() || RHS.isInvalid())
     return QualType();
 
   QualType LHSTy = LHS.get()->getType();
   QualType RHSTy = RHS.get()->getType();
static bool tryGCCVectorConvertAndSplat(Sema &S, ExprResult *Scalar,
   if (Scalar) {
     if (ScalarCast != CK_NoOp)
       *Scalar = S.ImpCastExprToType(Scalar->get(), VectorEltTy, ScalarCast);
     *Scalar = S.ImpCastExprToType(Scalar->get(), VectorTy, CK_VectorSplat);
   }
   return false;
 }
 
+static bool IsScalarOrVectorSizeBool(QualType Ty) {
+  return Ty->isBooleanType() ||
+         (Ty->isVectorType() && Ty->getAs<VectorType>()->isVectorSizeBoolean());
+}
+
 QualType Sema::CheckVectorOperands(ExprResult &LHS, ExprResult &RHS,
                                    SourceLocation Loc, bool IsCompAssign,
                                    bool AllowBothBool,
-                                   bool AllowBoolConversions) {
+                                   bool AllowBoolConversions,
+                                   bool AllowBoolOperation,
+                                   bool ReportInvalid) {
   if (!IsCompAssign) {
     LHS = DefaultFunctionArrayLvalueConversion(LHS.get());
     if (LHS.isInvalid())
       return QualType();
   }
   RHS = DefaultFunctionArrayLvalueConversion(RHS.get());
   if (RHS.isInvalid())
     return QualType();
 
   // For conversion purposes, we ignore any qualifiers.
   // For example, "const float" and "float" are equivalent.
   QualType LHSType = LHS.get()->getType().getUnqualifiedType();
   QualType RHSType = RHS.get()->getType().getUnqualifiedType();
 
   const VectorType *LHSVecType = LHSType->getAs<VectorType>();
   const VectorType *RHSVecType = RHSType->getAs<VectorType>();
   assert(LHSVecType || RHSVecType);
 
   if ((LHSVecType && LHSVecType->getElementType()->isBFloat16Type()) ||
       (RHSVecType && RHSVecType->getElementType()->isBFloat16Type()))
-    return InvalidOperands(Loc, LHS, RHS);
+    return ReportInvalid ? InvalidOperands(Loc, LHS, RHS) : QualType();
 
   // AltiVec-style "vector bool op vector bool" combinations are allowed
   // for some operators but not others.
   if (!AllowBothBool &&
       LHSVecType && LHSVecType->getVectorKind() == VectorType::AltiVecBool &&
       RHSVecType && RHSVecType->getVectorKind() == VectorType::AltiVecBool)
-    return InvalidOperands(Loc, LHS, RHS);
+    return ReportInvalid ? InvalidOperands(Loc, LHS, RHS) : QualType();
+
+  // This operation may not be performed on boolean vectors.
+  if (!AllowBoolOperation && IsScalarOrVectorSizeBool(LHSType) &&
+      IsScalarOrVectorSizeBool(RHSType))
+    return ReportInvalid ? InvalidOperands(Loc, LHS, RHS) : QualType();
 
   // If the vector types are identical, return.
   if (Context.hasSameType(LHSType, RHSType))
     return LHSType;
 
   // If we have compatible AltiVec and GCC vector types, use the AltiVec type.
   if (LHSVecType && RHSVecType &&
       Context.areCompatibleVectorTypes(LHSType, RHSType)) {

 QualType Sema::CheckMultiplyDivideOperands(ExprResult &LHS, ExprResult &RHS,
                                            SourceLocation Loc,
                                            bool IsCompAssign, bool IsDiv) {
   checkArithmeticNull(*this, LHS, RHS, Loc, /*IsCompare=*/false);
 
   if (LHS.get()->getType()->isVectorType() ||
       RHS.get()->getType()->isVectorType())
     return CheckVectorOperands(LHS, RHS, Loc, IsCompAssign,
-                               /*AllowBothBool*/getLangOpts().AltiVec,
-                               /*AllowBoolConversions*/false);
+                               /*AllowBothBool*/ getLangOpts().AltiVec,
+                               /*AllowBoolConversions*/ false,
+                               /*AllowBooleanOperation*/ false,
+                               /*ReportInvalid*/ true);
   if (!IsDiv && (LHS.get()->getType()->isConstantMatrixType() ||
                  RHS.get()->getType()->isConstantMatrixType()))
     return CheckMatrixMultiplyOperands(LHS, RHS, Loc, IsCompAssign);
 
   QualType compType = UsualArithmeticConversions(
       LHS, RHS, Loc, IsCompAssign ? ACK_CompAssign : ACK_Arithmetic);
   if (LHS.isInvalid() || RHS.isInvalid())
     return QualType();
QualType Sema::CheckRemainderOperands(
   ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign) {
   checkArithmeticNull(*this, LHS, RHS, Loc, /*IsCompare=*/false);
 
   if (LHS.get()->getType()->isVectorType() ||
       RHS.get()->getType()->isVectorType()) {
     if (LHS.get()->getType()->hasIntegerRepresentation() &&
         RHS.get()->getType()->hasIntegerRepresentation())
       return CheckVectorOperands(LHS, RHS, Loc, IsCompAssign,
-                                 /*AllowBothBool*/getLangOpts().AltiVec,
-                                 /*AllowBoolConversions*/false);
+                                 /*AllowBothBool*/ getLangOpts().AltiVec,
+                                 /*AllowBoolConversions*/ false,
+                                 /*AllowBooleanOperation*/ false,
+                                 /*ReportInvalid*/ true);
     return InvalidOperands(Loc, LHS, RHS);
   }
 
   QualType compType = UsualArithmeticConversions(
       LHS, RHS, Loc, IsCompAssign ? ACK_CompAssign : ACK_Arithmetic);
   if (LHS.isInvalid() || RHS.isInvalid())
     return QualType();
 

 // C99 6.5.6
 QualType Sema::CheckAdditionOperands(ExprResult &LHS, ExprResult &RHS,
                                      SourceLocation Loc, BinaryOperatorKind Opc,
                                      QualType* CompLHSTy) {
   checkArithmeticNull(*this, LHS, RHS, Loc, /*IsCompare=*/false);
 
   if (LHS.get()->getType()->isVectorType() ||
       RHS.get()->getType()->isVectorType()) {
-    QualType compType = CheckVectorOperands(
-        LHS, RHS, Loc, CompLHSTy,
-        /*AllowBothBool*/getLangOpts().AltiVec,
-        /*AllowBoolConversions*/getLangOpts().ZVector);
+    QualType compType =
+        CheckVectorOperands(LHS, RHS, Loc, CompLHSTy,
+                            /*AllowBothBool*/ getLangOpts().AltiVec,
+                            /*AllowBoolConversions*/ getLangOpts().ZVector,
+                            /*AllowBooleanOperation*/ false,
+                            /*ReportInvalid*/ true);
     if (CompLHSTy) *CompLHSTy = compType;
     return compType;
   }
 
   if (LHS.get()->getType()->isConstantMatrixType() ||
       RHS.get()->getType()->isConstantMatrixType()) {
     return CheckMatrixElementwiseOperands(LHS, RHS, Loc, CompLHSTy);
   }

 // C99 6.5.6
 QualType Sema::CheckSubtractionOperands(ExprResult &LHS, ExprResult &RHS,
                                         SourceLocation Loc,
                                         QualType* CompLHSTy) {
   checkArithmeticNull(*this, LHS, RHS, Loc, /*IsCompare=*/false);
 
   if (LHS.get()->getType()->isVectorType() ||
       RHS.get()->getType()->isVectorType()) {
-    QualType compType = CheckVectorOperands(
-        LHS, RHS, Loc, CompLHSTy,
-        /*AllowBothBool*/getLangOpts().AltiVec,
-        /*AllowBoolConversions*/getLangOpts().ZVector);
+    QualType compType =
+        CheckVectorOperands(LHS, RHS, Loc, CompLHSTy,
+                            /*AllowBothBool*/ getLangOpts().AltiVec,
+                            /*AllowBoolConversions*/ getLangOpts().ZVector,
+                            /*AllowBooleanOperation*/ false,
+                            /*ReportInvalid*/ true);
     if (CompLHSTy) *CompLHSTy = compType;
     return compType;
   }
 
   if (LHS.get()->getType()->isConstantMatrixType() ||
       RHS.get()->getType()->isConstantMatrixType()) {
     return CheckMatrixElementwiseOperands(LHS, RHS, Loc, CompLHSTy);
   }
static QualType checkVectorShift(Sema &S, ExprResult &LHS, ExprResult &RHS,
   const VectorType *LHSVecTy = LHSType->getAs<VectorType>();
   QualType LHSEleType = LHSVecTy ? LHSVecTy->getElementType() : LHSType;
 
   // Note that RHS might not be a vector.
   QualType RHSType = RHS.get()->getType();
   const VectorType *RHSVecTy = RHSType->getAs<VectorType>();
   QualType RHSEleType = RHSVecTy ? RHSVecTy->getElementType() : RHSType;
 
+  // Do not allow shifts for vector_size boolean vectors.
+  if ((LHSVecTy && LHSVecTy->isVectorSizeBoolean()) ||
+      (RHSVecTy && RHSVecTy->isVectorSizeBoolean())) {
+    S.Diag(Loc, diag::err_typecheck_invalid_operands)
+        << LHS.get()->getType() << RHS.get()->getType()
+        << LHS.get()->getSourceRange();
+    return QualType();
+  }
+
   // The operands need to be integers.
   if (!LHSEleType->isIntegerType()) {
     S.Diag(Loc, diag::err_typecheck_expect_int)
       << LHS.get()->getType() << LHS.get()->getSourceRange();
     return QualType();
   }
 
   if (!RHSEleType->isIntegerType()) {
else if (TypeSize == Context.getTypeSize(Context.IntTy))
       return Context.getExtVectorType(Context.IntTy, VTy->getNumElements());
     else if (TypeSize == Context.getTypeSize(Context.LongTy))
       return Context.getExtVectorType(Context.LongTy, VTy->getNumElements());
     assert(TypeSize == Context.getTypeSize(Context.LongLongTy) &&
            "Unhandled vector element size in vector compare");
     return Context.getExtVectorType(Context.LongLongTy, VTy->getNumElements());
   }
 
-  if (TypeSize == Context.getTypeSize(Context.LongLongTy))
+  if (VTy->isVectorSizeBoolean())
+    return Context.getVectorType(Context.BoolTy, VTy->getNumElements(),
+                                 VectorType::GenericVector);
+  else if (TypeSize == Context.getTypeSize(Context.LongLongTy))
     return Context.getVectorType(Context.LongLongTy, VTy->getNumElements(),
                                  VectorType::GenericVector);
   else if (TypeSize == Context.getTypeSize(Context.LongTy))
     return Context.getVectorType(Context.LongTy, VTy->getNumElements(),
                                  VectorType::GenericVector);
   else if (TypeSize == Context.getTypeSize(Context.IntTy))
     return Context.getVectorType(Context.IntTy, VTy->getNumElements(),
                                  VectorType::GenericVector);
   else if (TypeSize == Context.getTypeSize(Context.ShortTy))
     return Context.getVectorType(Context.ShortTy, VTy->getNumElements(),
                                  VectorType::GenericVector);
   assert(TypeSize == Context.getTypeSize(Context.CharTy) &&
          "Unhandled vector element size in vector compare");
   return Context.getVectorType(Context.CharTy, VTy->getNumElements(),
                                VectorType::GenericVector);
 }
 
 /// CheckVectorCompareOperands - vector comparisons are a clang extension that
 /// operates on extended vector types.  Instead of producing an IntTy result,
 /// like a scalar comparison, a vector comparison produces a vector of integer
 /// types.
 QualType Sema::CheckVectorCompareOperands(ExprResult &LHS, ExprResult &RHS,
                                           SourceLocation Loc,
                                           BinaryOperatorKind Opc) {
   if (Opc == BO_Cmp) {
     Diag(Loc, diag::err_three_way_vector_comparison);
     return QualType();
   }
 
   // Check to make sure we're operating on vectors of the same type and width,
   // Allowing one side to be a scalar of element type.
-  QualType vType = CheckVectorOperands(LHS, RHS, Loc, /*isCompAssign*/false,
-                              /*AllowBothBool*/true,
-                              /*AllowBoolConversions*/getLangOpts().ZVector);
+  QualType vType =
+      CheckVectorOperands(LHS, RHS, Loc, /*isCompAssign*/ false,
+                          /*AllowBothBool*/ true,
+                          /*AllowBoolConversions*/ getLangOpts().ZVector,
+                          /*AllowBooleanOperation*/ true,
+                          /*ReportInvalid*/ true);
   if (vType.isNull())
     return vType;
 
   QualType LHSType = LHS.get()->getType();
 
   // If AltiVec, the comparison results in a numeric type, i.e.
   // bool for C++, int for C
   if (getLangOpts().AltiVec &&
static void diagnoseXorMisusedAsPow(Sema &S, const ExprResult &XorLHS,
   }
 }
 
 QualType Sema::CheckVectorLogicalOperands(ExprResult &LHS, ExprResult &RHS,
                                           SourceLocation Loc) {
   // Ensure that either both operands are of the same vector type, or
   // one operand is of a vector type and the other is of its element type.
   QualType vType = CheckVectorOperands(LHS, RHS, Loc, false,
-                                       /*AllowBothBool*/true,
-                                       /*AllowBoolConversions*/false);
+                                       /*AllowBothBool*/ true,
+                                       /*AllowBoolConversions*/ false,
+                                       /*AllowBooleanOperation*/ false,
+                                       /*ReportInvalid*/ false);
   if (vType.isNull())
     return InvalidOperands(Loc, LHS, RHS);
   if (getLangOpts().OpenCL && getLangOpts().OpenCLVersion < 120 &&
       !getLangOpts().OpenCLCPlusPlus && vType->hasFloatingRepresentation())
     return InvalidOperands(Loc, LHS, RHS);
   // FIXME: The check for C++ here is for GCC compatibility. GCC rejects the
   //        usage of the logical operators && and || with vectors in C. This
   //        check could be notionally dropped.
if (LHSMatType && RHSMatType) {
 
     return Context.getConstantMatrixType(LHSMatType->getElementType(),
                                          LHSMatType->getNumRows(),
                                          RHSMatType->getNumColumns());
   }
   return CheckMatrixElementwiseOperands(LHS, RHS, Loc, IsCompAssign);
 }
 
+static bool isLegalBoolVectorBinaryOp(BinaryOperatorKind Opc) {
+  switch (Opc) {
+  default:
+    return false;
+  case BO_And:
+  case BO_AndAssign:
+  case BO_Or:
+  case BO_OrAssign:
+  case BO_Xor:
+  case BO_XorAssign:
+    return true;
+  }
+}
+
 inline QualType Sema::CheckBitwiseOperands(ExprResult &LHS, ExprResult &RHS,
                                            SourceLocation Loc,
                                            BinaryOperatorKind Opc) {
   checkArithmeticNull(*this, LHS, RHS, Loc, /*IsCompare=*/false);
 
   bool IsCompAssign =
       Opc == BO_AndAssign || Opc == BO_OrAssign || Opc == BO_XorAssign;
 
+  bool LegalBoolVecOperator = isLegalBoolVectorBinaryOp(Opc);
+
   if (LHS.get()->getType()->isVectorType() ||
       RHS.get()->getType()->isVectorType()) {
     if (LHS.get()->getType()->hasIntegerRepresentation() &&
         RHS.get()->getType()->hasIntegerRepresentation())
       return CheckVectorOperands(LHS, RHS, Loc, IsCompAssign,
-                        /*AllowBothBool*/true,
-                        /*AllowBoolConversions*/getLangOpts().ZVector);
+                                 /*AllowBothBool*/ true,
+                                 /*AllowBoolConversions*/ getLangOpts().ZVector,
+                                 /*AllowBooleanOperation*/ LegalBoolVecOperator,
+                                 /*ReportInvalid*/ true);
     return InvalidOperands(Loc, LHS, RHS);
   }
 
   if (Opc == BO_And)
     diagnoseLogicalNotOnLHSofCheck(*this, LHS, RHS, Loc, Opc);
 
   if (LHS.get()->getType()->hasFloatingRepresentation() ||
       RHS.get()->getType()->hasFloatingRepresentation())

clang/lib/Sema/SemaExprCXX.cpp

 // extension.
 static bool isValidVectorForConditionalCondition(ASTContext &Ctx,
                                                  QualType CondTy) {
   if (!CondTy->isVectorType() || CondTy->isExtVectorType())
     return false;
   const QualType EltTy =
       cast<VectorType>(CondTy.getCanonicalType())->getElementType();
 
-  assert(!EltTy->isBooleanType() && !EltTy->isEnumeralType() &&
-         "Vectors cant be boolean or enum types");
-  return EltTy->isIntegralType(Ctx);
+  assert(!EltTy->isEnumeralType() && "Vectors cant be enum types");
+  return EltTy->isIntegralType(Ctx) || EltTy->isBooleanType();
 }
 
 QualType Sema::CheckGNUVectorConditionalTypes(ExprResult &Cond, ExprResult &LHS,
                                               ExprResult &RHS,
                                               SourceLocation QuestionLoc) {
   LHS = DefaultFunctionArrayLvalueConversion(LHS.get());
   RHS = DefaultFunctionArrayLvalueConversion(RHS.get());
 
if (!Context.hasSameType(LHSType, RHSType)) {
       Diag(QuestionLoc, diag::err_conditional_vector_mismatched_vectors)
           << LHSType << RHSType;
       return {};
     }
     ResultType = LHSType;
   } else if (LHSVT || RHSVT) {
     ResultType = CheckVectorOperands(
         LHS, RHS, QuestionLoc, /*isCompAssign*/ false, /*AllowBothBool*/ true,
-        /*AllowBoolConversions*/ false);
+        /*AllowBoolConversions*/ false,
+        /*AllowBoolOperation*/ true,
+        /*ReportInvalid*/ true);
     if (ResultType.isNull())
       return {};
   } else {
     // Both are scalar.
     QualType ResultElementTy;
     LHSType = LHSType.getCanonicalType().getUnqualifiedType();
     RHSType = RHSType.getCanonicalType().getUnqualifiedType();
 
if (LTy->isFunctionPointerType() || LTy->isMemberFunctionPointerType()) {
                               "canonically equivalent function ptr types");
     }
 
     return LTy;
   }
 
   // Extension: conditional operator involving vector types.
   if (LTy->isVectorType() || RTy->isVectorType())
-    return CheckVectorOperands(LHS, RHS, QuestionLoc, /*isCompAssign*/false,
-                               /*AllowBothBool*/true,
-                               /*AllowBoolConversions*/false);
+    return CheckVectorOperands(LHS, RHS, QuestionLoc, /*isCompAssign*/ false,
+                               /*AllowBothBool*/ true,
+                               /*AllowBoolConversions*/ false,
+                               /*AllowBoolOperation*/ false,
+                               /*ReportInvalid*/ true);
 
   //   -- The second and third operands have arithmetic or enumeration type;
   //      the usual arithmetic conversions are performed to bring them to a
   //      common type, and the result is of that type.
   if (LTy->isArithmeticType() && RTy->isArithmeticType()) {
     QualType ResTy =
         UsualArithmeticConversions(LHS, RHS, QuestionLoc, ACK_Conditional);
     if (LHS.isInvalid() || RHS.isInvalid())

clang/lib/Sema/SemaType.cpp

if (getLangOpts().OpenCL) {
     }
   }
 
   return T;
 }
 
 QualType Sema::BuildVectorType(QualType CurType, Expr *SizeExpr,
                                SourceLocation AttrLoc) {
-  // The base type must be integer (not Boolean or enumeration) or float, and
+  // The base type must be boolean or integer (not enumeration) or float, and
   // can't already be a vector.
-  if ((!CurType->isDependentType() &&
-       (!CurType->isBuiltinType() || CurType->isBooleanType() ||
-        (!CurType->isIntegerType() && !CurType->isRealFloatingType()))) ||
+  if (!CurType->isDependentType() &&
+      (!CurType->isBuiltinType() ||
+       (!CurType->isIntegerType() && !CurType->isRealFloatingType())) ||
       CurType->isArrayType()) {
     Diag(AttrLoc, diag::err_attribute_invalid_vector_type) << CurType;
     return QualType();
   }
 
   if (SizeExpr->isTypeDependent() || SizeExpr->isValueDependent())
     return Context.getDependentVectorType(CurType, SizeExpr, AttrLoc,
                                                VectorType::GenericVector);
QualType Sema::BuildVectorType(QualType CurType, Expr *SizeExpr,
   }
 
   if (VectorSizeBits / TypeSize > std::numeric_limits<uint32_t>::max()) {
     Diag(AttrLoc, diag::err_attribute_size_too_large)
         << SizeExpr->getSourceRange() << "vector";
     return QualType();
   }
 
-  return Context.getVectorType(CurType, VectorSizeBits / TypeSize,
+  uint64_t ElemSizeBits = CurType->isBooleanType() ? 1 : TypeSize;
+  return Context.getVectorType(CurType, VectorSizeBits / ElemSizeBits,
                                VectorType::GenericVector);
 }
 
 /// Build an ext-vector type.
 ///
 /// Run the required checks for the extended vector type.
 QualType Sema::BuildExtVectorType(QualType T, Expr *ArraySize,
                                   SourceLocation AttrLoc) {
if (hasExplicitCallingConv(T))
       return;
   }
 
   FT = Context.adjustFunctionType(FT, FT->getExtInfo().withCallingConv(ToCC));
   QualType Wrapped = Unwrapped.wrap(*this, FT);
   T = Context.getAdjustedType(T, Wrapped);
 }
 
-/// HandleVectorSizeAttribute - this attribute is only applicable to integral
-/// and float scalars, although arrays, pointers, and function return values are
-/// allowed in conjunction with this construct. Aggregates with this attribute
-/// are invalid, even if they are of the same size as a corresponding scalar.
-/// The raw attribute should contain precisely 1 argument, the vector size for
-/// the variable, measured in bytes. If curType and rawAttr are well formed,
-/// this routine will return a new vector type.
+/// HandleVectorSizeAttribute - this attribute is only applicable to boolean,
+/// integral and float scalars, although arrays, pointers, and function return
+/// values are allowed in conjunction with this construct. Aggregates with this
+/// attribute are invalid, even if they are of the same size as a corresponding
+/// scalar. The raw attribute should contain precisely 1 argument, the vector
+/// size for the variable, measured in bytes. If curType and rawAttr are well
+/// formed, this routine will return a new vector type.
 static void HandleVectorSizeAttr(QualType &CurType, const ParsedAttr &Attr,
                                  Sema &S) {
   // Check the attribute arguments.
   if (Attr.getNumArgs() != 1) {
     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << Attr
                                                                       << 1;
     Attr.setInvalid();
     return;

clang/test/AST/ast-print-vector-size-bool.c

+// RUN: %clang_cc1 -ast-print %s -o - | FileCheck %s
+
+// CHECK: typedef __attribute__((__vector_size__(256))) _Bool bool32;
+typedef _Bool bool32 __attribute__((vector_size(32)));

clang/test/CodeGen/debug-info-vector-bool-hvx64.c

+// RUN: %clang_cc1 -triple hexagon-unknown-elf -target-cpu hexagonv65 -target-feature +hvxv65 -target-feature +hvx-length64b -emit-llvm -debug-info-kind=limited %s -o - | FileCheck %s
+typedef _Bool bool4 __attribute__((__vector_size__(4)));
+
+bool4 b;
+
+// Test that we get byte-sized bool elements on Hexagon
+// CHECK: !DICompositeType(tag: DW_TAG_array_type,
+// CHECK-SAME:             baseType: ![[BOOL:[0-9]+]]
+// CHECK-SAME:             size: 256
+// CHECK-SAME:             DIFlagVector
+// CHECK: ![[BOOL]] = !DIBasicType(name: "_Bool"

clang/test/CodeGen/debug-info-vector-bool.c

+// RUN: %clang_cc1 -triple x86_64-linux-pc -emit-llvm -debug-info-kind=limited %s -o - | FileCheck %s
+typedef _Bool bool512 __attribute__((__vector_size__(64)));
+
+bool512 b;
+
+// Test that we get bit-sized bool elements on x86
+// CHECK: !DICompositeType(tag: DW_TAG_array_type,
+// CHECK-SAME:             baseType: ![[BOOL:[0-9]+]]
+// CHECK-SAME:             size: 512
+// CHECK-SAME:             DIFlagVector
+// CHECK: ![[BOOL]] = !DIBasicType(name: "char"

clang/test/CodeGen/vector-alignment.c

 double __attribute__((vector_size(16))) v1;
 // SSE: @v1 {{.*}}, align 16
 // AVX: @v1 {{.*}}, align 16
 // AVX512: @v1 {{.*}}, align 16
 double __attribute__((vector_size(32))) v2;
 // SSE: @v2 {{.*}}, align 16
 // AVX: @v2 {{.*}}, align 32
 // AVX512: @v2 {{.*}}, align 32
+_Bool __attribute__((vector_size(2))) v2b;
+// ALL: @v2b {{.*}}, align 2
 
 // Alignment above target max alignment with no aligned attribute should align
 // based on the target max.
 double __attribute__((vector_size(64))) v3;
 // SSE: @v3 {{.*}}, align 16
 // AVX: @v3 {{.*}}, align 32
 // AVX512: @v3 {{.*}}, align 64
 double __attribute__((vector_size(1024))) v4;
 // SSE: @v4 {{.*}}, align 16
 // AVX: @v4 {{.*}}, align 32
 // AVX512: @v4 {{.*}}, align 64
+_Bool __attribute__((vector_size(1024))) v4b;
+// SSE: @v4b {{.*}}, align 16
+// AVX: @v4b {{.*}}, align 32
+// AVX512: @v4b {{.*}}, align 64
 
 // Aliged attribute should always override.
 double __attribute__((vector_size(16), aligned(16))) v5;
 // ALL: @v5 {{.*}}, align 16
 double __attribute__((vector_size(16), aligned(64))) v6;
 // ALL: @v6 {{.*}}, align 64
 double __attribute__((vector_size(32), aligned(16))) v7;
 // ALL: @v7 {{.*}}, align 16
 double __attribute__((vector_size(32), aligned(64))) v8;
 // ALL: @v8 {{.*}}, align 64
+_Bool __attribute__((vector_size(32), aligned(128))) v8b;
+// ALL: @v8b {{.*}}, align 128
 
 // Check non-power of 2 widths.
 double __attribute__((vector_size(24))) v9;
 // SSE: @v9 {{.*}}, align 16
 // AVX: @v9 {{.*}}, align 32
 // AVX512: @v9 {{.*}}, align 32
 double __attribute__((vector_size(40))) v10;
 // SSE: @v10 {{.*}}, align 16
 // AVX: @v10 {{.*}}, align 32
 // AVX512: @v10 {{.*}}, align 64
+_Bool __attribute__((vector_size(31))) v10b;
+// SSE: @v10b {{.*}}, align 16
+// AVX: @v10b {{.*}}, align 32
+// AVX512: @v10b {{.*}}, align 32
 
 // Check non-power of 2 widths with aligned attribute.
 double __attribute__((vector_size(24), aligned(64))) v11;
 // ALL: @v11 {{.*}}, align 64
 double __attribute__((vector_size(80), aligned(16))) v12;
 // ALL: @v12 {{.*}}, align 16
+_Bool __attribute__((vector_size(31), aligned(4))) v12b;
+// ALL: @v12b {{.*}}, align 4

clang/test/SemaCXX/constexpr-vectors.cpp

void FloatVecUsage() {
   // CHECK: store <4 x float> <float 3.000000e+00, float 1.800000e+01, float 8.750000e-01, float 0x3FEC71C720000000>
 
   constexpr auto X = CmpAdd(a, b);
   // CHECK: store <4 x float> <float 2.400000e+01, float 1.900000e+01, float 1.500000e+01, float 1.700000e+01>
 
   constexpr auto Y = CmpSub(a, b);
   // CHECK: store <4 x float> <float 1.200000e+01, float 1.700000e+01, float -1.000000e+00, float -1.000000e+00>
 }
+
+using EightBoolsVecSize __attribute__((vector_size(1))) = bool;
+void BoolVecUsage() {
+  constexpr auto a = EightBoolsVecSize{true, false, true, false} <
+                     EightBoolsVecSize{false, false, true, true};
+  constexpr auto b = EightBoolsVecSize{true, false, true, false} <=
+                     EightBoolsVecSize{false, false, true, true};
+  constexpr auto c = EightBoolsVecSize{true, false, true, false} ==
+                     EightBoolsVecSize{false, false, true, true};
+  constexpr auto d = EightBoolsVecSize{true, false, true, false} !=
+                     EightBoolsVecSize{false, false, true, true};
+  constexpr auto e = EightBoolsVecSize{true, false, true, false} >=
+                     EightBoolsVecSize{false, false, true, true};
+  constexpr auto f = EightBoolsVecSize{true, false, true, false} >
+                     EightBoolsVecSize{false, false, true, true};
+}

clang/test/SemaCXX/vector-bool.cpp

+// RUN: %clang_cc1 -triple x86_64-linux-pc -fsyntax-only -verify -fexceptions -fcxx-exceptions %s -std=c++17
+// Note that this test depends on the size of long-long to be different from
+// int, so it specifies a triple.
+
+using FourShorts = short __attribute__((__vector_size__(8)));
+using TwoInts = int __attribute__((__vector_size__(8)));
+using EightInts = int __attribute__((__vector_size__(32)));
+using TwoUInts = unsigned __attribute__((__vector_size__(8)));
+using FourInts = int __attribute__((__vector_size__(16)));
+using FourUInts = unsigned __attribute__((__vector_size__(16)));
+using TwoLongLong = long long __attribute__((__vector_size__(16)));
+using FourLongLong = long long __attribute__((__vector_size__(32)));
+using TwoFloats = float __attribute__((__vector_size__(8)));
+using FourFloats = float __attribute__((__vector_size__(16)));
+using TwoDoubles = double __attribute__((__vector_size__(16)));
+using FourDoubles = double __attribute__((__vector_size__(32)));
+using EightBools = bool __attribute__((__vector_size__(1)));
+
+EightInts eight_ints;
+EightBools eight_bools;
+EightBools other_eight_bools;
+bool one_bool;
+
+// Check the rules of the LHS/RHS of the conditional operator.
+void Operations() {
+  // Legal binary
+  (void)(eight_bools | other_eight_bools);
+  (void)(eight_bools & other_eight_bools);
+  (void)(eight_bools ^ other_eight_bools);
+  (void)(~eight_bools);
+  (void)(!eight_bools);
+
+  // Legal comparison
+  (void)(eight_bools == other_eight_bools);
+  (void)(eight_bools != other_eight_bools);
+  (void)(eight_bools < other_eight_bools);
+  (void)(eight_bools <= other_eight_bools);
+  (void)(eight_bools > other_eight_bools);
+  (void)(eight_bools >= other_eight_bools);
+
+  // Legal assignments
+  (void)(eight_bools |= other_eight_bools);
+  (void)(eight_bools &= other_eight_bools);
+  (void)(eight_bools ^= other_eight_bools);
+
+  // Illegal operators
+  (void)(eight_bools || other_eight_bools); // expected-error@47 {{invalid operands to binary expression ('EightBools' (vector of 8 'bool' values) and 'EightBools')}}
+  (void)(eight_bools && other_eight_bools); // expected-error@48 {{invalid operands to binary expression ('EightBools' (vector of 8 'bool' values) and 'EightBools')}}
+  (void)(eight_bools + other_eight_bools);  // expected-error@49 {{invalid operands to binary expression ('EightBools' (vector of 8 'bool' values) and 'EightBools')}}
+  (void)(eight_bools - other_eight_bools);  // expected-error@50 {{invalid operands to binary expression ('EightBools' (vector of 8 'bool' values) and 'EightBools')}}
+  (void)(eight_bools * other_eight_bools);  // expected-error@51 {{invalid operands to binary expression ('EightBools' (vector of 8 'bool' values) and 'EightBools')}}
+  (void)(eight_bools << other_eight_bools); // expected-error@52 {{invalid operands to binary expression ('EightBools' (vector of 8 'bool' values) and 'EightBools')}}
+  (void)(eight_bools >> other_eight_bools); // expected-error@53 {{invalid operands to binary expression ('EightBools' (vector of 8 'bool' values) and 'EightBools')}}
+  (void)(eight_bools / other_eight_bools);  // expected-error@54 {{invalid operands to binary expression ('EightBools' (vector of 8 'bool' values) and 'EightBools')}}
+  (void)(eight_bools % other_eight_bools);  // expected-error@55 {{invalid operands to binary expression ('EightBools' (vector of 8 'bool' values) and 'EightBools')}}
+
+  // Illegal assignment
+  (void)(eight_bools += other_eight_bools);  // expected-error@58 {{invalid operands to binary expression ('EightBools' (vector of 8 'bool' values) and 'EightBools')}}
+  (void)(eight_bools -= other_eight_bools);  // expected-error@59 {{invalid operands to binary expression ('EightBools' (vector of 8 'bool' values) and 'EightBools')}}
+  (void)(eight_bools *= other_eight_bools);  // expected-error@60 {{invalid operands to binary expression ('EightBools' (vector of 8 'bool' values) and 'EightBools')}}
+  (void)(eight_bools <<= other_eight_bools); // expected-error@61 {{invalid operands to binary expression ('EightBools' (vector of 8 'bool' values) and 'EightBools')}}
+  (void)(eight_bools >>= other_eight_bools); // expected-error@62 {{invalid operands to binary expression ('EightBools' (vector of 8 'bool' values) and 'EightBools')}}
+  (void)(eight_bools /= other_eight_bools);  // expected-error@63 {{invalid operands to binary expression ('EightBools' (vector of 8 'bool' values) and 'EightBools')}}
+  (void)(eight_bools %= other_eight_bools);  // expected-error@64 {{invalid operands to binary expression ('EightBools' (vector of 8 'bool' values) and 'EightBools')}}
+
+  // Illegal in/decrements
+  (void)(eight_bools++); // expected-error@67 {{cannot increment value of type 'EightBools' (vector of 8 'bool' values)}}
+  (void)(++eight_bools); // expected-error@68 {{cannot increment value of type 'EightBools' (vector of 8 'bool' values)}}
+  (void)(eight_bools--); // expected-error@69 {{cannot decrement value of type 'EightBools' (vector of 8 'bool' values)}}
+  (void)(--eight_bools); // expected-error@70 {{cannot decrement value of type 'EightBools' (vector of 8 'bool' values)}}
+
+  // No implicit promotion
+  (void)(eight_bools + eight_ints); // expected-error@73 {{cannot convert between vector type 'EightInts' (vector of 8 'int' values) and vector type 'EightBools' (vector of 8 'bool' values) as implicit conversion would cause truncation}}
+  (void)(eight_ints - eight_bools); // expected-error@74 {{cannot convert between vector type 'EightBools' (vector of 8 'bool' values) and vector type 'EightInts' (vector of 8 'int' values) as implicit conversion would cause truncation}}
+}
+
+// Check the conversion to integral type of same size
+void Conversions() {
+  (void)((long)eight_bools); // expected-error@79 {{C-style cast from vector 'EightBools' (vector of 8 'bool' values) to scalar 'long' of different size}}
+  (void)((char)eight_bools);
+}

clang/test/SemaCXX/vector-conditional.cpp

 // RUN: %clang_cc1 -triple x86_64-linux-pc -fsyntax-only -verify -fexceptions -fcxx-exceptions %s -std=c++17
 // Note that this test depends on the size of long-long to be different from
 // int, so it specifies a triple.
 
 using FourShorts = short __attribute__((__vector_size__(8)));
 using TwoInts = int __attribute__((__vector_size__(8)));
 using TwoUInts = unsigned __attribute__((__vector_size__(8)));
 using FourInts = int __attribute__((__vector_size__(16)));
 using FourUInts = unsigned __attribute__((__vector_size__(16)));
 using TwoLongLong = long long __attribute__((__vector_size__(16)));
 using FourLongLong = long long __attribute__((__vector_size__(32)));
 using TwoFloats = float __attribute__((__vector_size__(8)));
 using FourFloats = float __attribute__((__vector_size__(16)));
 using TwoDoubles = double __attribute__((__vector_size__(16)));
 using FourDoubles = double __attribute__((__vector_size__(32)));
+using EightBools = bool __attribute__((__vector_size__(2)));
 
 FourShorts four_shorts;
 TwoInts two_ints;
 TwoUInts two_uints;
 FourInts four_ints;
 FourUInts four_uints;
 TwoLongLong two_ll;
 FourLongLong four_ll;
 TwoFloats two_floats;
 FourFloats four_floats;
 TwoDoubles two_doubles;
 FourDoubles four_doubles;
+EightBools eight_bools;
+EightBools other_eight_bools;
 
 enum E {};
 enum class SE {};
 E e;
 SE se;
 
 // Check the rules of the condition of the conditional operator.
 void Condition() {
void Operands() {
   (void)(four_ints ? four_uints : four_floats); // expected-error {{vector operands to the vector conditional must be the same type ('FourUInts' (vector of 4 'unsigned int' values) and 'FourFloats' (vector of 4 'float' values))}}
   (void)(four_ints ? four_uints : four_ints);   // expected-error {{vector operands to the vector conditional must be the same type ('FourUInts' (vector of 4 'unsigned int' values) and 'FourInts' (vector of 4 'int' values))}}
   (void)(four_ints ? four_ints : four_uints);   // expected-error {{vector operands to the vector conditional must be the same type ('FourInts' (vector of 4 'int' values) and 'FourUInts' (vector of 4 'unsigned int' values))}}
 
   // GCC rejects these, but our lax vector conversions don't seem to have a problem with them. Allow conversion of the float to an int as an extension.
   (void)(four_ints ? four_uints : 3.0f);
   (void)(four_ints ? four_ints : 3.0f);
 
+  // Allow conditional select on bool vectors.
+  (void)(eight_bools ? eight_bools : other_eight_bools);
+
   // When there is a vector and a scalar, conversions must be legal.
   (void)(four_ints ? four_floats : 3); // should work, ints can convert to floats.
   (void)(four_ints ? four_uints : e);  // expected-error {{cannot convert between scalar type 'E' and vector type 'FourUInts'}}
   (void)(four_ints ? four_uints : se); // expected-error {{cannot convert between vector and non-scalar values ('FourUInts' (vector of 4 'unsigned int' values) and 'SE'}}
   // GCC permits this, but our conversion rules reject this for truncation.
   (void)(two_ints ? two_ints : us);        // expected-error {{cannot convert between scalar type 'unsigned int' and vector type 'TwoInts'}}
   (void)(four_shorts ? four_shorts : uss); // expected-error {{cannot convert between scalar type 'unsigned short' and vector type 'FourShorts'}}
   (void)(four_ints ? four_floats : us);    // expected-error {{cannot convert between scalar type 'unsigned int' and vector type 'FourFloats'}}

 void all_dependent(Cond C, LHS L, RHS R) {
   (void)(C ? L : R);
 }
 
 // Check dependent cases.
 void Templates() {
   dependent_cond(two_ints);
   dependent_operand(two_floats);
-  // expected-error@159 {{vector operands to the vector conditional must be the same type ('__attribute__((__vector_size__(4 * sizeof(unsigned int)))) unsigned int' (vector of 4 'unsigned int' values) and '__attribute__((__vector_size__(4 * sizeof(double)))) double' (vector of 4 'double' values))}}}
+  // expected-error@165 {{vector operands to the vector conditional must be the same type ('__attribute__((__vector_size__(4 * sizeof(unsigned int)))) unsigned int' (vector of 4 'unsigned int' values) and '__attribute__((__vector_size__(4 * sizeof(double)))) double' (vector of 4 'double' values))}}}
   all_dependent(four_ints, four_uints, four_doubles); // expected-note {{in instantiation of}}
 
-  // expected-error@159 {{vector operands to the vector conditional must be the same type ('__attribute__((__vector_size__(4 * sizeof(unsigned int)))) unsigned int' (vector of 4 'unsigned int' values) and '__attribute__((__vector_size__(2 * sizeof(unsigned int)))) unsigned int' (vector of 2 'unsigned int' values))}}}
+  // expected-error@165 {{vector operands to the vector conditional must be the same type ('__attribute__((__vector_size__(4 * sizeof(unsigned int)))) unsigned int' (vector of 4 'unsigned int' values) and '__attribute__((__vector_size__(2 * sizeof(unsigned int)))) unsigned int' (vector of 2 'unsigned int' values))}}}
   all_dependent(four_ints, four_uints, two_uints); // expected-note {{in instantiation of}}
   all_dependent(four_ints, four_uints, four_uints);
 }

clang/test/SemaCXX/vector.cpp

void test_pseudo_dtor(fltx4 *f) {
   (*f).~fltx4();
   test_pseudo_dtor_tmpl(f);
 }
 
 // PR16204
 typedef __attribute__((ext_vector_type(4))) int vi4;
 const int &reference_to_vec_element = vi4(1).x;
 
-// PR12649
-typedef bool bad __attribute__((__vector_size__(16)));  // expected-error {{invalid vector element type 'bool'}}
+typedef bool good __attribute__((__vector_size__(16)));
 
 namespace Templates {
 template <typename Elt, unsigned long long Size>
 struct TemplateVectorType {
   typedef Elt __attribute__((__vector_size__(Size))) type; // #1
 };
 
 template <int N, typename T>
 struct PR15730 {
   typedef T __attribute__((vector_size(N * sizeof(T)))) type;
   typedef T __attribute__((vector_size(0x1000000000))) type2; // #2
   typedef T __attribute__((vector_size(3))) type3; // #3
 };
 
 void Init() {
   const TemplateVectorType<float, 32>::type Works = {};
   const TemplateVectorType<int, 32>::type Works2 = {};
-  // expected-error@#1 {{invalid vector element type 'bool'}}
-  // expected-note@+1 {{in instantiation of template class 'Templates::TemplateVectorType<bool, 32>' requested here}}
-  const TemplateVectorType<bool, 32>::type NoBool = {};
+  const TemplateVectorType<bool, 32>::type BoolWorks = {};
   // expected-error@#1 {{invalid vector element type 'int __attribute__((ext_vector_type(4)))' (vector of 4 'int' values)}}
   // expected-note@+1 {{in instantiation of template class 'Templates::TemplateVectorType<int __attribute__((ext_vector_type(4))), 32>' requested here}}
   const TemplateVectorType<vi4, 32>::type NoComplex = {};
   // expected-error@#1 {{vector size not an integral multiple of component size}}
   // expected-note@+1 {{in instantiation of template class 'Templates::TemplateVectorType<int, 33>' requested here}}
   const TemplateVectorType<int, 33>::type BadSize = {};
   const TemplateVectorType<int, 3200>::type Large = {};
   // expected-error@#1 {{vector size too large}}