Support for PowerPC vector type

[DanielCChen]

Summary

This RFC is for adding the PowerPC vector type support as a language extension.

It has the following syntax:

VECTOR(element-type-spec)

where

element-type-spec

is:

integer-type-spec

or

real-type-spec

or

unsigned-type-spec

A finite set of functionalities are implemented in order to support the PowerPC vector type:

1. declare VECTOR type objects.
2. declare VECTOR type function result.
3. declare VECTOR type dummy arguments.
4. intrinsic assignment between VECTOR type objects. (e.g. v1 = v2)
5. reference VECTOR functions.

This patch only supports the functionalities mentioned at the above. Others, such as intrinsic operators are not extended to support vectors as all operations on vector types (such as addition, subtraction, construction, ... etc) are done via calls to vector intrinsic functions. The support of constant expressions, derived component, POINTER or ALLOCATABLE attribute, I/O, and etc is not included in this patch.

The purpose of this RFC is to get comments from the community on our implementation approach. We plan to add the LIT tests in this patch as a revision soon. We also plan to add semantic checking in a separate patch in the near future.

[jeanPerier]

It is a nice implementation dealing with all compilation stages, kudos for that! I am not in favor of extending TypeCategory with Vector, which is rather central in your patch after parsing, and I am suggesting an alternative (please wait for more feedback before spending too much time trying it though).

flang/include/flang/Common/Fortran.h

23

Personally, I would not favor making "Vector" a type category: it is a bit orthogonal to the element type (it looks more like a very special shape attribute to me that would create a constant size rank one array of element with special semantic (e.g: cannot be used in intrinsic operators)).

The TypeCategory is also very central to all the type system in the compiler after parsing, I feel it makes this extension very intrusive.

Could the "Vector" aspect be represented as a special attributes that could be added to the vector dummy or result symbols? (It would probably need to be added to the characteristics DummyDataObject and FunctionResult attributes in https://github.com/llvm/llvm-project/blob/main/flang/include/flang/Evaluate/characteristics.h).

I have not thought this in detail, and cannot be sure this would work, but I wonder if you could represent the vector type as a builtin kind parametrized derived type in semantics (inside evaluate:: and semantics::) that would look like:

type __builtin_ppc_vector(element_category, element_kind)
  integer, kind :: element_category, element_kind
  integer(16) :: storage ! Ensure alignment and type size is correct in inquiries.
end type

That way, it would be transparent in semantics (there may be a few places where it would need to be forbidden explicitly in places where a parametrized derived type is allowed (e.g parentheses)). As a funny extension, this would allow you to define the ppc vector intrinsic as type bound procedures for +,-,... operators if you ever wanted to allow the usage of operators for ppc vectors.

In lowering, the builtin type would be recognized and translated to the fir.vector type (some code might expect to get a fir.record type from a semantics Derived, but not many places should be impacted).

In any case, I would wait for more feedback from @klausler here on this point.

[tschuett]

Is this the first of ten vendors types? Do I need a flag to enable the PowerPC vector type or does it also work on other architectures?

[tislam]

flang/include/flang/Common/Fortran.h

23

Thanks for the quick review and suggestion! We actually looked at both approaches at the beginning.
Adding a new TypeCategory for vector type seems to have less complexity and better separation of vector type from others.
Our implementation is trying to isolate the vector code as much as possible. It can be compiled out if it is desired.
Using the derived type wrapper approach seems to require code splitting when the specialized derived type is encountered to handle vector types.
That being said, we are definitely seeking more comments.

[DanielCChen]

In D146751#4219738, @tschuett wrote:

Is this the first of ten vendors types? Do I need a flag to enable the PowerPC vector type or does it also work on other architectures?

We have two more PowerPC opaque types coming, namely __VECTOR_PAIR and __VECTOR_QUAD, of 32 bytes and 64 bytes in length respectively. These vector and opaque types should only be enabled on PowerPC architecture, and disabled on other platforms.

[klausler]

Do any operations on these vector types need to be folded to constant values for use in constant expressions or specification expressions?

The syntax of the vector type specifications allows an element type to appear (e.g. VECTOR(INTEGER)). This design appears to discard the element type, treating the vector essentially as a typeless entity, so that this element type is not used or needed to select the right code to emit for an operation; the operations themselves are fully typed by the names of the intrinsic procedures, and the vector operands are just raw data to them. Do I have that right?

So you basically just need a container type with a fixed size so that you can declare vector objects and validate the operands to vector intrinsic procedures. You don't really have vector operations, apart from calls to new vector intrinsic procedures. And these vector types are not intended to be applicable to multiple target architectures, much less part of a future Fortran language standard.

(If on the other hand you wanted to distinguish a VECTOR(INTEGER) from a VECTOR(REAL) in the type system of the compiler and leverage those types to automatically insert conversion operations, the situation would be different.)

How close am I to understanding your situation?

[DanielCChen]

Thanks for the review and the comments!

In D146751#4221656, @klausler wrote:

Do any operations on these vector types need to be folded to constant values for use in constant expressions or specification expressions?

No. These vector types cannot be used in constant expr or specification expr, so there is no folding for it. The implementation in this patch intentionally avoids instantiating the Constant class for the vector type.

The syntax of the vector type specifications allows an element type to appear (e.g. VECTOR(INTEGER)). This design appears to discard the element type, treating the vector essentially as a typeless entity, so that this element type is not used or needed to select the right code to emit for an operation; the operations themselves are fully typed by the names of the intrinsic procedures, and the vector operands are just raw data to them. Do I have that right?

We support vector type assignment (e.g. v1 = v2), The element type and the KIND parameter must be the same for LHS and RHS. For example, VECTOR(INTEGER(4)) = VECTOR(INTEGER(8)) would be an invalid usage. So in the FE, the element type and its KIND parameter will be used for semantic checking (not included in this patch). We also support vector type arguments. The same constraint will be checked for actual arguments against the corresponding dummy arguments. In code gen, we will generate different IR depending on the element type and its KIND parameter. For example, global <8 x i16> for VECTOR(INTEGER(2)) and global <4 x i32> for VECTOR(INTEGER(4)). We also generate different IR for vector intrinsic functions (e.g add vs fadd for integer vs real for intrinsic function vec_add).

So you basically just need a container type with a fixed size so that you can declare vector objects and validate the operands to vector intrinsic procedures. You don't really have vector operations, apart from calls to new vector intrinsic procedures. And these vector types are not intended to be applicable to multiple target architectures, much less part of a future Fortran language standard.

The vector type that has element type (integer, real or unsigned) is 16 bytes in length. The other two opaque vector types, __VECTOR_PAIR and __VECTOR_QUAD is 32 bytes and 64 bytes in length respectively although it doesn't not have any element types (e.g. __VECTOR_PAIR :: VP1). There is a different set of intrinsic functions that operate on these two opaque vector types. Our plan is to use a new vector type category in VectorTypeSpec for these two new types.

(If on the other hand you wanted to distinguish a VECTOR(INTEGER) from a VECTOR(REAL) in the type system of the compiler and leverage those types to automatically insert conversion operations, the situation would be different.)

How close am I to understanding your situation?

In the future, we also plan to add support for vector type derived type components and to have allocatable and pointer attributes on vector type objects.

[klausler]

Thank you so much for the detailed response to my questions.

As I see it, you have basically four alternatives: add Vector to the top level of the typing system (as in this patch); add Vector as an orthogonal attribute to the current types; add Vector as an object attribute (akin to VOLATILE); or add derived types or.a parameterized derived type to distinguish all of the possible vector types.

With Vector as a type category, or type or object attribute, you'll need to extend the procedure characterization module to handle compatibility checks with vector arguments; extend expression semantics to handle assignment compatibility checking; extend pointer assignment checking, if pointers to vectors are allowed; and a fair amount of work in the runtime to cope with I/O, interoperability, memory allocation, &c. Even where vectors are not permitted (formatted I/O? namelist? allocatables? I'm sorry that I don't know this extension better) you'll need to have stubs and asserts. And somebody is probably going to ask you to wrap some or all of this extension support with #ifdef or constexpr ifs.

Using derived types would have the smallest overall code footprint, I think, and you'd immediately get implementations of argument compatibility checking, assignment compatibility checks, I/O, debugging tables, and so on basically for free. It might complicate lowering a little, but using a PDT with a kind parameter would help that. You might have the problem of having vector features working automatically that you don't intend to support (pointers to vectors? user-defined I/O?) and might want to disable. For error messages of the best quality, and to get data alignment right, you'd probably want to extend the DerivedTypeSpec implementation to detect and handle vectors as special cases.

I'd like to encourage you to reconsider whether you could do this with derived types. I think it would result in significantly less work, less extension-specific code, and way fewer #ifdefs or constexpr ifs marbled throughout the compiler.

flang/runtime/type-info.cpp

52

RUNTIME_CHECK and RUNTIME_CRASH are how we assert and crash in the runtime.

[DanielCChen]

Thanks for the quick response!

In D146751#4224077, @klausler wrote:

Thank you so much for the detailed response to my questions.

As I see it, you have basically four alternatives: add Vector to the top level of the typing system (as in this patch); add Vector as an orthogonal attribute to the current types; add Vector as an object attribute (akin to VOLATILE); or add derived types or.a parameterized derived type to distinguish all of the possible vector types.

With Vector as a type category, or type or object attribute, you'll need to extend the procedure characterization module to handle compatibility checks with vector arguments; extend expression semantics to handle assignment compatibility checking; extend pointer assignment checking, if pointers to vectors are allowed; and a fair amount of work in the runtime to cope with I/O, interoperability, memory allocation, &c. Even where vectors are not permitted (formatted I/O? namelist? allocatables? I'm sorry that I don't know this extension better) you'll need to have stubs and asserts. And somebody is probably going to ask you to wrap some or all of this extension support with #ifdef or constexpr ifs.

Right. we currently have semantic checking for argument passing (from the operator(==)), but we do need to add code for assignment. We don't plan to support I/O for vector types.

Using derived types would have the smallest overall code footprint, I think, and you'd immediately get implementations of argument compatibility checking, assignment compatibility checks, I/O, debugging tables, and so on basically for free. It might complicate lowering a little, but using a PDT with a kind parameter would help that. You might have the problem of having vector features working automatically that you don't intend to support (pointers to vectors? user-defined I/O?) and might want to disable. For error messages of the best quality, and to get data alignment right, you'd probably want to extend the DerivedTypeSpec implementation to detect and handle vectors as special cases.

Is the following mapping something you have in mind? This is based on @jeanPerier 's suggestion.

vector(integer)     ->        type __builtin_ppc_intrinsic_vector(element_category, element_kind)
vector(real)                    integer, kind :: element_category, element_kind
vector(unsigned)                integer(16) :: storage
                              end type  

__vector_pair       ->        type __builtin_ppc_pair_vector
                                integer(16) :: storage1
                                integer(16) :: storage2
                              end type

__vector_quad       ->        type __builtin_ppc_quad_vector
                                integer(16) :: storage1
                                integer(16) :: storage2
                                integer(16) :: storage3
                                integer(16) :: storage4
                              end type

If so, what would be the best place to construct these derived types? They are not scoped (i.e. the definition should be global). I think the lowering should be OK as long as v1 = v2 is not expanded into v1%storage = v2%storage in FE.

I'd like to encourage you to reconsider whether you could do this with derived types. I think it would result in significantly less work, less extension-specific code, and way fewer #ifdefs or constexpr ifs marbled throughout the compiler.

[DanielCChen]

flang/runtime/type-info.cpp

52

Thanks! Good to know.

[DanielCChen]

@klausler @jeanPerier We have been looking into the derived type wrapper approach. Besides the question in my response to Peter's comments regarding if the derived types layout is OK to represent those 3 different vector types, I have another question of type compatibility checking.
Consider the following vector code:

module m1
vector(integer) :: v1
end module

module m2
vector(integer) :: v2
end module

program main
use m1
contains
subroutine sub()
use m2
v1 = v2
end subroutine
end program

With derived wrapper approach, we will get something like:

module m1
type __builtin_ppc_intrinsic_vector(element_category, element_kind)
integer, kind :: element_category, element_kind
integer(16) :: storage
end type
end module

module m2
type __builtin_ppc_intrinsic_vector(element_category, element_kind)
integer, kind :: element_category, element_kind
integer(16) :: storage
end type
end module

program main
use m1
type(__builtin_ppc_intrinsic_vector(1, 4)) :: v1
call sub()
contains
subroutine sub()
use m2
type(__builtin_ppc_intrinsic_vector(1, 4)) :: v2
v1 = v2
end subroutine
end program

Currently, it complains at v1 = v2 as their types are coming from different module. Is this something we could just simply 'skip' the semantic checking for the specialized derived type for vector? This also applies to the argument passing case.

[klausler]

In D146751#4227713, @DanielCChen wrote:

@klausler @jeanPerier We have been looking into the derived type wrapper approach. Besides the question in my response to Peter's comments regarding if the derived types layout is OK to represent those 3 different vector types, I have another question of type compatibility checking.
Consider the following vector code:

module m1
vector(integer) :: v1
end module

module m2
vector(integer) :: v2
end module

I recommend that you define "builtin" derived types in one intrinsic module -- perhaps the same one in which the PPC vector intrinsic procedure interfaces are defined -- and reference those derived type definitions via USE association.

[DanielCChen]

In D146751#4227734, @klausler wrote:

In D146751#4227713, @DanielCChen wrote:

@klausler @jeanPerier We have been looking into the derived type wrapper approach. Besides the question in my response to Peter's comments regarding if the derived types layout is OK to represent those 3 different vector types, I have another question of type compatibility checking.
Consider the following vector code:

module m1
vector(integer) :: v1
end module

module m2
vector(integer) :: v2
end module

I recommend that you define "builtin" derived types in one intrinsic module -- perhaps the same one in which the PPC vector intrinsic procedure interfaces are defined -- and reference those derived type definitions via USE association.

Ok. I see. Thanks for the pointer!

[DanielCChen]

Close this review as a different implementation that uses derived type wrapper approach has been landed.

flang/include/flang/Common/Fortran-features.h

ENUM_CLASS(LanguageFeature, BackslashEscapes, OldDebugLines,
     Assign, AssignedGOTO, Pause, OpenACC, OpenMP, CruftAfterAmpersand,
     ClassicCComments, AdditionalFormats, BigIntLiterals, RealDoControls,
     EquivalenceNumericWithCharacter, EquivalenceNonDefaultNumeric,
     EquivalenceSameNonSequence, AdditionalIntrinsics, AnonymousParents,
     OldLabelDoEndStatements, LogicalIntegerAssignment, EmptySourceFile,
     ProgramReturn, ImplicitNoneTypeNever, ImplicitNoneTypeAlways,
     ForwardRefImplicitNone, OpenAccessAppend, BOZAsDefaultInteger,
     DistinguishableSpecifics, DefaultSave, PointerInSeqType, NonCharacterFormat,
-    SaveMainProgram, SaveBigMainProgramVariables)
+    SaveMainProgram, SaveBigMainProgramVariables, Vector)
 
 using LanguageFeatures = EnumSet<LanguageFeature, LanguageFeature_enumSize>;
 
 class LanguageFeatureControl {
 public:
   LanguageFeatureControl() {
     // These features must be explicitly enabled by command line options.
     disable_.set(LanguageFeature::OldDebugLines);

flang/include/flang/Common/Fortran.h

 
 #include "idioms.h"
 #include <cinttypes>
 #include <vector>
 
 namespace Fortran::common {
 
 // Fortran has five kinds of intrinsic data types, plus the derived types.
-ENUM_CLASS(TypeCategory, Integer, Real, Complex, Character, Logical, Derived)
+ENUM_CLASS(TypeCategory, Integer, Real, Complex, Character, Logical, Derived,
+    Vector, // Extension
+)
+ENUM_CLASS(VectorElementCategory, Integer, Unsigned, Real)
 
 constexpr bool IsNumericTypeCategory(TypeCategory category) {
   return category == TypeCategory::Integer || category == TypeCategory::Real ||
       category == TypeCategory::Complex;
 }
 
 // Kinds of IMPORT statements. Default means IMPORT or IMPORT :: names.
 ENUM_CLASS(ImportKind, Default, Only, None, All)

flang/include/flang/Evaluate/expression.h

 public:
   using Result = SomeDerived;
   EVALUATE_UNION_CLASS_BOILERPLATE(Expr)
   std::variant<Constant<Result>, ArrayConstructor<Result>, StructureConstructor,
       Designator<Result>, FunctionRef<Result>, Parentheses<Result>>
       u;
 };
 
+template <> class Expr<SomeVector> : public ExpressionBase<SomeVector> {
+public:
+  using Result = SomeVector;
+  EVALUATE_UNION_CLASS_BOILERPLATE(Expr)
+  std::variant<Designator<Result>, FunctionRef<Result>> u;
+};
+
 // A polymorphic expression of known intrinsic type category, but dynamic
 // kind, represented as a discriminated union over Expr<Type<CAT, K>>
 // for each supported kind K in the category.
 template <TypeCategory CAT>
 class Expr<SomeKind<CAT>> : public ExpressionBase<SomeKind<CAT>> {
 public:
   using Result = SomeKind<CAT>;
   EVALUATE_UNION_CLASS_BOILERPLATE(Expr)
struct GenericAssignmentWrapper {
   explicit GenericAssignmentWrapper(std::optional<Assignment> &&x)
       : v{std::move(x)} {}
   ~GenericAssignmentWrapper();
   static void Deleter(GenericAssignmentWrapper *);
   std::optional<Assignment> v; // vacant if error
 };
 
 FOR_EACH_CATEGORY_TYPE(extern template class Expr, )
+FOR_VECTOR_TYPE(extern template class Expr, )
 FOR_EACH_TYPE_AND_KIND(extern template class ExpressionBase, )
+FOR_VECTOR_TYPE(extern template class ExpressionBase, )
 FOR_EACH_INTRINSIC_KIND(extern template class ArrayConstructorValues, )
 FOR_EACH_INTRINSIC_KIND(extern template class ArrayConstructor, )
 
 // Template instantiations to resolve these "extern template" declarations.
 #define INSTANTIATE_EXPRESSION_TEMPLATES \
   FOR_EACH_INTRINSIC_KIND(template class Expr, ) \
   FOR_EACH_CATEGORY_TYPE(template class Expr, ) \
+  FOR_VECTOR_TYPE(template class Expr, ) \
   FOR_EACH_INTEGER_KIND(template class Relational, ) \
   FOR_EACH_REAL_KIND(template class Relational, ) \
   FOR_EACH_CHARACTER_KIND(template class Relational, ) \
   template class Relational<SomeType>; \
   FOR_EACH_TYPE_AND_KIND(template class ExpressionBase, ) \
+  FOR_VECTOR_TYPE(template class ExpressionBase, ) \
   FOR_EACH_INTRINSIC_KIND(template class ArrayConstructorValues, ) \
   FOR_EACH_INTRINSIC_KIND(template class ArrayConstructor, )
 } // namespace Fortran::evaluate
 #endif // FORTRAN_EVALUATE_EXPRESSION_H_

flang/include/flang/Evaluate/tools.h

common::IfNoLvalue<std::optional<Expr<SomeType>>, WRAPPED> TypedWrapper(
   case TypeCategory::Character:
     return WrapperHelper<TypeCategory::Character, WRAPPER, WRAPPED>(
         dyType.kind(), std::move(x));
   case TypeCategory::Logical:
     return WrapperHelper<TypeCategory::Logical, WRAPPER, WRAPPED>(
         dyType.kind(), std::move(x));
   case TypeCategory::Derived:
     return AsGenericExpr(Expr<SomeDerived>{WRAPPER<SomeDerived>{std::move(x)}});
+  case TypeCategory::Vector:
+    return AsGenericExpr(Expr<SomeVector>{WRAPPER<SomeVector>{std::move(x)}});
   }
 }
 
 // GetLastSymbol() returns the rightmost symbol in an object or procedure
 // designator (which has perhaps been wrapped in an Expr<>), or a null pointer
 // when none is found.  It will return an ASSOCIATE construct entity's symbol
 // rather than descending into its expression.
 struct GetLastSymbolHelper

flang/include/flang/Evaluate/type.h

 #include <optional>
 #include <string>
 #include <type_traits>
 #include <variant>
 
 namespace Fortran::semantics {
 class DeclTypeSpec;
 class DerivedTypeSpec;
+class VectorTypeSpec;
 class ParamValue;
 class Symbol;
 bool IsDescriptor(const Symbol &);
 } // namespace Fortran::semantics
 
 namespace Fortran::evaluate {
 
 using common::TypeCategory;
public:
   }
   explicit constexpr DynamicType(
       const semantics::DerivedTypeSpec &dt, bool poly = false)
       : category_{TypeCategory::Derived}, derived_{&dt} {
     if (poly) {
       kind_ = ClassKind;
     }
   }
+  explicit constexpr DynamicType(const semantics::VectorTypeSpec &vt)
+      : category_{TypeCategory::Vector}, vector_{&vt} {}
   CONSTEXPR_CONSTRUCTORS_AND_ASSIGNMENTS(DynamicType)
 
   // A rare use case used for representing the characteristics of an
   // intrinsic function like REAL() that accepts a typeless BOZ literal
   // argument and for typeless pointers -- things that real user Fortran can't
   // do.
   static constexpr DynamicType TypelessIntrinsicArgument() {
     DynamicType result;
     result.category_ = TypeCategory::Integer;
     result.kind_ = TypelessKind;
     return result;
   }
 
   static constexpr DynamicType UnlimitedPolymorphic() {
     DynamicType result;
     result.category_ = TypeCategory::Derived;
     result.kind_ = ClassKind;
     result.derived_ = nullptr;
+    result.vector_ = nullptr;
     return result; // CLASS(*)
   }
 
   static constexpr DynamicType AssumedType() {
     DynamicType result;
     result.category_ = TypeCategory::Derived;
     result.kind_ = AssumedTypeKind;
     result.derived_ = nullptr;
+    result.vector_ = nullptr;
     return result; // TYPE(*)
   }
 
   // Comparison is deep -- type parameters are compared independently.
   bool operator==(const DynamicType &) const;
   bool operator!=(const DynamicType &that) const { return !(*this == that); }
 
   constexpr TypeCategory category() const { return category_; }
constexpr bool IsPolymorphic() const { // TYPE(*) or CLASS()
     return kind_ == ClassKind || IsAssumedType();
   }
   constexpr bool IsUnlimitedPolymorphic() const { // TYPE(*) or CLASS(*)
     return IsPolymorphic() && !derived_;
   }
   constexpr const semantics::DerivedTypeSpec &GetDerivedTypeSpec() const {
     return DEREF(derived_);
   }
+  constexpr const semantics::VectorTypeSpec &GetVectorTypeSpec() const {
+    return DEREF(vector_);
+  }
 
   bool RequiresDescriptor() const;
   bool HasDeferredTypeParameter() const;
 
   // 7.3.2.3 & 15.5.2.4 type compatibility.
   // x.IsTkCompatibleWith(y) is true if "x => y" or passing actual y to
   // dummy argument x would be valid.  Be advised, this is not a reflexive
   // relation.  Kind type parameters must match, but CHARACTER lengths
private:
   const semantics::ParamValue *charLengthParamValue_{nullptr};
 #if defined(_GLIBCXX_RELEASE) && _GLIBCXX_RELEASE == 7
   // GCC 7's optional<> lacks a constexpr operator=
   std::int64_t knownLength_{-1};
 #else
   std::optional<std::int64_t> knownLength_;
 #endif
   const semantics::DerivedTypeSpec *derived_{nullptr}; // TYPE(T), CLASS(T)
+  const semantics::VectorTypeSpec *vector_{nullptr}; // VECTOR(NumericType)
 };
 
 // Return the DerivedTypeSpec of a DynamicType if it has one.
 const semantics::DerivedTypeSpec *GetDerivedTypeSpec(const DynamicType &);
 const semantics::DerivedTypeSpec *GetDerivedTypeSpec(
     const std::optional<DynamicType> &);
 const semantics::DerivedTypeSpec *GetParentTypeSpec(
     const semantics::DerivedTypeSpec &);
 
 std::string DerivedTypeSpecAsFortran(const semantics::DerivedTypeSpec &);
+std::string VectorTypeSpecAsFortran(const semantics::VectorTypeSpec &);
 
 template <TypeCategory CATEGORY, int KIND = 0> struct TypeBase {
   static constexpr TypeCategory category{CATEGORY};
   static constexpr int kind{KIND};
   constexpr bool operator==(const TypeBase &) const { return true; }
   static constexpr DynamicType GetType() { return {category, kind}; }
   static std::string AsFortran() { return GetType().AsFortran(); }
 };
public:
   }
   bool operator==(const SomeKind &) const;
   std::string AsFortran() const;
 
 private:
   const semantics::DerivedTypeSpec *derivedTypeSpec_{nullptr};
 };
 
+template <> class SomeKind<TypeCategory::Vector> {
+public:
+  static constexpr TypeCategory category{TypeCategory::Vector};
+
+  constexpr explicit SomeKind(const semantics::VectorTypeSpec &vts)
+      : vectorTypeSpec_{&vts} {}
+  constexpr explicit SomeKind(const DynamicType &vt)
+      : SomeKind(vt.GetVectorTypeSpec()) {}
+  CONSTEXPR_CONSTRUCTORS_AND_ASSIGNMENTS(SomeKind)
+
+  constexpr DynamicType GetType() const {
+    return DynamicType{*vectorTypeSpec_};
+  }
+  const semantics::VectorTypeSpec &vectorTypeSpec() const {
+    CHECK(vectorTypeSpec_);
+    return *vectorTypeSpec_;
+  }
+  bool operator==(const SomeKind &) const;
+  std::string AsFortran() const;
+
+private:
+  const semantics::VectorTypeSpec *vectorTypeSpec_{nullptr};
+};
+
 using SomeInteger = SomeKind<TypeCategory::Integer>;
 using SomeReal = SomeKind<TypeCategory::Real>;
 using SomeComplex = SomeKind<TypeCategory::Complex>;
 using SomeCharacter = SomeKind<TypeCategory::Character>;
 using SomeLogical = SomeKind<TypeCategory::Logical>;
 using SomeDerived = SomeKind<TypeCategory::Derived>;
+using SomeVector = SomeKind<TypeCategory::Vector>;
 using SomeCategory = std::tuple<SomeInteger, SomeReal, SomeComplex,
-    SomeCharacter, SomeLogical, SomeDerived>;
+    SomeCharacter, SomeLogical, SomeDerived, SomeVector>;
 
 using AllTypes =
     common::CombineTuples<AllIntrinsicTypes, std::tuple<SomeDerived>>;
 
 template <typename T> using Scalar = typename std::decay_t<T>::Scalar;
 
 // When Scalar<T> is S, then TypeOf<S> is T.
 // TypeOf is implemented by scanning all supported types for a match

 #define FOR_EACH_CATEGORY_TYPE(PREFIX, SUFFIX) \
   PREFIX<SomeInteger> SUFFIX; \
   PREFIX<SomeReal> SUFFIX; \
   PREFIX<SomeComplex> SUFFIX; \
   PREFIX<SomeCharacter> SUFFIX; \
   PREFIX<SomeLogical> SUFFIX; \
   PREFIX<SomeDerived> SUFFIX; \
   PREFIX<SomeType> SUFFIX;
+
 #define FOR_EACH_TYPE_AND_KIND(PREFIX, SUFFIX) \
   FOR_EACH_INTRINSIC_KIND(PREFIX, SUFFIX) \
   FOR_EACH_CATEGORY_TYPE(PREFIX, SUFFIX)
+
+#define FOR_VECTOR_TYPE(PREFIX, SUFFIX) PREFIX<SomeVector> SUFFIX;
 } // namespace Fortran::evaluate
 #endif // FORTRAN_EVALUATE_TYPE_H_

flang/include/flang/Evaluate/variable.h

using MaybeSubstring =
           std::variant<Substring>, std::variant<>>;
   using MaybeComplexPart = std::conditional_t<T::category == TypeCategory::Real,
       std::variant<ComplexPart>, std::variant<>>;
   using Variant =
       common::CombineVariants<DataRefs, MaybeSubstring, MaybeComplexPart>;
 
 public:
   using Result = T;
-  static_assert(
-      IsSpecificIntrinsicType<Result> || std::is_same_v<Result, SomeDerived>);
+  static_assert(IsSpecificIntrinsicType<Result> ||
+      std::is_same_v<Result, SomeDerived> ||
+      std::is_same_v<Result, SomeVector>);
   EVALUATE_UNION_CLASS_BOILERPLATE(Designator)
   Designator(const DataRef &that) : u{common::CopyVariant<Variant>(that.u)} {}
   Designator(DataRef &&that)
       : u{common::MoveVariant<Variant>(std::move(that.u))} {}
 
   std::optional<DynamicType> GetType() const;
   int Rank() const;
   BaseObject GetBaseObject() const;

 
 private:
   NamedEntity base_;
   Field field_;
   int dimension_{0}; // zero-based
 };
 
 #define INSTANTIATE_VARIABLE_TEMPLATES \
-  FOR_EACH_SPECIFIC_TYPE(template class Designator, )
+  FOR_EACH_SPECIFIC_TYPE(template class Designator, ) \
+  FOR_VECTOR_TYPE(template class Designator, )
 } // namespace Fortran::evaluate
 #endif // FORTRAN_EVALUATE_VARIABLE_H_

flang/include/flang/Lower/AbstractConverter.h

public:
   virtual mlir::Type
   genType(Fortran::common::TypeCategory tc, int kind,
           llvm::ArrayRef<std::int64_t> lenParameters = std::nullopt) = 0;
   /// Generate the type from a DerivedTypeSpec.
   virtual mlir::Type genType(const Fortran::semantics::DerivedTypeSpec &) = 0;
   /// Generate the type from a Variable
   virtual mlir::Type genType(const pft::Variable &) = 0;
 
+  /// Generate the type from a VectorTypeSpec
+  virtual mlir::Type
+  genType(const Fortran::semantics::VectorTypeSpec &tySpec) = 0;
+
   /// Register a runtime derived type information object symbol to ensure its
   /// object will be generated as a global.
   virtual void registerRuntimeTypeInfo(mlir::Location loc,
                                        SymbolRef typeInfoSym) = 0;
 
   virtual void registerDispatchTableInfo(
       mlir::Location loc,
       const Fortran::semantics::DerivedTypeSpec *typeSpec) = 0;

flang/include/flang/Lower/ConvertType.h

 mlir::Type getFIRType(mlir::MLIRContext *ctxt, common::TypeCategory tc,
                       int kind, llvm::ArrayRef<LenParameterTy>);
 
 /// Get a FIR type for a derived type
 mlir::Type
 translateDerivedTypeToFIRType(Fortran::lower::AbstractConverter &,
                               const Fortran::semantics::DerivedTypeSpec &);
 
+/// Get a FIR type for a Vector type.
+mlir::Type
+translateVectorTypeToFIRType(Fortran::lower::AbstractConverter &,
+                             const Fortran::semantics::VectorTypeSpec &);
+
 /// Translate a SomeExpr to an mlir::Type.
 mlir::Type translateSomeExprToFIRType(Fortran::lower::AbstractConverter &,
                                       const SomeExpr &expr);
 
 /// Translate a Fortran::semantics::Symbol to an mlir::Type.
 mlir::Type translateSymbolToFIRType(Fortran::lower::AbstractConverter &,
                                     const SymbolRef symbol);
 

 template <typename T>
 class TypeBuilder {
 public:
   static mlir::Type genType(Fortran::lower::AbstractConverter &,
                             const Fortran::evaluate::FunctionRef<T> &);
 };
 using namespace evaluate;
 FOR_EACH_SPECIFIC_TYPE(extern template class TypeBuilder, )
+FOR_VECTOR_TYPE(extern template class TypeBuilder, )
 
 } // namespace lower
 } // namespace Fortran
 
 #endif // FORTRAN_LOWER_CONVERT_TYPE_H

flang/include/flang/Parser/dump-parse-tree.h

#include "llvm/Frontend/OpenMP/OMP.inc"
   NODE(parser, TypeParamSpec)
   NODE(parser, TypeParamValue)
   NODE(TypeParamValue, Deferred)
   NODE(parser, TypeSpec)
   NODE(parser, Union)
   NODE(Union, EndUnionStmt)
   NODE(Union, UnionStmt)
   NODE(parser, UnlockStmt)
+  NODE(parser, UnsignedTypeSpec)
   NODE(parser, UseStmt)
   NODE_ENUM(UseStmt, ModuleNature)
   NODE(parser, Value)
   NODE(parser, ValueStmt)
   NODE(parser, Variable)
+  NODE(parser, VectorTypeSpec)
+  NODE(parser, VectorElementType)
   NODE(parser, Verbatim)
   NODE(parser, Volatile)
   NODE(parser, VolatileStmt)
   NODE(parser, WaitSpec)
   NODE(parser, WaitStmt)
   NODE(parser, WhereBodyConstruct)
   NODE(parser, WhereConstruct)
   NODE(WhereConstruct, Elsewhere)

flang/include/flang/Parser/parse-tree.h

struct Logical {
     std::optional<KindSelector> kind;
   };
   EMPTY_CLASS(DoubleComplex);
   std::variant<IntegerTypeSpec, Real, DoublePrecision, Complex, Character,
       Logical, DoubleComplex>
       u;
 };
 
+// Extension: VECTOR type
+// VECTOR(integer-type-spec) | VECTOR(REAL [kind-selector]) |
+// VECTOR(UNSIGNED [kind-selector])
+WRAPPER_CLASS(UnsignedTypeSpec, std::optional<KindSelector>);
+struct VectorElementType {
+  UNION_CLASS_BOILERPLATE(VectorElementType);
+  VectorElementType(IntegerTypeSpec &&its) : u(std::move(its)) {}
+  VectorElementType(IntrinsicTypeSpec::Real &&r) : u(std::move(r)) {}
+  VectorElementType(UnsignedTypeSpec &&us) : u(std::move(us)) {}
+  std::variant<IntegerTypeSpec, IntrinsicTypeSpec::Real, UnsignedTypeSpec> u;
+};
+WRAPPER_CLASS(VectorTypeSpec, VectorElementType);
+
 // R755 type-param-spec -> [keyword =] type-param-value
 struct TypeParamSpec {
   TUPLE_CLASS_BOILERPLATE(TypeParamSpec);
   std::tuple<std::optional<Keyword>, TypeParamValue> t;
 };
 
 // R754 derived-type-spec -> type-name [(type-param-spec-list)]
 struct DerivedTypeSpec {
struct DeclarationTypeSpec {
   struct Class {
     BOILERPLATE(Class);
     Class(DerivedTypeSpec &&dt) : derived(std::move(dt)) {}
     DerivedTypeSpec derived;
   };
   EMPTY_CLASS(ClassStar);
   EMPTY_CLASS(TypeStar);
   WRAPPER_CLASS(Record, Name);
-  std::variant<IntrinsicTypeSpec, Type, Class, ClassStar, TypeStar, Record> u;
+  std::variant<IntrinsicTypeSpec, Type, Class, ClassStar, TypeStar, Record,
+      VectorTypeSpec>
+      u;
 };
 
 // R709 kind-param -> digit-string | scalar-int-constant-name
 struct KindParam {
   UNION_CLASS_BOILERPLATE(KindParam);
   std::variant<std::uint64_t, Scalar<Integer<Constant<Name>>>> u;
 };
 

flang/include/flang/Semantics/scope.h

public:
   const DeclTypeSpec *FindType(const DeclTypeSpec &) const;
   const DeclTypeSpec &MakeNumericType(TypeCategory, KindExpr &&kind);
   const DeclTypeSpec &MakeLogicalType(KindExpr &&kind);
   const DeclTypeSpec &MakeCharacterType(
       ParamValue &&length, KindExpr &&kind = KindExpr{0});
   DeclTypeSpec &MakeDerivedType(DeclTypeSpec::Category, DerivedTypeSpec &&);
   const DeclTypeSpec &MakeTypeStarType();
   const DeclTypeSpec &MakeClassStarType();
+  const DeclTypeSpec &MakeVectorType(VectorElementCategory, KindExpr &&kind);
   const DeclTypeSpec *GetType(const SomeExpr &);
 
   std::size_t size() const { return size_; }
   void set_size(std::size_t size) { size_ = size; }
   std::optional<std::size_t> alignment() const { return alignment_; }
 
   void SetAlignment(std::size_t n) {
     alignment_ = std::max(alignment_.value_or(0), n);

flang/include/flang/Semantics/semantics.h

public:
   }
   SemanticsContext &set_anyDefinedIntrinsicOperator(bool yes = true) {
     anyDefinedIntrinsicOperator_ = yes;
     return *this;
   }
 
   const DeclTypeSpec &MakeNumericType(TypeCategory, int kind = 0);
   const DeclTypeSpec &MakeLogicalType(int kind = 0);
+  const DeclTypeSpec &MakeVectorType(VectorElementCategory, int kind = 0);
 
   bool AnyFatalError() const;
 
   // Test or set the Error flag on a Symbol
   bool HasError(const Symbol &);
   bool HasError(const Symbol *);
   bool HasError(const parser::Name &);
   void SetError(const Symbol &, bool = true);

flang/include/flang/Semantics/type.h

 using TypeCategory = common::TypeCategory;
 using SomeExpr = evaluate::Expr<evaluate::SomeType>;
 using MaybeExpr = std::optional<SomeExpr>;
 using SomeIntExpr = evaluate::Expr<evaluate::SomeInteger>;
 using MaybeIntExpr = std::optional<SomeIntExpr>;
 using SubscriptIntExpr = evaluate::Expr<evaluate::SubscriptInteger>;
 using MaybeSubscriptIntExpr = std::optional<SubscriptIntExpr>;
 using KindExpr = SubscriptIntExpr;
+using VectorElementCategory = common::VectorElementCategory;
 
 // An array spec bound: an explicit integer expression, assumed size
 // or implied shape(*), or assumed or deferred shape(:).  In the absence
 // of explicit lower bounds it is not possible to distinguish assumed
 // shape bounds from deferred shape bounds without knowing whether the
 // particular symbol is an allocatable/pointer or a non-allocatable
 // non-pointer dummy; use the symbol-based predicates for those
 // determinations.
private:
   bool RawEquals(const DerivedTypeSpec &that) const {
     return &typeSymbol_ == &that.typeSymbol_ && cooked_ == that.cooked_ &&
         rawParameters_ == that.rawParameters_;
   }
   friend llvm::raw_ostream &operator<<(
       llvm::raw_ostream &, const DerivedTypeSpec &);
 };
 
+class VectorTypeSpec {
+public:
+  VectorTypeSpec(VectorElementCategory pVectorElemCategory, KindExpr &&pKind);
+
+  bool operator==(const VectorTypeSpec &x) const {
+    return vectorElementCategory_ == x.vectorElementCategory() &&
+        vectorElementKind_ == x.vectorElementKind();
+  }
+  bool operator!=(const VectorTypeSpec &x) const { return !operator==(x); }
+  VectorElementCategory vectorElementCategory() const {
+    return vectorElementCategory_;
+  }
+  int vectorElementKind() const { return vectorElementKind_; }
+  int vectorAlignment() const { return vectorAlignment_; }
+  int vectorLenInBytes() const { return vectorLenInBytes_; }
+  std::string AsFortran() const;
+
+  static TypeCategory elementTypeCatToIntrinsicTypeCat(
+      VectorElementCategory cat) {
+    switch (cat) {
+      SWITCH_COVERS_ALL_CASES
+    case VectorElementCategory::Integer:
+    case VectorElementCategory::Unsigned:
+      return TypeCategory::Integer;
+    case VectorElementCategory::Real:
+      return TypeCategory::Real;
+    }
+  }
+
+private:
+  VectorElementCategory vectorElementCategory_;
+  int vectorElementKind_;
+  static const int vectorLenInBytes_ = 16;
+  static const int vectorAlignment_ = 16;
+};
+
 class DeclTypeSpec {
 public:
   enum Category {
     Numeric,
     Logical,
     Character,
     TypeDerived,
     ClassDerived,
     TypeStar,
-    ClassStar
+    ClassStar,
+    Vector
   };
 
   // intrinsic-type-spec or TYPE(intrinsic-type-spec), not character
   DeclTypeSpec(NumericTypeSpec &&);
   DeclTypeSpec(LogicalTypeSpec &&);
   // character
   DeclTypeSpec(const CharacterTypeSpec &);
   DeclTypeSpec(CharacterTypeSpec &&);
   // TYPE(derived-type-spec) or CLASS(derived-type-spec)
   DeclTypeSpec(Category, const DerivedTypeSpec &);
   DeclTypeSpec(Category, DerivedTypeSpec &&);
   // TYPE(*) or CLASS(*)
   DeclTypeSpec(Category);
+  // Extension: VECTOR type
+  DeclTypeSpec(VectorTypeSpec &&);
 
   bool operator==(const DeclTypeSpec &) const;
   bool operator!=(const DeclTypeSpec &that) const { return !operator==(that); }
 
   Category category() const { return category_; }
   void set_category(Category category) { category_ = category; }
   bool IsPolymorphic() const {
     return category_ == ClassDerived || IsUnlimitedPolymorphic();
public:
   const DerivedTypeSpec &derivedTypeSpec() const {
     CHECK(category_ == TypeDerived || category_ == ClassDerived);
     return std::get<DerivedTypeSpec>(typeSpec_);
   }
   DerivedTypeSpec &derivedTypeSpec() {
     CHECK(category_ == TypeDerived || category_ == ClassDerived);
     return std::get<DerivedTypeSpec>(typeSpec_);
   }
+  const VectorTypeSpec &vectorTypeSpec() const {
+    CHECK(category_ == Vector);
+    return std::get<VectorTypeSpec>(typeSpec_);
+  }
 
   inline IntrinsicTypeSpec *AsIntrinsic();
   inline const IntrinsicTypeSpec *AsIntrinsic() const;
   inline DerivedTypeSpec *AsDerived();
   inline const DerivedTypeSpec *AsDerived() const;
+  inline VectorTypeSpec *AsVector();
+  inline const VectorTypeSpec *AsVector() const;
 
   std::string AsFortran() const;
 
 private:
   Category category_;
   std::variant<std::monostate, NumericTypeSpec, LogicalTypeSpec,
-      CharacterTypeSpec, DerivedTypeSpec>
+      CharacterTypeSpec, DerivedTypeSpec, VectorTypeSpec>
       typeSpec_;
 };
 llvm::raw_ostream &operator<<(llvm::raw_ostream &, const DeclTypeSpec &);
 
 // Define some member functions here in the header so that they can be used by
 // lib/Evaluate without link-time dependency on Semantics.
 
 inline bool ArraySpec::IsExplicitShape() const {
default:
     return nullptr;
   }
 }
 inline const DerivedTypeSpec *DeclTypeSpec::AsDerived() const {
   return const_cast<DeclTypeSpec *>(this)->AsDerived();
 }
 
 bool IsInteroperableIntrinsicType(const DeclTypeSpec &);
+inline VectorTypeSpec *DeclTypeSpec::AsVector() {
+  switch (category_) {
+  case Vector:
+    return &std::get<VectorTypeSpec>(typeSpec_);
+  default:
+    return nullptr;
+  }
+}
+inline const VectorTypeSpec *DeclTypeSpec::AsVector() const {
+  return const_cast<DeclTypeSpec *>(this)->AsVector();
+}
 
 } // namespace Fortran::semantics
 #endif // FORTRAN_SEMANTICS_TYPE_H_

flang/lib/Evaluate/expression.cpp

 bool Expr<SomeKind<CAT>>::operator==(const Expr<SomeKind<CAT>> &that) const {
   return u == that.u;
 }
 
 bool Expr<SomeDerived>::operator==(const Expr<SomeDerived> &that) const {
   return u == that.u;
 }
 
+bool Expr<SomeVector>::operator==(const Expr<SomeVector> &that) const {
+  return u == that.u;
+}
+
 bool Expr<SomeCharacter>::operator==(const Expr<SomeCharacter> &that) const {
   return u == that.u;
 }
 
 bool Expr<SomeType>::operator==(const Expr<SomeType> &that) const {
   return u == that.u;
 }
 

flang/lib/Evaluate/fold-implementation.h

 template <typename T>
 Expr<T> ExpressionBase<T>::Rewrite(FoldingContext &context, Expr<T> &&expr) {
   return common::visit(
       [&](auto &&x) -> Expr<T> {
         if constexpr (IsSpecificIntrinsicType<T>) {
           return FoldOperation(context, std::move(x));
         } else if constexpr (std::is_same_v<T, SomeDerived>) {
           return FoldOperation(context, std::move(x));
+        } else if constexpr (std::is_same_v<T, SomeVector>) {
+          return std::move(expr);
         } else if constexpr (common::HasMember<decltype(x),
                                  TypelessExpression>) {
           return std::move(expr);
         } else {
           return Expr<T>{Fold(context, std::move(x))};
         }
       },
       std::move(expr.u));
 }
 
 FOR_EACH_TYPE_AND_KIND(extern template class ExpressionBase, )
 } // namespace Fortran::evaluate
 #endif // FORTRAN_EVALUATE_FOLD_IMPLEMENTATION_H_

flang/lib/Evaluate/fold.cpp

if (totalBytes < std::size_t{1000000} &&
       return image.AsConstant(
           context, *moldType, moldLength, *extents, true /*pad with 0*/);
     }
   }
   return std::nullopt;
 }
 
 template class ExpressionBase<SomeDerived>;
+template class ExpressionBase<SomeVector>;
 template class ExpressionBase<SomeType>;
 
 } // namespace Fortran::evaluate

flang/lib/Evaluate/formatting.cpp

 std::string DynamicType::AsFortran() const {
   if (derived_) {
     CHECK(category_ == TypeCategory::Derived);
     std::string result{DerivedTypeSpecAsFortran(*derived_)};
     if (IsPolymorphic()) {
       result = "CLASS("s + result + ')';
     }
     return result;
+  } else if (vector_) {
+    CHECK(category_ == TypeCategory::Vector);
+    std::string result{VectorTypeSpecAsFortran(*vector_)};
+    return result;
   } else if (charLengthParamValue_ || knownLength()) {
     std::string result{"CHARACTER(KIND="s + std::to_string(kind_) + ",LEN="};
     if (knownLength()) {
       result += std::to_string(*knownLength()) + "_8";
     } else if (charLengthParamValue_->isAssumed()) {
       result += '*';
     } else if (charLengthParamValue_->isDeferred()) {
       result += ':';
for (const auto &[name, value] : spec.parameters()) {
     }
   }
   if (ch != '(') {
     ss << ')';
   }
   return ss.str();
 }
 
+std::string SomeVector::AsFortran() const {
+  return "VECTOR("s + VectorTypeSpecAsFortran(vectorTypeSpec()) + ')';
+}
+
+std::string VectorTypeSpecAsFortran(const semantics::VectorTypeSpec &spec) {
+  int kind = spec.vectorElementKind();
+  return parser::ToUpperCaseLetters(
+             EnumToString(spec.vectorElementCategory())) +
+      '(' + std::to_string(kind) + ')';
+}
+
 llvm::raw_ostream &EmitVar(llvm::raw_ostream &o, const Symbol &symbol) {
   return o << symbol.name().ToString();
 }
 
 llvm::raw_ostream &EmitVar(llvm::raw_ostream &o, const std::string &lit) {
   return o << parser::QuoteCharacterLiteral(lit);
 }
 

flang/lib/Evaluate/target.cpp

 //===-- lib/Semantics/target.cpp ------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Evaluate/target.h"
 #include "flang/Common/template.h"
 #include "flang/Evaluate/common.h"
 #include "flang/Evaluate/type.h"
+#include "flang/Semantics/type.h"
 
 namespace Fortran::evaluate {
 
 Rounding TargetCharacteristics::defaultRounding;
 
 TargetCharacteristics::TargetCharacteristics() {
   auto enableCategoryKinds{[this](TypeCategory category) {
     for (int kind{0}; kind < maxKind; ++kind) {

flang/lib/Evaluate/tools.cpp

 Expr<SomeType> Parenthesize(Expr<SomeType> &&expr) {
   return common::visit(
       [&](auto &&x) {
         using T = std::decay_t<decltype(x)>;
         if constexpr (common::HasMember<T, TypelessExpression>) {
           return expr; // no parentheses around typeless
         } else if constexpr (std::is_same_v<T, Expr<SomeDerived>>) {
           return AsGenericExpr(Parentheses<SomeDerived>{std::move(x)});
+        } else if constexpr (std::is_same_v<T, Expr<SomeVector>>) {
+          return expr; // no parentheses around Vector Type
         } else {
           return common::visit(
               [](auto &&y) {
                 using T = ResultType<decltype(y)>;
                 return AsGenericExpr(Parentheses<T>{std::move(y)});
               },
               std::move(x.u));
         }
return common::visit(
             messages.Say("LOGICAL cannot be negated"_err_en_US);
             return NoExpr();
           },
           [&](Expr<SomeDerived> &&) {
             // TODO: defined operator
             messages.Say("Operand cannot be negated"_err_en_US);
             return NoExpr();
           },
+          [&](Expr<SomeVector> &&) {
+            messages.Say("VECTOR cannot be negated"_err_en_US);
+            return NoExpr();
+          },
       },
       std::move(x.u));
 }
 
 Expr<SomeLogical> LogicalNegation(Expr<SomeLogical> &&x) {
   return common::visit(
       [](auto &&xk) { return AsCategoryExpr(LogicalNegation(std::move(xk))); },
       std::move(x.u));
case TypeCategory::Derived:
     if (auto fromType{x.GetType()}) {
       if (type.IsTkCompatibleWith(*fromType)) {
         // "x" could be assigned or passed to "type", or appear in a
         // structure constructor as a value for a component with "type"
         return std::move(x);
       }
     }
     break;
+  case TypeCategory::Vector:
+    // No type conversion for Vector types.
+    return std::nullopt;
   }
   return std::nullopt;
 }
 
 std::optional<Expr<SomeType>> ConvertToType(
     const DynamicType &to, std::optional<Expr<SomeType>> &&x) {
   if (x) {
     return ConvertToType(to, std::move(*x));

flang/lib/Evaluate/type.cpp

 }
 
 std::size_t DynamicType::GetAlignment(
     const TargetCharacteristics &targetCharacteristics) const {
   if (category_ == TypeCategory::Derived) {
     if (derived_ && derived_->scope()) {
       return derived_->scope()->alignment().value_or(1);
     }
+  } else if (category_ == TypeCategory::Vector) {
+    return vector_->vectorAlignment();
   } else {
     return targetCharacteristics.GetAlignment(category_, kind_);
   }
   return 1; // needs to be after switch to dodge a bogus gcc warning
 }
 
 std::optional<Expr<SubscriptInteger>> DynamicType::MeasureSizeInBytes(
     FoldingContext &context, bool aligned,
case TypeCategory::Derived:
     if (!IsPolymorphic() && derived_ && derived_->scope()) {
       auto size{derived_->scope()->size()};
       auto align{aligned ? derived_->scope()->alignment().value_or(0) : 0};
       auto alignedSize{align > 0 ? ((size + align - 1) / align) * align : size};
       return Expr<SubscriptInteger>{
           static_cast<ConstantSubscript>(alignedSize)};
     }
     break;
+  case TypeCategory::Vector:
+    auto size{vector_->vectorLenInBytes()};
+    return Expr<SubscriptInteger>{size};
   }
   return std::nullopt;
 }
 
 bool DynamicType::IsAssumedLengthCharacter() const {
   return category_ == TypeCategory::Character && charLengthParamValue_ &&
       charLengthParamValue_->isAssumed();
 }
if (x.IsUnlimitedPolymorphic()) {
     return false;
   } else if (x.category() != y.category()) {
     return false;
   } else if (x.category() == TypeCategory::Character) {
     const auto xLen{x.knownLength()};
     const auto yLen{y.knownLength()};
     return x.kind() == y.kind() &&
         (ignoreLengths || !xLen || !yLen || *xLen == *yLen);
+  } else if (x.category() == TypeCategory::Vector) {
+    return x.GetVectorTypeSpec() == y.GetVectorTypeSpec();
   } else if (x.category() != TypeCategory::Derived) {
     return x.kind() == y.kind();
   } else {
     const auto *xdt{GetDerivedTypeSpec(x)};
     const auto *ydt{GetDerivedTypeSpec(y)};
     return AreCompatibleDerivedTypes(
         xdt, ydt, x.IsPolymorphic(), ignoreTypeParameterValues, false);
   }
if (const auto *intrinsic{type.AsIntrinsic()}) {
     }
   } else if (const auto *derived{type.AsDerived()}) {
     return DynamicType{
         *derived, type.category() == semantics::DeclTypeSpec::ClassDerived};
   } else if (type.category() == semantics::DeclTypeSpec::ClassStar) {
     return DynamicType::UnlimitedPolymorphic();
   } else if (type.category() == semantics::DeclTypeSpec::TypeStar) {
     return DynamicType::AssumedType();
+  } else if (const auto *vectorType{type.AsVector()}) {
+    return DynamicType{*vectorType};
   } else {
     common::die("DynamicType::From(DeclTypeSpec): failed");
   }
   return std::nullopt;
 }
 
 std::optional<DynamicType> DynamicType::From(const semantics::Symbol &symbol) {
   return From(symbol.GetType()); // Symbol -> DeclTypeSpec -> DynamicType

flang/lib/Lower/Bridge.cpp

public:
   genType(const Fortran::semantics::DerivedTypeSpec &tySpec) override final {
     return Fortran::lower::translateDerivedTypeToFIRType(*this, tySpec);
   }
   mlir::Type genType(Fortran::common::TypeCategory tc) override final {
     return Fortran::lower::getFIRType(
         &getMLIRContext(), tc, bridge.getDefaultKinds().GetDefaultKind(tc),
         std::nullopt);
   }
+  mlir::Type
+  genType(const Fortran::semantics::VectorTypeSpec &tySpec) override final {
+    return Fortran::lower::translateVectorTypeToFIRType(*this, tySpec);
+  }
 
   bool createHostAssociateVarClone(
       const Fortran::semantics::Symbol &sym) override final {
     mlir::Location loc = genLocation(sym.name());
     mlir::Type symType = genType(sym);
     const auto *details = sym.detailsIf<Fortran::semantics::HostAssocDetails>();
     assert(details && "No host-association found");
     const Fortran::semantics::Symbol &hsym = details->symbol();
static bool isLogicalCategory(Fortran::common::TypeCategory cat) {
     return cat == Fortran::common::TypeCategory::Logical;
   }
   static bool isCharacterCategory(Fortran::common::TypeCategory cat) {
     return cat == Fortran::common::TypeCategory::Character;
   }
   static bool isDerivedCategory(Fortran::common::TypeCategory cat) {
     return cat == Fortran::common::TypeCategory::Derived;
   }
+  static bool isVectorCategory(Fortran::common::TypeCategory cat) {
+    return cat == Fortran::common::TypeCategory::Vector;
+  }
 
   /// Insert a new block before \p block. Leave the insertion point unchanged.
   mlir::Block *insertBlock(mlir::Block *block) {
     mlir::OpBuilder::InsertPoint insertPt = builder->saveInsertionPoint();
     mlir::Block *newBlock = builder->createBlock(block);
     builder->restoreInsertionPoint(insertPt);
     return newBlock;
   }
std::visit(
                 // See Fortran 2018 10.2.1.3 p5, p6, and p7
                 genArrayAssignment(assign, stmtCtx);
                 return;
               }
 
               // Scalar assignment
               const bool isNumericScalar =
                   isNumericScalarCategory(lhsType->category());
-              fir::ExtendedValue rhs = isNumericScalar
+              const bool isVector = isVectorCategory(lhsType->category());
+              fir::ExtendedValue rhs = (isNumericScalar || isVector)
                                            ? genExprValue(assign.rhs, stmtCtx)
                                            : genExprAddr(assign.rhs, stmtCtx);
               const bool lhsIsWholeAllocatable =
                   Fortran::lower::isWholeAllocatable(assign.lhs);
               std::optional<fir::factory::MutableBoxReallocation> lhsRealloc;
               std::optional<fir::MutableBoxValue> lhsMutableBox;
 
               // Set flag to know if the LHS needs finalization. Polymorphic,
std::visit(
                   lhsRealloc = fir::factory::genReallocIfNeeded(
                       *builder, loc, *lhsMutableBox,
                       /*shape=*/std::nullopt, lengthParams);
                   return lhsRealloc->newValue;
                 }
                 return genExprAddr(assign.lhs, stmtCtx);
               }();
 
-              if (isNumericScalar) {
+              if (isNumericScalar || isVector) {
                 // Fortran 2018 10.2.1.3 p8 and p9
                 // Conversions should have been inserted by semantic analysis,
                 // but they can be incorrect between the rhs and lhs. Correct
                 // that here.
                 mlir::Value addr = fir::getBase(lhs);
                 mlir::Value val = fir::getBase(rhs);
                 // A function with multiple entry points returning different
                 // types tags all result variables with one of the largest
                 // types to allow them to share the same storage. Assignment
                 // to a result variable of one of the other types requires
                 // conversion to the actual type.
                 mlir::Type toTy = genType(assign.lhs);
                 mlir::Value cast =
-                    builder->convertWithSemantics(loc, toTy, val);
+                    isVector ? val
+                             : builder->convertWithSemantics(loc, toTy, val);
                 if (fir::dyn_cast_ptrEleTy(addr.getType()) != toTy) {
                   assert(isFuncResultDesignator(assign.lhs) && "type mismatch");
                   addr = builder->createConvert(
                       toLocation(), builder->getRefType(toTy), addr);
                 }
                 builder->create<fir::StoreOp>(loc, cast, addr);
               } else if (isCharacterCategory(lhsType->category())) {
                 // Fortran 2018 10.2.1.3 p10 and p11

flang/lib/Lower/CallInterface.cpp

if (dynamicType.category() == Fortran::common::TypeCategory::Character) {
                Fortran::common::TypeCategory::Derived) {
       // Derived result need to be allocated by the caller and the result value
       // must be saved. Derived type in implicit interface cannot have length
       // parameters.
       setSaveResult();
       mlir::Type mlirType = translateDynamicType(dynamicType);
       addFirResult(mlirType, FirPlaceHolder::resultEntityPosition,
                    Property::Value);
+    } else if (dynamicType.category() ==
+               Fortran::common::TypeCategory::Vector) {
+      mlir::Type mlirType = translateDynamicType(dynamicType);
+      addFirResult(mlirType, FirPlaceHolder::resultEntityPosition,
+                   Property::Value);
     } else {
       // All result other than characters/derived are simply returned by value
       // in implicit interfaces
       mlir::Type mlirType =
           getConverter().genType(dynamicType.category(), dynamicType.kind());
       addFirResult(mlirType, FirPlaceHolder::resultEntityPosition,
                    Property::Value);
     }
if (cat == Fortran::common::TypeCategory::Derived) {
         return mlir::NoneType::get(&mlirContext);
       return getConverter().genType(dynamicType.GetDerivedTypeSpec());
     }
     // CHARACTER with compile time constant length.
     if (cat == Fortran::common::TypeCategory::Character)
       if (std::optional<std::int64_t> constantLen =
               toInt64(dynamicType.GetCharLength()))
         return getConverter().genType(cat, dynamicType.kind(), {*constantLen});
+
+    if (cat == Fortran::common::TypeCategory::Vector) {
+      return getConverter().genType(dynamicType.GetVectorTypeSpec());
+    }
     // INTEGER, REAL, LOGICAL, COMPLEX, and CHARACTER with dynamic length.
     return getConverter().genType(cat, dynamicType.kind());
   }
 
   void handleExplicitDummy(
       const DummyCharacteristics *characteristics,
       const Fortran::evaluate::characteristics::DummyDataObject &obj,
       const FortranEntity &entity, bool isBindC) {

flang/lib/Lower/ConvertConstant.cpp

genConstantValue(Fortran::lower::AbstractConverter &converter,
   return std::visit(
       [&](const auto &x) -> fir::ExtendedValue {
         using T = std::decay_t<decltype(x)>;
         if constexpr (Fortran::common::HasMember<
                           T, Fortran::lower::CategoryExpression>) {
           if constexpr (T::Result::category ==
                         Fortran::common::TypeCategory::Derived) {
             return genConstantValue(converter, loc, x);
+          } else if constexpr (T::Result::category ==
+                               Fortran::common::TypeCategory::Vector) {
+            fir::emitFatalError(loc, "unexpected Vector constant value");
           } else {
             return std::visit(
                 [&](const auto &preciseKind) {
                   return genConstantValue(converter, loc, preciseKind);
                 },
                 x.u);
           }
         } else {

flang/lib/Lower/ConvertExpr.cpp

ExtValue gen(const Fortran::evaluate::Designator<A> &des) {
     return std::visit([&](const auto &x) { return gen(x); }, des.u);
   }
   template <typename A>
   ExtValue genval(const Fortran::evaluate::Designator<A> &des) {
     return std::visit([&](const auto &x) { return genval(x); }, des.u);
   }
 
   mlir::Type genType(const Fortran::evaluate::DynamicType &dt) {
-    if (dt.category() != Fortran::common::TypeCategory::Derived)
-      return converter.genType(dt.category(), dt.kind());
+    if (dt.category() == Fortran::common::TypeCategory::Derived) {
       if (dt.IsUnlimitedPolymorphic())
         return mlir::NoneType::get(&converter.getMLIRContext());
       return converter.genType(dt.GetDerivedTypeSpec());
+    } else if (dt.category() == Fortran::common::TypeCategory::Vector) {
+      return converter.genType(dt.GetVectorTypeSpec());
+    } else {
+      return converter.genType(dt.category(), dt.kind());
+    }
   }
 
   /// Lower a function reference
   template <typename A>
   ExtValue genFunctionRef(const Fortran::evaluate::FunctionRef<A> &funcRef) {
     if (!funcRef.GetType().has_value())
       fir::emitFatalError(getLoc(), "a function must have a type");
     mlir::Type resTy = genType(*funcRef.GetType());

flang/lib/Lower/ConvertType.cpp

 #include "flang/Semantics/tools.h"
 #include "flang/Semantics/type.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "llvm/Support/Debug.h"
 
 #define DEBUG_TYPE "flang-lower-type"
 
+using Fortran::common::VectorElementCategory;
+
 //===--------------------------------------------------------------------===//
 // Intrinsic type translation helpers
 //===--------------------------------------------------------------------===//
 
 static mlir::Type genRealType(mlir::MLIRContext *context, int kind) {
   if (Fortran::evaluate::IsValidKindOfIntrinsicType(
           Fortran::common::TypeCategory::Real, kind)) {
     switch (kind) {
static mlir::Type genRealType(mlir::MLIRContext *context, int kind) {
   llvm_unreachable("REAL type translation not implemented");
 }
 
 template <int KIND>
 int getIntegerBits() {
   return Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer,
                                  KIND>::Scalar::bits;
 }
-static mlir::Type genIntegerType(mlir::MLIRContext *context, int kind) {
+static mlir::Type genIntegerType(mlir::MLIRContext *context, int kind,
+                                 bool isUnsigned = false) {
   if (Fortran::evaluate::IsValidKindOfIntrinsicType(
           Fortran::common::TypeCategory::Integer, kind)) {
+    mlir::IntegerType::SignednessSemantics signedness =
+        (isUnsigned ? mlir::IntegerType::SignednessSemantics::Unsigned
+                    : mlir::IntegerType::SignednessSemantics::Signless);
     switch (kind) {
     case 1:
-      return mlir::IntegerType::get(context, getIntegerBits<1>());
+      return mlir::IntegerType::get(context, getIntegerBits<1>(), signedness);
     case 2:
-      return mlir::IntegerType::get(context, getIntegerBits<2>());
+      return mlir::IntegerType::get(context, getIntegerBits<2>(), signedness);
     case 4:
-      return mlir::IntegerType::get(context, getIntegerBits<4>());
+      return mlir::IntegerType::get(context, getIntegerBits<4>(), signedness);
     case 8:
-      return mlir::IntegerType::get(context, getIntegerBits<8>());
+      return mlir::IntegerType::get(context, getIntegerBits<8>(), signedness);
     case 16:
-      return mlir::IntegerType::get(context, getIntegerBits<16>());
+      return mlir::IntegerType::get(context, getIntegerBits<16>(), signedness);
     }
   }
   llvm_unreachable("INTEGER kind not translated");
 }
 
 static mlir::Type genLogicalType(mlir::MLIRContext *context, int KIND) {
   if (Fortran::evaluate::IsValidKindOfIntrinsicType(
           Fortran::common::TypeCategory::Logical, KIND))
mlir::Type genExprType(const A &expr) {
     mlir::Type baseType;
     bool isPolymorphic = (dynamicType->IsPolymorphic() ||
                           dynamicType->IsUnlimitedPolymorphic()) &&
                          !dynamicType->IsAssumedType();
     if (dynamicType->IsUnlimitedPolymorphic()) {
       baseType = mlir::NoneType::get(context);
     } else if (category == Fortran::common::TypeCategory::Derived) {
       baseType = genDerivedType(dynamicType->GetDerivedTypeSpec());
+    } else if (category == Fortran::common::TypeCategory::Vector) {
+      baseType = genVectorType(dynamicType->GetVectorTypeSpec());
     } else {
       // LOGICAL, INTEGER, REAL, COMPLEX, CHARACTER
       llvm::SmallVector<Fortran::lower::LenParameterTy> params;
       translateLenParameters(params, category, expr);
       baseType = genFIRType(context, category, dynamicType->kind(), params);
     }
     std::optional<Fortran::evaluate::Shape> shapeExpr =
         Fortran::evaluate::GetShape(converter.getFoldingContext(), expr);
if (const Fortran::semantics::DeclTypeSpec *type = ultimate.GetType()) {
                  !converter.getLoweringOptions().getPolymorphicTypeImpl()) {
         // TODO is kept under experimental flag until feature is complete.
         TODO(loc, "support for polymorphic types");
       } else if (type->IsUnlimitedPolymorphic()) {
         ty = mlir::NoneType::get(context);
       } else if (const Fortran::semantics::DerivedTypeSpec *tySpec =
                      type->AsDerived()) {
         ty = genDerivedType(*tySpec);
+      } else if (const Fortran::semantics::VectorTypeSpec *tySpec =
+                     type->AsVector()) {
+        ty = genVectorType(*tySpec);
       } else {
         fir::emitFatalError(loc, "symbol's type must have a type spec");
       }
     } else {
       fir::emitFatalError(loc, "symbol must have a type");
     }
     bool isPolymorphic = (Fortran::semantics::IsPolymorphic(symbol) ||
                           Fortran::semantics::IsUnlimitedPolymorphic(symbol)) &&
mlir::Type genDerivedType(const Fortran::semantics::DerivedTypeSpec &tySpec) {
     if (const Fortran::semantics::Scope *derivedScope =
             tySpec.scope() ? tySpec.scope() : tySpec.typeSymbol().scope())
       if (const Fortran::semantics::Symbol *typeInfoSym =
               derivedScope->runtimeDerivedTypeDescription())
         converter.registerRuntimeTypeInfo(loc, *typeInfoSym);
     return rec;
   }
 
+  mlir::Type genVectorType(const Fortran::semantics::VectorTypeSpec &tySpec) {
+    int64_t kind = tySpec.vectorElementKind();
+    if (!kind) {
+      llvm::report_fatal_error("Unspecified kind for vector element type");
+    }
+    int64_t noOfElements = tySpec.vectorLenInBytes() / kind;
+    switch (tySpec.vectorElementCategory()) {
+    case VectorElementCategory::Integer:
+      return fir::VectorType::get(noOfElements, genIntegerType(context, kind));
+    case VectorElementCategory::Unsigned:
+      return fir::VectorType::get(noOfElements,
+                                  genIntegerType(context, kind, true));
+    case VectorElementCategory::Real:
+      return fir::VectorType::get(noOfElements, genRealType(context, kind));
+    }
+    llvm_unreachable("Vector element type not implemented");
+  }
+
   // To get the character length from a symbol, make an fold a designator for
   // the symbol to cover the case where the symbol is an assumed length named
   // constant and its length comes from its init expression length.
   template <int Kind>
   fir::SequenceType::Extent
   getCharacterLengthHelper(const Fortran::semantics::Symbol &symbol) {
     using TC =
         Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, Kind>;

 }
 
 mlir::Type Fortran::lower::translateDerivedTypeToFIRType(
     Fortran::lower::AbstractConverter &converter,
     const Fortran::semantics::DerivedTypeSpec &tySpec) {
   return TypeBuilderImpl{converter}.genDerivedType(tySpec);
 }
 
+mlir::Type Fortran::lower::translateVectorTypeToFIRType(
+    Fortran::lower::AbstractConverter &converter,
+    const Fortran::semantics::VectorTypeSpec &tySpec) {
+  return TypeBuilderImpl{converter}.genVectorType(tySpec);
+}
+
 mlir::Type Fortran::lower::translateSomeExprToFIRType(
     Fortran::lower::AbstractConverter &converter, const SomeExpr &expr) {
   return TypeBuilderImpl{converter}.genExprType(expr);
 }
 
 mlir::Type Fortran::lower::translateSymbolToFIRType(
     Fortran::lower::AbstractConverter &converter, const SymbolRef symbol) {
   return TypeBuilderImpl{converter}.genSymbolType(symbol);
mlir::Type Fortran::lower::TypeBuilder<T>::genType(
     Fortran::lower::AbstractConverter &converter,
     const Fortran::evaluate::FunctionRef<T> &funcRef) {
   return TypeBuilderImpl{converter}.genExprType(funcRef);
 }
 
 using namespace Fortran::evaluate;
 using namespace Fortran::common;
 FOR_EACH_SPECIFIC_TYPE(template class Fortran::lower::TypeBuilder, )
+FOR_VECTOR_TYPE(template class Fortran::lower::TypeBuilder, )

flang/lib/Lower/Mangler.cpp

static std::string typeToString(Fortran::common::TypeCategory cat, int kind,
   case Fortran::common::TypeCategory::Complex:
     return "z" + std::to_string(kind);
   case Fortran::common::TypeCategory::Logical:
     return "l" + std::to_string(kind);
   case Fortran::common::TypeCategory::Character:
     return "c" + std::to_string(kind);
   case Fortran::common::TypeCategory::Derived:
     return derivedName.str();
+  case Fortran::common::TypeCategory::Vector:
+    return "Vector";
   }
   llvm_unreachable("bad TypeCategory");
 }
 
 std::string Fortran::lower::mangle::mangleArrayLiteral(
     const uint8_t *addr, size_t size,
     const Fortran::evaluate::ConstantSubscripts &shape,
     Fortran::common::TypeCategory cat, int kind,

flang/lib/Parser/Fortran-parsers.cpp

 // N.B. It is critical to distribute "parenthesized()" over the alternatives
 // for TYPE (...), rather than putting the alternatives within it, which
 // would fail on "TYPE(real_derived)" with a misrecognition of "real" as an
 // intrinsic-type-spec.
 // N.B. TYPE(x) is a derived type if x is a one-word extension intrinsic
 // type (BYTE or DOUBLECOMPLEX), not the extension intrinsic type.
 TYPE_CONTEXT_PARSER("declaration type spec"_en_US,
     construct<DeclarationTypeSpec>(intrinsicTypeSpec) ||
+        construct<DeclarationTypeSpec>(vectorTypeSpec) ||
         "TYPE" >>
             (parenthesized(construct<DeclarationTypeSpec>(
                  !"DOUBLECOMPLEX"_tok >> !"BYTE"_tok >> intrinsicTypeSpec)) ||
                 parenthesized(construct<DeclarationTypeSpec>(
                     construct<DeclarationTypeSpec::Type>(derivedTypeSpec))) ||
                 construct<DeclarationTypeSpec>(
                     "( * )" >> construct<DeclarationTypeSpec::TypeStar>())) ||
         "CLASS" >> parenthesized(construct<DeclarationTypeSpec>(
first(construct<IntrinsicTypeSpec>(integerTypeSpec),
         extension<LanguageFeature::DoubleComplex>(
             "nonstandard usage: DOUBLE COMPLEX"_port_en_US,
             construct<IntrinsicTypeSpec>("DOUBLE COMPLEX"_sptok >>
                 construct<IntrinsicTypeSpec::DoubleComplex>())),
         extension<LanguageFeature::Byte>("nonstandard usage: BYTE"_port_en_US,
             construct<IntrinsicTypeSpec>(construct<IntegerTypeSpec>(
                 "BYTE" >> construct<std::optional<KindSelector>>(pure(1)))))))
 
+// Extension: VECTOR type
+// VECTOR(integer-type-spec) | VECTOR(REAL [kind-selector])
+TYPE_CONTEXT_PARSER("Vector type spec"_en_US,
+    extension<LanguageFeature::Vector>("nonstandard usage: VECTOR"_port_en_US,
+        construct<VectorTypeSpec>("VECTOR" >>
+            parenthesized(construct<VectorElementType>(integerTypeSpec) ||
+                construct<VectorElementType>(unsignedTypeSpec) ||
+                construct<VectorElementType>(construct<IntrinsicTypeSpec::Real>(
+                    "REAL" >> maybe(kindSelector)))))))
+// UNSIGNED type
+TYPE_PARSER(construct<UnsignedTypeSpec>("UNSIGNED" >> maybe(kindSelector)))
+
 // R705 integer-type-spec -> INTEGER [kind-selector]
 TYPE_PARSER(construct<IntegerTypeSpec>("INTEGER" >> maybe(kindSelector)))
 
 // R706 kind-selector -> ( [KIND =] scalar-int-constant-expr )
 // Legacy extension: kind-selector -> * digit-string
 TYPE_PARSER(construct<KindSelector>(
                 parenthesized(maybe("KIND ="_tok) >> scalarIntConstantExpr)) ||
     extension<LanguageFeature::StarKind>(

flang/lib/Parser/type-parsers.h

 constexpr Parser<ContainsStmt> containsStmt; // R1543
 constexpr Parser<CompilerDirective> compilerDirective;
 constexpr Parser<OpenACCConstruct> openaccConstruct;
 constexpr Parser<AccEndCombinedDirective> accEndCombinedDirective;
 constexpr Parser<OpenACCDeclarativeConstruct> openaccDeclarativeConstruct;
 constexpr Parser<OpenMPConstruct> openmpConstruct;
 constexpr Parser<OpenMPDeclarativeConstruct> openmpDeclarativeConstruct;
 constexpr Parser<OmpEndLoopDirective> ompEndLoopDirective;
+constexpr Parser<VectorTypeSpec> vectorTypeSpec; // Extension
+constexpr Parser<UnsignedTypeSpec> unsignedTypeSpec; // Extension
 } // namespace Fortran::parser
 #endif // FORTRAN_PARSER_TYPE_PARSERS_H_

flang/lib/Parser/unparse.cpp

public:
   void Post(const IntrinsicTypeSpec::DoublePrecision &) {
     Word("DOUBLE PRECISION");
   }
   void Before(const IntrinsicTypeSpec::Character &) { Word("CHARACTER"); }
   void Before(const IntrinsicTypeSpec::Logical &) { Word("LOGICAL"); }
   void Post(const IntrinsicTypeSpec::DoubleComplex &) {
     Word("DOUBLE COMPLEX");
   }
+  void Before(const UnsignedTypeSpec &) { Word("UNSIGNED"); }
+  void Before(const VectorTypeSpec &) { Word("VECTOR("); }
+  void Post(const VectorTypeSpec &) { Put(')'); }
   void Before(const IntegerTypeSpec &) { // R705
     Word("INTEGER");
   }
   void Unparse(const KindSelector &x) { // R706
     common::visit(
         common::visitors{
             [&](const ScalarIntConstantExpr &y) {
               Put('('), Word("KIND="), Walk(y), Put(')');

flang/lib/Semantics/expression.cpp

const Symbol *ArgumentAnalyzer::FindBoundOp(parser::CharBlock oprName,
   return nullptr;
 }
 
 // If there is an implicit conversion between intrinsic types, make it explicit
 void ArgumentAnalyzer::AddAssignmentConversion(
     const DynamicType &lhsType, const DynamicType &rhsType) {
   if (lhsType.category() == rhsType.category() &&
       (lhsType.category() == TypeCategory::Derived ||
+          lhsType.category() == TypeCategory::Vector ||
           lhsType.kind() == rhsType.kind())) {
     // no conversion necessary
   } else if (auto rhsExpr{evaluate::Fold(context_.GetFoldingContext(),
                  evaluate::ConvertToType(lhsType, MoveExpr(1)))}) {
     std::optional<parser::CharBlock> source;
     if (actuals_[1]) {
       source = actuals_[1]->sourceLocation();
     }

flang/lib/Semantics/resolve-names.cpp

protected:
   bool ConvertToProcEntity(Symbol &);
 
   const DeclTypeSpec &MakeNumericType(
       TypeCategory, const std::optional<parser::KindSelector> &);
   const DeclTypeSpec &MakeNumericType(TypeCategory, int);
   const DeclTypeSpec &MakeLogicalType(
       const std::optional<parser::KindSelector> &);
   const DeclTypeSpec &MakeLogicalType(int);
+  const DeclTypeSpec &MakeVectorType(
+      VectorElementCategory, const std::optional<parser::KindSelector> &);
+  const DeclTypeSpec &MakeVectorType(VectorElementCategory, int);
   void NotePossibleBadForwardRef(const parser::Name &);
   std::optional<SourceName> HadForwardRef(const Symbol &) const;
   bool CheckPossibleBadForwardRef(const Symbol &);
 
   bool inSpecificationPart_{false};
   bool inEquivalenceStmt_{false};
 
   // Some information is collected from a specification part for deferred
public:
   void Post(const parser::IntrinsicTypeSpec::Real &);
   void Post(const parser::IntrinsicTypeSpec::Complex &);
   void Post(const parser::IntrinsicTypeSpec::Logical &);
   void Post(const parser::IntrinsicTypeSpec::Character &);
   void Post(const parser::CharSelector::LengthAndKind &);
   void Post(const parser::CharLength &);
   void Post(const parser::LengthSelector &);
   bool Pre(const parser::KindParam &);
+  bool Pre(const parser::VectorTypeSpec &);
+  void Post(const parser::VectorTypeSpec &);
   bool Pre(const parser::DeclarationTypeSpec::Type &);
   void Post(const parser::DeclarationTypeSpec::Type &);
   bool Pre(const parser::DeclarationTypeSpec::Class &);
   void Post(const parser::DeclarationTypeSpec::Class &);
   void Post(const parser::DeclarationTypeSpec::Record &);
   void Post(const parser::DerivedTypeSpec &);
   bool Pre(const parser::DerivedTypeDef &);
   bool Pre(const parser::DerivedTypeStmt &);
struct EnumeratorState {
     std::optional<int> value{0};
   } enumerationState_;
   // Set for OldParameterStmt processing
   bool inOldStyleParameterStmt_{false};
   // Set when walking DATA & array constructor implied DO loop bounds
   // to warn about use of the implied DO intex therein.
   std::optional<SourceName> checkIndexUseInOwnBounds_;
   bool hasBindCName_{false};
+  bool isVectorType{false};
 
   bool HandleAttributeStmt(Attr, const std::list<parser::Name> &);
   Symbol &HandleAttributeStmt(Attr, const parser::Name &);
   Symbol &DeclareUnknownEntity(const parser::Name &, Attrs);
   Symbol &DeclareProcEntity(
       const parser::Name &, Attrs, const Symbol *interface);
   void SetType(const parser::Name &, const DeclTypeSpec &);
   std::optional<DerivedTypeSpec> ResolveDerivedType(const parser::Name &);
if (auto known{evaluate::ToInt64(value)}) {
     return currScope_->MakeLogicalType(std::move(value));
   }
 }
 
 const DeclTypeSpec &ScopeHandler::MakeLogicalType(int kind) {
   return context().MakeLogicalType(kind);
 }
 
+const DeclTypeSpec &ScopeHandler::MakeVectorType(
+    VectorElementCategory elementCategory,
+    const std::optional<parser::KindSelector> &kind) {
+  KindExpr value{GetKindParamExpr(
+      VectorTypeSpec::elementTypeCatToIntrinsicTypeCat(elementCategory), kind)};
+  if (auto known{evaluate::ToInt64(value)}) {
+    return MakeVectorType(elementCategory, static_cast<int>(*known));
+  } else {
+    return currScope_->MakeVectorType(elementCategory, std::move(value));
+  }
+}
+const DeclTypeSpec &ScopeHandler::MakeVectorType(
+    VectorElementCategory category, int kind) {
+  return context().MakeVectorType(category, kind);
+}
+
 void ScopeHandler::NotePossibleBadForwardRef(const parser::Name &name) {
   if (inSpecificationPart_ && name.symbol) {
     auto kind{currScope().kind()};
     if ((kind == Scope::Kind::Subprogram && !currScope().IsStmtFunction()) ||
         kind == Scope::Kind::BlockConstruct) {
       bool isHostAssociated{&name.symbol->owner() == &currScope()
               ? name.symbol->has<HostAssocDetails>()
               : name.symbol->owner().Contains(currScope())};
Symbol &DeclarationVisitor::DeclareObjectEntity(
   }
   ClearArraySpec();
   ClearCoarraySpec();
   charInfo_.length.reset();
   return symbol;
 }
 
 void DeclarationVisitor::Post(const parser::IntegerTypeSpec &x) {
+  if (!isVectorType) {
     SetDeclTypeSpec(MakeNumericType(TypeCategory::Integer, x.v));
   }
+}
 void DeclarationVisitor::Post(const parser::IntrinsicTypeSpec::Real &x) {
+  if (!isVectorType) {
     SetDeclTypeSpec(MakeNumericType(TypeCategory::Real, x.kind));
   }
+}
 void DeclarationVisitor::Post(const parser::IntrinsicTypeSpec::Complex &x) {
   SetDeclTypeSpec(MakeNumericType(TypeCategory::Complex, x.kind));
 }
 void DeclarationVisitor::Post(const parser::IntrinsicTypeSpec::Logical &x) {
   SetDeclTypeSpec(MakeLogicalType(x.kind));
 }
 void DeclarationVisitor::Post(const parser::IntrinsicTypeSpec::Character &) {
   if (!charInfo_.length) {
if (const auto *kind{std::get_if<
     const parser::Name &name{kind->thing.thing.thing};
     if (!FindSymbol(name)) {
       Say(name, "Parameter '%s' not found"_err_en_US);
     }
   }
   return false;
 }
 
+bool DeclarationVisitor::Pre(const parser::VectorTypeSpec &) {
+  isVectorType = true;
+  return true;
+}
+void DeclarationVisitor::Post(const parser::VectorTypeSpec &x) {
+  isVectorType = false;
+  common::visit(common::visitors{
+                    [=](const parser::IntegerTypeSpec &y) {
+                      SetDeclTypeSpec(MakeVectorType(
+                          VectorElementCategory::Integer, std::move(y.v)));
+                    },
+                    [=](const parser::IntrinsicTypeSpec::Real &y) {
+                      SetDeclTypeSpec(MakeVectorType(
+                          VectorElementCategory::Real, std::move(y.kind)));
+                    },
+                    [=](const parser::UnsignedTypeSpec &y) {
+                      SetDeclTypeSpec(MakeVectorType(
+                          VectorElementCategory::Unsigned, std::move(y.v)));
+                    },
+                },
+      x.v.u);
+}
+
 bool DeclarationVisitor::Pre(const parser::DeclarationTypeSpec::Type &) {
   CHECK(GetDeclTypeSpecCategory() == DeclTypeSpec::Category::TypeDerived);
   return true;
 }
 
 void DeclarationVisitor::Post(const parser::DeclarationTypeSpec::Type &type) {
   const parser::Name &derivedName{std::get<parser::Name>(type.derived.t)};
   if (const Symbol * derivedSymbol{derivedName.symbol}) {
if (type.IsAssumedType()) {
           type.IsPolymorphic() ? DeclTypeSpec::ClassDerived
                                : DeclTypeSpec::TypeDerived,
           common::Clone(type.GetDerivedTypeSpec())
 
       );
     }
   case common::TypeCategory::Character:
     CRASH_NO_CASE;
+  case common::TypeCategory::Vector:
+    return context().MakeVectorType(
+        type.GetVectorTypeSpec().vectorElementCategory(),
+        type.GetVectorTypeSpec().vectorElementKind());
   }
 }
 
 const DeclTypeSpec &ConstructVisitor::ToDeclTypeSpec(
     evaluate::DynamicType &&type, MaybeSubscriptIntExpr &&length) {
   CHECK(type.category() == common::TypeCategory::Character);
   if (length) {
     return currScope().MakeCharacterType(

flang/lib/Semantics/scope.cpp

const DeclTypeSpec &Scope::MakeLogicalType(KindExpr &&kind) {
   return MakeLengthlessType(LogicalTypeSpec{std::move(kind)});
 }
 const DeclTypeSpec &Scope::MakeTypeStarType() {
   return MakeLengthlessType(DeclTypeSpec{DeclTypeSpec::TypeStar});
 }
 const DeclTypeSpec &Scope::MakeClassStarType() {
   return MakeLengthlessType(DeclTypeSpec{DeclTypeSpec::ClassStar});
 }
+const DeclTypeSpec &Scope::MakeVectorType(
+    VectorElementCategory elementTypeCategory, KindExpr &&kind) {
+  return MakeLengthlessType(
+      VectorTypeSpec{elementTypeCategory, std::move(kind)});
+}
+
 // Types that can't have length parameters can be reused without having to
 // compare length expressions. They are stored in the global scope.
 const DeclTypeSpec &Scope::MakeLengthlessType(DeclTypeSpec &&type) {
   const auto *found{FindType(type)};
   return found ? *found : declTypeSpecs_.emplace_back(std::move(type));
 }
 
 const DeclTypeSpec &Scope::MakeCharacterType(
if (dyType->IsAssumedType()) {
         break;
       case TypeCategory::Logical:
         return &MakeLogicalType(KindExpr{dyType->kind()});
       case TypeCategory::Derived:
         return &MakeDerivedType(dyType->IsPolymorphic()
                 ? DeclTypeSpec::ClassDerived
                 : DeclTypeSpec::TypeDerived,
             DerivedTypeSpec{dyType->GetDerivedTypeSpec()});
+      case TypeCategory::Vector:
+        return &MakeVectorType(
+            dyType->GetVectorTypeSpec().vectorElementCategory(),
+            KindExpr{dyType->GetVectorTypeSpec().vectorElementKind()});
       }
     }
   }
   return nullptr;
 }
 
 Scope::ImportKind Scope::GetImportKind() const {
   if (importKind_) {

flang/lib/Semantics/semantics.cpp

 }
 const DeclTypeSpec &SemanticsContext::MakeLogicalType(int kind) {
   if (kind == 0) {
     kind = GetDefaultKind(TypeCategory::Logical);
   }
   return globalScope_.MakeLogicalType(KindExpr{kind});
 }
 
+const DeclTypeSpec &SemanticsContext::MakeVectorType(
+    VectorElementCategory elementCategory, int kind) {
+  if (kind == 0) {
+    kind = GetDefaultKind(
+        VectorTypeSpec::elementTypeCatToIntrinsicTypeCat(elementCategory));
+  }
+  return globalScope_.MakeVectorType(elementCategory, KindExpr{kind});
+}
 bool SemanticsContext::AnyFatalError() const {
   return !messages_.empty() &&
       (warningsAreErrors_ || messages_.AnyFatalError());
 }
 bool SemanticsContext::HasError(const Symbol &symbol) {
   return errorSymbols_.count(symbol) > 0;
 }
 bool SemanticsContext::HasError(const Symbol *symbol) {

flang/lib/Semantics/type.cpp

for (const auto &pair : parameters_) {
     auto iter{that.parameters_.find(pair.first)};
     if (iter == that.parameters_.end() || iter->second != value) {
       return false;
     }
   }
   return true;
 }
 
+VectorTypeSpec::VectorTypeSpec(
+    VectorElementCategory pVectorElementCategory, KindExpr &&pKind)
+    : vectorElementCategory_(pVectorElementCategory) {
+  auto kind{Fortran::evaluate::ToInt64(pKind).value_or(0)};
+  if (!kind) {
+    llvm::report_fatal_error("Unspecified kind for vector element type");
+  }
+  vectorElementKind_ = kind;
+}
+
 class InstantiateHelper {
 public:
   InstantiateHelper(Scope &scope) : scope_{scope} {}
   // Instantiate components from fromScope into scope_
   void InstantiateComponents(const Scope &);
 
 private:
   SemanticsContext &context() const { return scope_.context(); }
llvm::raw_ostream &operator<<(
     llvm::raw_ostream &os, const IntrinsicTypeSpec &x) {
   return os << x.AsFortran();
 }
 
 std::string CharacterTypeSpec::AsFortran() const {
   return "CHARACTER(" + length_.AsFortran() + ',' + KindAsFortran(kind()) + ')';
 }
 
+std::string VectorTypeSpec::AsFortran() const {
+  return "VECTOR(" + std::string{EnumToString(vectorElementCategory())} + "(" +
+      std::to_string(vectorElementKind()) + ")" + ')';
+}
+
 llvm::raw_ostream &operator<<(
     llvm::raw_ostream &os, const CharacterTypeSpec &x) {
   return os << x.AsFortran();
 }
 
 DeclTypeSpec::DeclTypeSpec(NumericTypeSpec &&typeSpec)
     : category_{Numeric}, typeSpec_{std::move(typeSpec)} {}
 DeclTypeSpec::DeclTypeSpec(LogicalTypeSpec &&typeSpec)
     : category_{Logical}, typeSpec_{std::move(typeSpec)} {}
 DeclTypeSpec::DeclTypeSpec(const CharacterTypeSpec &typeSpec)
     : category_{Character}, typeSpec_{typeSpec} {}
 DeclTypeSpec::DeclTypeSpec(CharacterTypeSpec &&typeSpec)
     : category_{Character}, typeSpec_{std::move(typeSpec)} {}
 DeclTypeSpec::DeclTypeSpec(Category category, const DerivedTypeSpec &typeSpec)
     : category_{category}, typeSpec_{typeSpec} {
   CHECK(category == TypeDerived || category == ClassDerived);
 }
 DeclTypeSpec::DeclTypeSpec(Category category, DerivedTypeSpec &&typeSpec)
     : category_{category}, typeSpec_{std::move(typeSpec)} {
   CHECK(category == TypeDerived || category == ClassDerived);
 }
 DeclTypeSpec::DeclTypeSpec(Category category) : category_{category} {
   CHECK(category == TypeStar || category == ClassStar);
 }
+DeclTypeSpec::DeclTypeSpec(VectorTypeSpec &&typeSpec)
+    : category_{Vector}, typeSpec_{std::move(typeSpec)} {}
+
 bool DeclTypeSpec::IsNumeric(TypeCategory tc) const {
   return category_ == Numeric && numericTypeSpec().category() == tc;
 }
 bool DeclTypeSpec::IsSequenceType() const {
   if (const DerivedTypeSpec * derivedType{AsDerived()}) {
     const auto *typeDetails{
         derivedType->typeSymbol().detailsIf<DerivedTypeDetails>()};
     return typeDetails && typeDetails->sequence();
if (derivedTypeSpec()
       return "TYPE(" + derivedTypeSpec().AsFortran() + ')';
     }
   case ClassDerived:
     return "CLASS(" + derivedTypeSpec().AsFortran() + ')';
   case TypeStar:
     return "TYPE(*)";
   case ClassStar:
     return "CLASS(*)";
+  case Vector:
+    return vectorTypeSpec().AsFortran();
   }
 }
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &o, const DeclTypeSpec &x) {
   return o << x.AsFortran();
 }
 
 bool IsInteroperableIntrinsicType(const DeclTypeSpec &type) {
   auto dyType{evaluate::DynamicType::From(type)};
   return dyType && IsInteroperableIntrinsicType(*dyType);
 }
 
 } // namespace Fortran::semantics

flang/runtime/descriptor-io.h

case TypeCategory::Logical:
       default:
         handler.Crash(
             "DescriptorIO: Unimplemented LOGICAL kind (%d) in descriptor",
             kind);
         return false;
       }
     case TypeCategory::Derived:
       return FormattedDerivedTypeIO<DIR>(io, descriptor);
+    case TypeCategory::Vector:
+      handler.Crash("DescriptorIO: Unsupported VECTOR type in descriptor");
+      return false;
     }
   }
   handler.Crash("DescriptorIO: bad type code (%d) in descriptor",
       static_cast<int>(descriptor.type().raw()));
   return false;
 }
 } // namespace Fortran::runtime::io::descr
 #endif // FORTRAN_RUNTIME_DESCRIPTOR_IO_H_

flang/runtime/type-code.cpp

 //===-- runtime/type-code.cpp ---------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Runtime/type-code.h"
+#include <cassert>
 
 namespace Fortran::runtime {
 
 TypeCode::TypeCode(TypeCategory f, int kind) {
   switch (f) {
   case TypeCategory::Integer:
     switch (kind) {
     case 1:
case TypeCategory::Logical:
     case 8:
       raw_ = CFI_type_int_least64_t;
       break;
     }
     break;
   case TypeCategory::Derived:
     raw_ = CFI_type_struct;
     break;
+  case TypeCategory::Vector:
+    assert(false && "Vector is not supported.");
+    break;
   }
 }
 
 std::optional<std::pair<TypeCategory, int>>
 TypeCode::GetCategoryAndKind() const {
   switch (raw_) {
   case CFI_type_signed_char:
     return std::make_pair(TypeCategory::Character, sizeof(signed char));

flang/runtime/type-info.cpp

 //===-- runtime/type-info.cpp ---------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "type-info.h"
 #include "terminator.h"
+#include <cassert>
 #include <cstdio>
 
 namespace Fortran::runtime::typeInfo {
 
 std::optional<TypeParameterValue> Value::GetValue(
     const Descriptor *descriptor) const {
   switch (genre_) {
   case Genre::Explicit:
if (auto value{characterLen_.GetValue(&instance)}) {
       return kind_ * *value;
     }
     break;
   case TypeCategory::Derived:
     if (const auto *type{derivedType()}) {
       return type->sizeInBytes();
     }
     break;
+  case TypeCategory::Vector:
+    assert(false && "Vector is not supported.");
+    break;
   }
   return 0;
 }
 
 std::size_t Component::GetElements(const Descriptor &instance) const {
   std::size_t elements{1};
   if (int rank{rank_}) {
     if (const Value * boundValues{bounds()}) {