Add _Optional as fast qualifier

[chrisbazley]

Summary

A new pointee type qualifier for the purpose of
adding pointer nullability information to C
programs. Its goal is to provide value not only
for static analysis and documentation, but also
for compilers which report errors based only on
existing type-compatibility rules. The syntax
and semantics are designed to be as familiar (to
C programmers) and ergonomic as possible.

[rriddle]

I don't understand the MLIR changes here, how are they relevant to the patch?

[rsmith]

Including a link to the RFC (https://discourse.llvm.org/t/rfc-optional-a-type-qualifier-to-indicate-pointer-nullability/68004/2) in each of the patches in this series would be helpful.

Assuming that we want to go in this direction, it seems quite expensive to model this as a fast qualifier rather than an extended qualifier. Are these annotations expected to be so common that it's better to increase the alignment of all types than perform extra allocations and indirections for _Optional qualifiers? Have you measured the memory impact of increasing the alignment of Type? I think that should be a prerequisite to adding any new kind of fast qualifier, and if we do add such a qualifier, we should select carefully which qualifier gets this precious bit in QualType.

[chrisbazley]

Please refer to https://discourse.llvm.org/t/rfc-optional-a-type-qualifier-to-indicate-pointer-nullability/ and https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3089.pdf for the wider context of this commit.

[chrisbazley]

Hi, thanks very much for looking at my patch. I added the link that you proposed to all of the patches in the stack.

Assuming that we want to go in this direction, it seems quite expensive to model this as a fast qualifier rather than an extended qualifier.

True, and I'm not at all wedded to the idea of _Optional being a fast qualifier. I added it in the simplest way I knew how, having no prior experience of the codebase. What would be really useful would be if you could show/explain how to add it in a less risky way. If not, I can look into it myself.

Are these annotations expected to be so common that it's better to increase the alignment of all types than perform extra allocations and indirections for _Optional qualifiers?

Given time, I hope so, but realistically not in the near future.

Have you measured the memory impact of increasing the alignment of Type?

No, because I didn't think it necessary for the purpose of prototyping. If there's any prospect of getting my patches merged then I'd be delighted to invest the time... but only if increasing the alignment is a necessary thing to do.

I think that should be a prerequisite to adding any new kind of fast qualifier, and if we do add such a qualifier, we should select carefully which qualifier gets this precious bit in QualType.

I believe that over time, _Optional would be a much more appropriate use of the precious bit currently occupied by volatile because I expect it to be used more heavily, but I can't make that argument yet.

clang/include/clang/AST/APValue.h

static DynamicAllocLValue getFromOpaqueValue(void *Value) {
     V.Index = reinterpret_cast<uintptr_t>(Value) >> NumLowBitsAvailable;
     return V;
   }
 
   static unsigned getMaxIndex() {
     return (std::numeric_limits<unsigned>::max() >> NumLowBitsAvailable) - 1;
   }
 
-  static constexpr int NumLowBitsAvailable = 3;
+  static constexpr int NumLowBitsAvailable = 4;
 };
 }
 
 namespace llvm {
 template<> struct PointerLikeTypeTraits<clang::TypeInfoLValue> {
   static void *getAsVoidPointer(clang::TypeInfoLValue V) {
     return V.getOpaqueValue();
   }
   static clang::TypeInfoLValue getFromVoidPointer(void *P) {
     return clang::TypeInfoLValue::getFromOpaqueValue(P);
   }
   // Validated by static_assert in APValue.cpp; hardcoded to avoid needing
   // to include Type.h.
-  static constexpr int NumLowBitsAvailable = 3;
+  static constexpr int NumLowBitsAvailable = 4;
 };
 
 template<> struct PointerLikeTypeTraits<clang::DynamicAllocLValue> {
   static void *getAsVoidPointer(clang::DynamicAllocLValue V) {
     return V.getOpaqueValue();
   }
   static clang::DynamicAllocLValue getFromVoidPointer(void *P) {
     return clang::DynamicAllocLValue::getFromOpaqueValue(P);

clang/include/clang/AST/CanonicalType.h

public:
   bool isVolatileQualified() const {
     return Stored.isLocalVolatileQualified();
   }
 
   bool isRestrictQualified() const {
     return Stored.isLocalRestrictQualified();
   }
 
+  bool isOptionalQualified() const {
+    return Stored.isLocalOptionalQualified();
+  }
+
   /// Determines if this canonical type is furthermore
   /// canonical as a parameter.  The parameter-canonicalization
   /// process decays arrays to pointers and drops top-level qualifiers.
   bool isCanonicalAsParam() const {
     return Stored.isCanonicalAsParam();
   }
 
   /// Retrieve the unqualified form of this type.

clang/include/clang/AST/Type.h

 class ExtQuals;
 class QualType;
 class ConceptDecl;
 class TagDecl;
 class TemplateParameterList;
 class Type;
 
 enum {
-  TypeAlignmentInBits = 4,
+  TypeAlignmentInBits = 5,
   TypeAlignment = 1 << TypeAlignmentInBits
 };
 
 namespace serialization {
   template <class T> class AbstractTypeReader;
   template <class T> class AbstractTypeWriter;
 }
 

 /// * Embedded C (TR18037): address spaces
 /// * Objective C: the GC attributes (none, weak, or strong)
 class Qualifiers {
 public:
   enum TQ { // NOTE: These flags must be kept in sync with DeclSpec::TQ.
     Const    = 0x1,
     Restrict = 0x2,
     Volatile = 0x4,
-    CVRMask = Const | Volatile | Restrict
+    Optional = 0x8,
+    CVRMask = Const | Volatile | Restrict | Optional
   };
 
   enum GC {
     GCNone = 0,
     Weak,
     Strong
   };
 
public:
   };
 
   enum {
     /// The maximum supported address space number.
     /// 23 bits should be enough for anyone.
     MaxAddressSpace = 0x7fffffu,
 
     /// The width of the "fast" qualifier mask.
-    FastWidth = 3,
+    FastWidth = 4,
 
     /// The fast qualifier mask.
     FastMask = (1 << FastWidth) - 1
   };
 
   /// Returns the common set of qualifiers while removing them from
   /// the given sets.
   static Qualifiers removeCommonQualifiers(Qualifiers &L, Qualifiers &R) {
public:
   void removeVolatile() { Mask &= ~Volatile; }
   void addVolatile() { Mask |= Volatile; }
   Qualifiers withVolatile() const {
     Qualifiers Qs = *this;
     Qs.addVolatile();
     return Qs;
   }
 
+  bool hasOptional() const { return Mask & Optional; }
+  bool hasOnlyOptional() const { return Mask == Optional; }
+  void removeOptional() { Mask &= ~Optional; }
+  void addOptional() { Mask |= Optional; }
+  Qualifiers withOptional() const {
+    Qualifiers Qs = *this;
+    Qs.addOptional();
+    return Qs;
+  }
+
   bool hasRestrict() const { return Mask & Restrict; }
   bool hasOnlyRestrict() const { return Mask == Restrict; }
   void removeRestrict() { Mask &= ~Restrict; }
   void addRestrict() { Mask |= Restrict; }
   Qualifiers withRestrict() const {
     Qualifiers Qs = *this;
     Qs.addRestrict();
     return Qs;
public:
   void print(raw_ostream &OS, const PrintingPolicy &Policy,
              bool appendSpaceIfNonEmpty = false) const;
 
   void Profile(llvm::FoldingSetNodeID &ID) const {
     ID.AddInteger(Mask);
   }
 
 private:
-  // bits:     |0 1 2|3|4 .. 5|6  ..  8|9   ...   31|
-  //           |C R V|U|GCAttr|Lifetime|AddressSpace|
+  // bits:     |0 1 2 3|4|5 .. 6|7  ..  9|10  ...   31|
+  //           |C R V O|U|GCAttr|Lifetime|AddressSpace|
   uint32_t Mask = 0;
 
-  static const uint32_t UMask = 0x8;
-  static const uint32_t UShift = 3;
-  static const uint32_t GCAttrMask = 0x30;
-  static const uint32_t GCAttrShift = 4;
-  static const uint32_t LifetimeMask = 0x1C0;
-  static const uint32_t LifetimeShift = 6;
+  static const uint32_t UMask = 0x10;
+  static const uint32_t UShift = 4;
+  static const uint32_t GCAttrMask = 0x60;
+  static const uint32_t GCAttrShift = 5;
+  static const uint32_t LifetimeMask = 0x380;
+  static const uint32_t LifetimeShift = 7;
   static const uint32_t AddressSpaceMask =
       ~(CVRMask | UMask | GCAttrMask | LifetimeMask);
-  static const uint32_t AddressSpaceShift = 9;
+  static const uint32_t AddressSpaceShift = 10;
 };
 
 class QualifiersAndAtomic {
   Qualifiers Quals;
   bool HasAtomic;
 
 public:
   QualifiersAndAtomic() : HasAtomic(false) {}
   QualifiersAndAtomic(Qualifiers Quals, bool HasAtomic)
       : Quals(Quals), HasAtomic(HasAtomic) {}
 
   operator Qualifiers() const { return Quals; }
 
   bool hasVolatile() const { return Quals.hasVolatile(); }
+  bool hasOptional() const { return Quals.hasOptional(); }
   bool hasConst() const { return Quals.hasConst(); }
   bool hasRestrict() const { return Quals.hasRestrict(); }
   bool hasAtomic() const { return HasAtomic; }
 
   void addVolatile() { Quals.addVolatile(); }
+  void addOptional() { Quals.addOptional(); }
   void addConst() { Quals.addConst(); }
   void addRestrict() { Quals.addRestrict(); }
   void addAtomic() { HasAtomic = true; }
 
   void removeVolatile() { Quals.removeVolatile(); }
+  void removeOptional() { Quals.removeOptional(); }
   void removeConst() { Quals.removeConst(); }
   void removeRestrict() { Quals.removeRestrict(); }
   void removeAtomic() { HasAtomic = false; }
 
   QualifiersAndAtomic withVolatile() {
     return {Quals.withVolatile(), HasAtomic};
   }
+  QualifiersAndAtomic withOptional() {
+    return {Quals.withOptional(), HasAtomic};
+  }
   QualifiersAndAtomic withConst() { return {Quals.withConst(), HasAtomic}; }
   QualifiersAndAtomic withRestrict() {
     return {Quals.withRestrict(), HasAtomic};
   }
   QualifiersAndAtomic withAtomic() { return {Quals, true}; }
 
   QualifiersAndAtomic &operator+=(Qualifiers RHS) {
     Quals += RHS;
public:
   /// added "volatile" at a different level.
   bool isLocalVolatileQualified() const {
     return (getLocalFastQualifiers() & Qualifiers::Volatile);
   }
 
   /// Determine whether this type is volatile-qualified.
   bool isVolatileQualified() const;
 
+  /// Determine whether this particular QualType instance has the
+  /// "_Optional" qualifier set, without looking through typedefs that may have
+  /// added "_Optional" at a different level.
+  bool isLocalOptionalQualified() const {
+    return (getLocalFastQualifiers() & Qualifiers::Optional);
+  }
+
+  /// Determine whether this type is _Optional-qualified.
+  bool isOptionalQualified() const;
+
   /// Determine whether this particular QualType instance has any
   /// qualifiers, without looking through any typedefs that might add
   /// qualifiers at a different level.
   bool hasLocalQualifiers() const {
     return getLocalFastQualifiers() || hasLocalNonFastQualifiers();
   }
 
   /// Determine whether this type has any qualifiers.
public:
   /// Add the `volatile` type qualifier to this QualType.
   void addVolatile() {
     addFastQualifiers(Qualifiers::Volatile);
   }
   QualType withVolatile() const {
     return withFastQualifiers(Qualifiers::Volatile);
   }
 
+  /// Add the `_Optional` type qualifier to this QualType.
+  void addOptional() {
+    addFastQualifiers(Qualifiers::Optional);
+  }
+  QualType withOptional() const {
+    return withFastQualifiers(Qualifiers::Optional);
+  }
   /// Add the `restrict` qualifier to this QualType.
   void addRestrict() {
     addFastQualifiers(Qualifiers::Restrict);
   }
   QualType withRestrict() const {
     return withFastQualifiers(Qualifiers::Restrict);
   }
 
   QualType withCVRQualifiers(unsigned CVR) const {
     return withFastQualifiers(CVR);
   }
 
   void addFastQualifiers(unsigned TQs) {
     assert(!(TQs & ~Qualifiers::FastMask)
            && "non-fast qualifier bits set in mask!");
     Value.setInt(Value.getInt() | TQs);
   }
 
   void removeLocalConst();
   void removeLocalVolatile();
+  void removeLocalOptional();
   void removeLocalRestrict();
   void removeLocalCVRQualifiers(unsigned Mask);
 
   void removeLocalFastQualifiers() { Value.setInt(0); }
   void removeLocalFastQualifiers(unsigned Mask) {
     assert(!(Mask & ~Qualifiers::FastMask) && "mask has non-fast qualifiers");
     Value.setInt(Value.getInt() & ~Mask);
   }

 /// Non-canonical types are useful for emitting diagnostics, without losing
 /// information about typedefs being used.  Canonical types are useful for type
 /// comparisons (they allow by-pointer equality tests) and useful for reasoning
 /// about whether something has a particular form (e.g. is a function type),
 /// because they implicitly, recursively, strip all typedefs out of a type.
 ///
 /// Types, once created, are immutable.
 ///
-class alignas(8) Type : public ExtQualsTypeCommonBase {
+class alignas(16) Type : public ExtQualsTypeCommonBase {
 public:
   enum TypeClass {
 #define TYPE(Class, Base) Class,
 #define LAST_TYPE(Class) TypeLast = Class
 #define ABSTRACT_TYPE(Class, Base)
 #include "clang/AST/TypeNodes.inc"
   };
 
private:
   }
 
 protected:
   friend class ASTContext;
 
   Type(TypeClass tc, QualType canon, TypeDependence Dependence)
       : ExtQualsTypeCommonBase(this,
                                canon.isNull() ? QualType(this_(), 0) : canon) {
-    static_assert(sizeof(*this) <= 8 + sizeof(ExtQualsTypeCommonBase),
+    static_assert(sizeof(*this) <= 16 + sizeof(ExtQualsTypeCommonBase),
                   "changing bitfields changed sizeof(Type)!");
     static_assert(alignof(decltype(*this)) % sizeof(void *) == 0,
                   "Insufficient alignment!");
     TypeBits.TC = tc;
     TypeBits.Dependence = static_cast<unsigned>(Dependence);
     TypeBits.CacheValid = false;
     TypeBits.CachedLocalOrUnnamed = false;
     TypeBits.CachedLinkage = NoLinkage;
public:
   ExtInfo getExtInfo() const { return ExtInfo(FunctionTypeBits.ExtInfo); }
 
   static_assert((~Qualifiers::FastMask & Qualifiers::CVRMask) == 0,
                 "Const, volatile and restrict are assumed to be a subset of "
                 "the fast qualifiers.");
 
   bool isConst() const { return getFastTypeQuals().hasConst(); }
   bool isVolatile() const { return getFastTypeQuals().hasVolatile(); }
+  bool isOptional() const { return getFastTypeQuals().hasOptional(); }
   bool isRestrict() const { return getFastTypeQuals().hasRestrict(); }
 
   /// Determine the type of an expression that calls a function of
   /// this type.
   QualType getCallResultType(const ASTContext &Context) const {
     return getReturnType().getNonLValueExprType(Context);
   }
 

 }
 
 
 inline bool QualType::isVolatileQualified() const {
   return isLocalVolatileQualified() ||
          getCommonPtr()->CanonicalType.isLocalVolatileQualified();
 }
 
+inline bool QualType::isOptionalQualified() const {
+  return isLocalOptionalQualified() ||
+         getCommonPtr()->CanonicalType.isLocalOptionalQualified();
+}
+
 inline bool QualType::hasQualifiers() const {
   return hasLocalQualifiers() ||
          getCommonPtr()->CanonicalType.hasLocalQualifiers();
 }
 
 inline QualType QualType::getUnqualifiedType() const {
   if (!getTypePtr()->getCanonicalTypeInternal().hasLocalQualifiers())
     return QualType(getTypePtr(), 0);

 inline void QualType::removeLocalRestrict() {
   removeLocalFastQualifiers(Qualifiers::Restrict);
 }
 
 inline void QualType::removeLocalVolatile() {
   removeLocalFastQualifiers(Qualifiers::Volatile);
 }
 
+inline void QualType::removeLocalOptional() {
+  removeLocalFastQualifiers(Qualifiers::Optional);
+}
+
 inline void QualType::removeLocalCVRQualifiers(unsigned Mask) {
   assert(!(Mask & ~Qualifiers::CVRMask) && "mask has non-CVR bits");
   static_assert((int)Qualifiers::CVRMask == (int)Qualifiers::FastMask,
                 "Fast bits differ from CVR bits!");
 
   // Fast path: we don't need to touch the slow qualifiers.
   removeLocalFastQualifiers(Mask);
 }

clang/include/clang/Basic/DiagnosticSemaKinds.td

def ext_pure_function_definition : ExtWarn<
   "function definition with pure-specifier is a Microsoft extension">,
   InGroup<MicrosoftPureDefinition>;
 def err_qualified_member_of_unrelated : Error<
   "%q0 is not a member of class %1">;
 
 def err_member_function_call_bad_cvr : Error<
   "'this' argument to member function %0 has type %1, but function is not marked "
   "%select{const|restrict|const or restrict|volatile|const or volatile|"
-  "volatile or restrict|const, volatile, or restrict}2">;
+  "volatile or restrict|const, volatile, or restrict|_Optional|"
+  "const or _Optional|restrict or _Optional|const, restrict or _Optional|"
+  "volatile or _Optional|const, volatile or _Optional|"
+  "volatile, restrict or _Optional|const, volatile, restrict or _Optional}2">;
 def err_member_function_call_bad_ref : Error<
   "'this' argument to member function %0 is an %select{lvalue|rvalue}1, "
   "but function has %select{non-const lvalue|rvalue}2 ref-qualifier">;
 def err_member_function_call_bad_type : Error<
   "cannot initialize object parameter of type %0 with an expression "
   "of type %1">;
 
 def warn_call_to_pure_virtual_member_function_from_ctor_dtor : Warning<
def note_ovl_candidate_bad_ownership : Note<
     "%select{%ordinal7|'this'}6 argument (%3) has "
     "%select{no|__unsafe_unretained|__strong|__weak|__autoreleasing}4 ownership,"
     " but parameter has %select{no|__unsafe_unretained|__strong|__weak|"
     "__autoreleasing}5 ownership">;
 def note_ovl_candidate_bad_cvr_this : Note<
     "candidate %sub{select_ovl_candidate_kind}0,1,2 not viable: "
     "'this' argument has type %3, but method is not marked "
     "%select{const|restrict|const or restrict|volatile|const or volatile|"
-    "volatile or restrict|const, volatile, or restrict}4">;
+    "volatile or restrict|const, volatile, or restrict|_Optional|"
+    "const or _Optional|restrict or _Optional|const, restrict or _Optional|"
+    "volatile or _Optional|const, volatile or _Optional|"
+    "volatile, restrict or _Optional|const, volatile, restrict or _Optional}4">;
 def note_ovl_candidate_bad_cvr : Note<
     "candidate %sub{select_ovl_candidate_kind}0,1,2 not viable: "
     "%ordinal5 argument (%3) would lose "
     "%select{const|restrict|const and restrict|volatile|const and volatile|"
-    "volatile and restrict|const, volatile, and restrict}4 qualifier"
-    "%select{||s||s|s|s}4">;
+    "volatile and restrict|const, volatile, and restrict|_Optional|"
+    "const and _Optional|restrict and _Optional|const, restrict and _Optional|"
+    "volatile and _Optional|const, volatile and _Optional|"
+    "volatile, restrict and _Optional|const, volatile, restrict and _Optional}4 qualifier"
+    "%select{||s||s|s|s||s|s|s|s|s|s|s}4">;
 def note_ovl_candidate_bad_unaligned : Note<
     "candidate %sub{select_ovl_candidate_kind}0,1,2 not viable: "
     "%ordinal5 argument (%3) would lose __unaligned qualifier">;
 def note_ovl_candidate_bad_base_to_derived_conv : Note<
     "candidate %sub{select_ovl_candidate_kind}0,1,2 not viable: "
     "cannot %select{convert from|convert from|bind}3 "
     "%select{base class pointer|superclass|base class object of type}3 %4 to "
     "%select{derived class pointer|subclass|derived class reference}3 %5 for "

clang/include/clang/Basic/TokenKinds.def

 KEYWORD(_Alignas                    , KEYALL)
 KEYWORD(_Alignof                    , KEYALL)
 KEYWORD(_Atomic                     , KEYALL|KEYNOOPENCL)
 KEYWORD(_Bool                       , KEYNOCXX)
 KEYWORD(_Complex                    , KEYALL)
 KEYWORD(_Generic                    , KEYALL)
 KEYWORD(_Imaginary                  , KEYALL)
 KEYWORD(_Noreturn                   , KEYALL)
+KEYWORD(_Optional                   , KEYALL)
 KEYWORD(_Static_assert              , KEYALL)
 KEYWORD(_Thread_local               , KEYALL)
 KEYWORD(__func__                    , KEYALL)
 KEYWORD(__objc_yes                  , KEYALL)
 KEYWORD(__objc_no                   , KEYALL)
 
 
 // C++ 2.11p1: Keywords.

 TYPE_TRAIT_1(__is_pointer, IsPointer, KEYCXX)
 TYPE_TRAIT_1(__is_member_object_pointer, IsMemberObjectPointer, KEYCXX)
 TYPE_TRAIT_1(__is_member_function_pointer, IsMemberFunctionPointer, KEYCXX)
 TYPE_TRAIT_1(__is_member_pointer, IsMemberPointer, KEYCXX)
 TYPE_TRAIT_1(__is_const, IsConst, KEYCXX)
 TYPE_TRAIT_1(__is_volatile, IsVolatile, KEYCXX)
 TYPE_TRAIT_1(__is_signed, IsSigned, KEYCXX)
 TYPE_TRAIT_1(__is_unsigned, IsUnsigned, KEYCXX)
+TYPE_TRAIT_1(__is_optional, IsOptional, KEYCXX)
 
 // Embarcadero Binary Type Traits
 TYPE_TRAIT_2(__is_same, IsSame, KEYCXX)
 TYPE_TRAIT_2(__is_convertible, IsConvertible, KEYCXX)
 ARRAY_TYPE_TRAIT(__array_rank, ArrayRank, KEYCXX)
 ARRAY_TYPE_TRAIT(__array_extent, ArrayExtent, KEYCXX)
 // Name for GCC 6 compatibility.
 ALIAS("__is_same_as", __is_same, KEYCXX)

 ALIAS("__restrict"   , restrict   , KEYALL)
 ALIAS("__restrict__" , restrict   , KEYALL)
 ALIAS("__signed"     , signed     , KEYALL)
 ALIAS("__signed__"   , signed     , KEYALL)
 ALIAS("__typeof"     , typeof     , KEYALL)
 ALIAS("__typeof__"   , typeof     , KEYALL)
 ALIAS("__volatile"   , volatile   , KEYALL)
 ALIAS("__volatile__" , volatile   , KEYALL)
+ALIAS("__optional"   , _Optional  , KEYALL)
+ALIAS("__optional__" , _Optional  , KEYALL)
 
 // Type nullability.
 KEYWORD(_Nonnull                 , KEYALL)
 KEYWORD(_Nullable                , KEYALL)
 KEYWORD(_Nullable_result         , KEYALL)
 KEYWORD(_Null_unspecified        , KEYALL)
 
 // Microsoft extensions which should be disabled in strict conformance mode

clang/include/clang/Sema/DeclSpec.h

#include "clang/Basic/OpenCLImageTypes.def"
   static const TST TST_error = clang::TST_error;
 
   // type-qualifiers
   enum TQ {   // NOTE: These flags must be kept in sync with Qualifiers::TQ.
     TQ_unspecified = 0,
     TQ_const       = 1,
     TQ_restrict    = 2,
     TQ_volatile    = 4,
-    TQ_unaligned   = 8,
+    TQ_optional    = 8,
+    TQ_unaligned   = 16,
     // This has no corresponding Qualifiers::TQ value, because it's not treated
     // as a qualifier in our type system.
-    TQ_atomic      = 16
+    TQ_atomic      = 32
   };
 
   /// ParsedSpecifiers - Flags to query which specifiers were applied.  This is
   /// returned by getParsedSpecifiers.
   enum ParsedSpecifiers {
     PQ_None                  = 0,
     PQ_StorageClassSpecifier = 1,
     PQ_TypeSpecifier         = 2,
private:
   SourceRange TSWRange;
   SourceLocation TSCLoc, TSSLoc, TSTLoc, AltiVecLoc, TSSatLoc;
   /// TSTNameLoc - If TypeSpecType is any of class, enum, struct, union,
   /// typename, then this is the location of the named type (if present);
   /// otherwise, it is the same as TSTLoc. Hence, the pair TSTLoc and
   /// TSTNameLoc provides source range info for tag types.
   SourceLocation TSTNameLoc;
   SourceRange TypeofParensRange;
-  SourceLocation TQ_constLoc, TQ_restrictLoc, TQ_volatileLoc, TQ_atomicLoc,
+  SourceLocation TQ_constLoc, TQ_restrictLoc, TQ_volatileLoc, TQ_optionalLoc, TQ_atomicLoc,
       TQ_unalignedLoc;
   SourceLocation FS_inlineLoc, FS_virtualLoc, FS_explicitLoc, FS_noreturnLoc;
   SourceLocation FS_explicitCloseParenLoc;
   SourceLocation FS_forceinlineLoc;
   SourceLocation FriendLoc, ModulePrivateLoc, ConstexprLoc;
   SourceLocation TQ_pipeLoc;
 
   WrittenBuiltinSpecs writtenBS;
#include "clang/Basic/TransformTypeTraits.def"
 
   // type-qualifiers
 
   /// getTypeQualifiers - Return a set of TQs.
   unsigned getTypeQualifiers() const { return TypeQualifiers; }
   SourceLocation getConstSpecLoc() const { return TQ_constLoc; }
   SourceLocation getRestrictSpecLoc() const { return TQ_restrictLoc; }
   SourceLocation getVolatileSpecLoc() const { return TQ_volatileLoc; }
+  SourceLocation getOptionalSpecLoc() const { return TQ_optionalLoc; }
   SourceLocation getAtomicSpecLoc() const { return TQ_atomicLoc; }
   SourceLocation getUnalignedSpecLoc() const { return TQ_unalignedLoc; }
   SourceLocation getPipeLoc() const { return TQ_pipeLoc; }
 
   /// Clear out all of the type qualifiers.
   void ClearTypeQualifiers() {
     TypeQualifiers = 0;
     TQ_constLoc = SourceLocation();
     TQ_restrictLoc = SourceLocation();
     TQ_volatileLoc = SourceLocation();
+    TQ_optionalLoc = SourceLocation();
     TQ_atomicLoc = SourceLocation();
     TQ_unalignedLoc = SourceLocation();
     TQ_pipeLoc = SourceLocation();
   }
 
   // function-specifier
   bool isInlineSpecified() const {
     return FS_inline_specified | FS_forceinline_specified;
struct PointerTypeInfo {
     unsigned TypeQuals : 5;
 
     /// The location of the const-qualifier, if any.
     SourceLocation ConstQualLoc;
 
     /// The location of the volatile-qualifier, if any.
     SourceLocation VolatileQualLoc;
 
+    /// The location of the _Optional-qualifier, if any.
+    SourceLocation OptionalQualLoc;
+
     /// The location of the restrict-qualifier, if any.
     SourceLocation RestrictQualLoc;
 
     /// The location of the _Atomic-qualifier, if any.
     SourceLocation AtomicQualLoc;
 
     /// The location of the __unaligned-qualifier, if any.
     SourceLocation UnalignedQualLoc;
struct DeclaratorChunk {
   /// them.
   const ParsedAttributesView &getAttrs() const { return AttrList; }
   ParsedAttributesView &getAttrs() { return AttrList; }
 
   /// Return a DeclaratorChunk for a pointer.
   static DeclaratorChunk getPointer(unsigned TypeQuals, SourceLocation Loc,
                                     SourceLocation ConstQualLoc,
                                     SourceLocation VolatileQualLoc,
+                                    SourceLocation OptionalQualLoc,
                                     SourceLocation RestrictQualLoc,
                                     SourceLocation AtomicQualLoc,
                                     SourceLocation UnalignedQualLoc) {
     DeclaratorChunk I;
     I.Kind                = Pointer;
     I.Loc                 = Loc;
     new (&I.Ptr) PointerTypeInfo;
     I.Ptr.TypeQuals       = TypeQuals;
     I.Ptr.ConstQualLoc    = ConstQualLoc;
     I.Ptr.VolatileQualLoc = VolatileQualLoc;
+    I.Ptr.OptionalQualLoc = OptionalQualLoc;
     I.Ptr.RestrictQualLoc = RestrictQualLoc;
     I.Ptr.AtomicQualLoc   = AtomicQualLoc;
     I.Ptr.UnalignedQualLoc = UnalignedQualLoc;
     return I;
   }
 
   /// Return a DeclaratorChunk for a reference.
   static DeclaratorChunk getReference(unsigned TypeQuals, SourceLocation Loc,

clang/include/clang/Sema/Sema.h

public:
   bool diagnoseQualifiedDeclaration(CXXScopeSpec &SS, DeclContext *DC,
                                     DeclarationName Name, SourceLocation Loc,
                                     bool IsTemplateId);
   void
   diagnoseIgnoredQualifiers(unsigned DiagID, unsigned Quals,
                             SourceLocation FallbackLoc,
                             SourceLocation ConstQualLoc = SourceLocation(),
                             SourceLocation VolatileQualLoc = SourceLocation(),
+                            SourceLocation OptionalQualLoc = SourceLocation(),
                             SourceLocation RestrictQualLoc = SourceLocation(),
                             SourceLocation AtomicQualLoc = SourceLocation(),
                             SourceLocation UnalignedQualLoc = SourceLocation());
 
   static bool adjustContextForLocalExternDecl(DeclContext *&DC);
   void DiagnoseFunctionSpecifiers(const DeclSpec &DS);
   NamedDecl *getShadowedDeclaration(const TypedefNameDecl *D,
                                     const LookupResult &R);

clang/lib/AST/ASTImporter.cpp

ExpectedType ASTNodeImporter::VisitInjectedClassNameType(
   ExpectedType ToInjTypeOrErr = import(T->getInjectedSpecializationType());
   if (!ToInjTypeOrErr)
     return ToInjTypeOrErr.takeError();
 
   // FIXME: ASTContext::getInjectedClassNameType is not suitable for AST reading
   // See comments in InjectedClassNameType definition for details
   // return Importer.getToContext().getInjectedClassNameType(D, InjType);
   enum {
-    TypeAlignmentInBits = 4,
+    TypeAlignmentInBits = 5,
     TypeAlignment = 1 << TypeAlignmentInBits
   };
 
   return QualType(new (Importer.getToContext(), TypeAlignment)
                   InjectedClassNameType(*ToDeclOrErr, *ToInjTypeOrErr), 0);
 }
 
 ExpectedType ASTNodeImporter::VisitRecordType(const RecordType *T) {

clang/lib/AST/ItaniumMangle.cpp

void CXXNameMangler::mangleNestedName(GlobalDecl GD,
   // <nested-name>
   //   ::= N [<CV-qualifiers>] [<ref-qualifier>] <prefix> <unqualified-name> E
   //   ::= N [<CV-qualifiers>] [<ref-qualifier>] <template-prefix>
   //       <template-args> E
 
   Out << 'N';
   if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(ND)) {
     Qualifiers MethodQuals = Method->getMethodQualifiers();
-    // We do not consider restrict a distinguishing attribute for overloading
+    // We do not consider restrict or _Optional a distinguishing attribute for overloading
     // purposes so we must not mangle it.
     MethodQuals.removeRestrict();
+    MethodQuals.removeOptional();
     mangleQualifiers(MethodQuals);
     mangleRefQualifier(Method->getRefQualifier());
   }
 
   // Check if we have a template.
   const TemplateArgumentList *TemplateArgs = nullptr;
   if (GlobalDecl TD = isTemplate(GD, TemplateArgs)) {
     mangleTemplatePrefix(TD, NoFunction);

clang/lib/AST/TypePrinter.cpp

static void AppendTypeQualList(raw_ostream &OS, unsigned TypeQuals,
   if (TypeQuals & Qualifiers::Restrict) {
     if (appendSpace) OS << ' ';
     if (HasRestrictKeyword) {
       OS << "restrict";
     } else {
       OS << "__restrict";
     }
   }
+  if (TypeQuals & Qualifiers::Optional) {
+    if (appendSpace) OS << ' ';
+    OS << "_Optional";
+    appendSpace = true;
+  }
 }
 
 void TypePrinter::spaceBeforePlaceHolder(raw_ostream &OS) {
   if (!HasEmptyPlaceHolder)
     OS << ' ';
 }
 
 static SplitQualType splitAccordingToPolicy(QualType QT,

clang/lib/CodeGen/CGDebugInfo.cpp

static llvm::dwarf::Tag getNextQualifier(Qualifiers &Q) {
   if (Q.hasVolatile()) {
     Q.removeVolatile();
     return llvm::dwarf::DW_TAG_volatile_type;
   }
   if (Q.hasRestrict()) {
     Q.removeRestrict();
     return llvm::dwarf::DW_TAG_restrict_type;
   }
+  if (Q.hasOptional()) {
+    Q.removeOptional();
+    return llvm::dwarf::DW_TAG_LLVM_optional_type;
+  }
+
   return (llvm::dwarf::Tag)0;
 }
 
 llvm::DIType *CGDebugInfo::CreateQualifiedType(QualType Ty,
                                                llvm::DIFile *Unit) {
   QualifierCollector Qc;
   const Type *T = Qc.strip(Ty);
 

 
 llvm::DISubroutineType *CGDebugInfo::getOrCreateInstanceMethodType(
     QualType ThisPtr, const FunctionProtoType *Func, llvm::DIFile *Unit) {
   FunctionProtoType::ExtProtoInfo EPI = Func->getExtProtoInfo();
   Qualifiers &Qc = EPI.TypeQuals;
   Qc.removeConst();
   Qc.removeVolatile();
   Qc.removeRestrict();
+  Qc.removeOptional();
   Qc.removeUnaligned();
   // Keep the removed qualifiers in sync with
   // CreateQualifiedType(const FunctionPrototype*, DIFile *Unit)
   // On a 'real' member function type, these qualifiers are carried on the type
   // of the first parameter, not as separate DW_TAG_const_type (etc) decorator
   // tags around them. (But, in the raw function types with qualifiers, they have
   // to use wrapper types.)
 

clang/lib/Format/FormatToken.h

if (!isOneOf(tok::kw_public, tok::kw_protected, tok::kw_private))
       return false;
     if (!ColonRequired)
       return true;
     const auto NextNonComment = getNextNonComment();
     return NextNonComment && NextNonComment->is(tok::colon);
   }
 
   bool canBePointerOrReferenceQualifier() const {
-    return isOneOf(tok::kw_const, tok::kw_restrict, tok::kw_volatile,
+    return isOneOf(tok::kw_const, tok::kw_restrict, tok::kw_volatile, tok::kw__Optional,
                    tok::kw___attribute, tok::kw__Nonnull, tok::kw__Nullable,
                    tok::kw__Null_unspecified, tok::kw___ptr32, tok::kw___ptr64,
                    TT_AttributeMacro);
   }
 
   /// Determine whether the token is a simple-type-specifier.
   [[nodiscard]] bool isSimpleTypeSpecifier() const;
 
#include "clang/Basic/TransformTypeTraits.def"
   /// Returns whether the token is the left square bracket of a C++
   /// structured binding declaration.
   bool isCppStructuredBinding(const FormatStyle &Style) const {
     if (!Style.isCpp() || isNot(tok::l_square))
       return false;
     const FormatToken *T = this;
     do {
       T = T->getPreviousNonComment();
-    } while (T && T->isOneOf(tok::kw_const, tok::kw_volatile, tok::amp,
+    } while (T && T->isOneOf(tok::kw_const, tok::kw_volatile, tok::kw__Optional, tok::amp,
                              tok::ampamp));
     return T && T->is(tok::kw_auto);
   }
 
   /// Same as opensBlockOrBlockTypeList, but for the closing token.
   bool closesBlockOrBlockTypeList(const FormatStyle &Style) const {
     if (is(TT_TemplateString) && closesScope())
       return true;

clang/lib/Format/QualifierAlignmentFixer.cpp

 
 tok::TokenKind LeftRightQualifierAlignmentFixer::getTokenFromQualifier(
     const std::string &Qualifier) {
   // Don't let 'type' be an identifier, but steal typeof token.
   return llvm::StringSwitch<tok::TokenKind>(Qualifier)
       .Case("type", tok::kw_typeof)
       .Case("const", tok::kw_const)
       .Case("volatile", tok::kw_volatile)
+      .Case("_Optional", tok::kw__Optional)
       .Case("static", tok::kw_static)
       .Case("inline", tok::kw_inline)
       .Case("constexpr", tok::kw_constexpr)
       .Case("restrict", tok::kw_restrict)
       .Case("friend", tok::kw_friend)
       .Default(tok::identifier);
 }
 

clang/lib/Format/TokenAnnotator.cpp

if (Tok.Next->is(tok::question))
       return false;
 
     // `foreach((A a, B b) in someList)` should not be seen as a cast.
     if (Tok.Next->is(Keywords.kw_in) && Style.isCSharp())
       return false;
 
     // Functions which end with decorations like volatile, noexcept are unlikely
     // to be casts.
-    if (Tok.Next->isOneOf(tok::kw_noexcept, tok::kw_volatile, tok::kw_const,
+    if (Tok.Next->isOneOf(tok::kw_noexcept, tok::kw_volatile, tok::kw__Optional, tok::kw_const,
                           tok::kw_requires, tok::kw_throw, tok::arrow,
                           Keywords.kw_override, Keywords.kw_final) ||
         isCpp11AttributeSpecifier(*Tok.Next)) {
       return false;
     }
 
     // As Java has no function types, a "(" after the ")" likely means that this
     // is a cast.
if (Right.isOneOf(tok::star, tok::amp, tok::ampamp)) {
     //   operator Foo*()
     //   operator C<T>*()
     //   operator std::Foo*()
     //   operator C<T>::D<U>*()
     // dependent on PointerAlignment style.
     if (Previous) {
       if (Previous->endsSequence(tok::kw_operator))
         return Style.PointerAlignment != FormatStyle::PAS_Left;
-      if (Previous->is(tok::kw_const) || Previous->is(tok::kw_volatile)) {
+      if (Previous->is(tok::kw_const) || Previous->is(tok::kw_volatile) || Previous->is(tok::kw__Optional)) {
         return (Style.PointerAlignment != FormatStyle::PAS_Left) ||
                (Style.SpaceAroundPointerQualifiers ==
                 FormatStyle::SAPQ_After) ||
                (Style.SpaceAroundPointerQualifiers == FormatStyle::SAPQ_Both);
       }
     }
   }
   const auto SpaceRequiredForArrayInitializerLSquare =
bool TokenAnnotator::spaceRequiredBetween(const AnnotatedLine &Line,
   }
   if (Right.is(tok::r_brace) && Right.MatchingParen &&
       Right.MatchingParen->endsSequence(TT_DictLiteral, tok::at)) {
     // Objective-C dictionary literal -> no space before closing brace.
     return false;
   }
   if (Right.getType() == TT_TrailingAnnotation &&
       Right.isOneOf(tok::amp, tok::ampamp) &&
-      Left.isOneOf(tok::kw_const, tok::kw_volatile) &&
+      Left.isOneOf(tok::kw_const, tok::kw_volatile, tok::kw__Optional) &&
       (!Right.Next || Right.Next->is(tok::semi))) {
     // Match const and volatile ref-qualifiers without any additional
     // qualifiers such as
     // void Fn() const &;
     return getTokenReferenceAlignment(Right) != FormatStyle::PAS_Left;
   }
 
   return true;

clang/lib/Format/UnwrappedLineParser.cpp

bool clang::format::UnwrappedLineParser::parseRequires() {
 
   bool FoundType = false;
   bool LastWasColonColon = false;
   int OpenAngles = 0;
 
   for (; Lookahead < 50; PeekNext()) {
     switch (NextToken->Tok.getKind()) {
     case tok::kw_volatile:
+    case tok::kw__Optional:
     case tok::kw_const:
     case tok::comma:
       FormatTok = Tokens->setPosition(StoredPosition);
       parseRequiresExpression(RequiresToken);
       return false;
     case tok::r_paren:
     case tok::pipepipe:
       FormatTok = Tokens->setPosition(StoredPosition);

clang/lib/Parse/ParseDecl.cpp

 
 SourceLocation Parser::SkipExtendedMicrosoftTypeAttributes() {
   SourceLocation EndLoc;
 
   while (true) {
     switch (Tok.getKind()) {
     case tok::kw_const:
     case tok::kw_volatile:
+    case tok::kw__Optional:
     case tok::kw___fastcall:
     case tok::kw___stdcall:
     case tok::kw___thiscall:
     case tok::kw___cdecl:
     case tok::kw___vectorcall:
     case tok::kw___ptr32:
     case tok::kw___ptr64:
     case tok::kw___w64:
#include "clang/Basic/OpenCLImageTypes.def"
     case tok::kw_const:
       isInvalid = DS.SetTypeQual(DeclSpec::TQ_const, Loc, PrevSpec, DiagID,
                                  getLangOpts());
       break;
     case tok::kw_volatile:
       isInvalid = DS.SetTypeQual(DeclSpec::TQ_volatile, Loc, PrevSpec, DiagID,
                                  getLangOpts());
       break;
+    case tok::kw__Optional:
+      isInvalid = DS.SetTypeQual(DeclSpec::TQ_optional, Loc, PrevSpec, DiagID,
+                                 getLangOpts());
+      break;
     case tok::kw_restrict:
       isInvalid = DS.SetTypeQual(DeclSpec::TQ_restrict, Loc, PrevSpec, DiagID,
                                  getLangOpts());
       break;
 
     // C++ typename-specifier:
     case tok::kw_typename:
       if (TryAnnotateTypeOrScopeToken()) {
#include "clang/Basic/OpenCLImageTypes.def"
   case tok::kw___interface:
   case tok::kw_union:
     // enum-specifier
   case tok::kw_enum:
 
     // type-qualifier
   case tok::kw_const:
   case tok::kw_volatile:
+  case tok::kw__Optional:
   case tok::kw_restrict:
   case tok::kw__Sat:
 
     // Debugger support.
   case tok::kw___unknown_anytype:
 
     // typedef-name
   case tok::annot_typename:
bool Parser::isDeclarationSpecifier(
   case tok::kw_union:
   case tok::kw___interface:
     // enum-specifier
   case tok::kw_enum:
 
     // type-qualifier
   case tok::kw_const:
   case tok::kw_volatile:
+  case tok::kw__Optional:
   case tok::kw_restrict:
   case tok::kw__Sat:
 
     // function-specifier
   case tok::kw_inline:
   case tok::kw_virtual:
   case tok::kw_explicit:
   case tok::kw__Noreturn:
while (true) {
     case tok::kw_const:
       isInvalid = DS.SetTypeQual(DeclSpec::TQ_const   , Loc, PrevSpec, DiagID,
                                  getLangOpts());
       break;
     case tok::kw_volatile:
       isInvalid = DS.SetTypeQual(DeclSpec::TQ_volatile, Loc, PrevSpec, DiagID,
                                  getLangOpts());
       break;
+    case tok::kw__Optional:
+      isInvalid = DS.SetTypeQual(DeclSpec::TQ_optional, Loc, PrevSpec, DiagID,
+                                 getLangOpts());
+      break;
     case tok::kw_restrict:
       isInvalid = DS.SetTypeQual(DeclSpec::TQ_restrict, Loc, PrevSpec, DiagID,
                                  getLangOpts());
       break;
     case tok::kw__Atomic:
       if (!AtomicAllowed)
         goto DoneWithTypeQuals;
       if (!getLangOpts().C11)
if (Kind == tok::star || Kind == tok::caret) {
 
     // Recursively parse the declarator.
     Actions.runWithSufficientStackSpace(
         D.getBeginLoc(), [&] { ParseDeclaratorInternal(D, DirectDeclParser); });
     if (Kind == tok::star)
       // Remember that we parsed a pointer type, and remember the type-quals.
       D.AddTypeInfo(DeclaratorChunk::getPointer(
                         DS.getTypeQualifiers(), Loc, DS.getConstSpecLoc(),
-                        DS.getVolatileSpecLoc(), DS.getRestrictSpecLoc(),
-                        DS.getAtomicSpecLoc(), DS.getUnalignedSpecLoc()),
+                        DS.getVolatileSpecLoc(), DS.getOptionalSpecLoc(),
+                        DS.getRestrictSpecLoc(), DS.getAtomicSpecLoc(),
+                        DS.getUnalignedSpecLoc()),
                     std::move(DS.getAttributes()), SourceLocation());
     else
       // Remember that we parsed a Block type, and remember the type-quals.
       D.AddTypeInfo(
           DeclaratorChunk::getBlockPointer(DS.getTypeQualifiers(), Loc),
           std::move(DS.getAttributes()), SourceLocation());
   } else {
     // Is a reference
if (Kind == tok::star || Kind == tok::caret) {
     // template type argument, in which case the cv-qualifiers are ignored.
     if (DS.getTypeQualifiers() != DeclSpec::TQ_unspecified) {
       if (DS.getTypeQualifiers() & DeclSpec::TQ_const)
         Diag(DS.getConstSpecLoc(),
              diag::err_invalid_reference_qualifier_application) << "const";
       if (DS.getTypeQualifiers() & DeclSpec::TQ_volatile)
         Diag(DS.getVolatileSpecLoc(),
              diag::err_invalid_reference_qualifier_application) << "volatile";
+      if (DS.getTypeQualifiers() & DeclSpec::TQ_optional)
+        Diag(DS.getOptionalSpecLoc(),
+             diag::err_invalid_reference_qualifier_application) << "_Optional";
       // 'restrict' is permitted as an extension.
       if (DS.getTypeQualifiers() & DeclSpec::TQ_atomic)
         Diag(DS.getAtomicSpecLoc(),
              diag::err_invalid_reference_qualifier_application) << "_Atomic";
     }
 
     // Recursively parse the declarator.
     Actions.runWithSufficientStackSpace(

clang/lib/Parse/ParseDeclCXX.cpp

bool Parser::isValidAfterTypeSpecifier(bool CouldBeBitfield) {
   case tok::kw___thiscall:   // struct foo {...} __thiscall   x;
   case tok::kw___vectorcall: // struct foo {...} __vectorcall x;
     // We will diagnose these calling-convention specifiers on non-function
     // declarations later, so claim they are valid after a type specifier.
     return getLangOpts().MicrosoftExt;
   // Type qualifiers
   case tok::kw_const:       // struct foo {...} const     x;
   case tok::kw_volatile:    // struct foo {...} volatile  x;
+  case tok::kw__Optional:   // struct foo {...} _Optional x;
   case tok::kw_restrict:    // struct foo {...} restrict  x;
   case tok::kw__Atomic:     // struct foo {...} _Atomic   x;
   case tok::kw___unaligned: // struct foo {...} __unaligned *x;
   // Function specifiers
   // Note, no 'explicit'. An explicit function must be either a conversion
   // operator or a constructor. Either way, it can't have a return type.
   case tok::kw_inline:  // struct foo       inline    f();
   case tok::kw_virtual: // struct foo       virtual   f();

clang/lib/Parse/ParseObjc.cpp

IdentifierInfo *Parser::ParseObjCSelectorPiece(SourceLocation &SelectorLoc) {
   case tok::kw_typename:
   case tok::kw_typeof:
   case tok::kw_union:
   case tok::kw_unsigned:
   case tok::kw_using:
   case tok::kw_virtual:
   case tok::kw_void:
   case tok::kw_volatile:
+  case tok::kw__Optional:
   case tok::kw_wchar_t:
   case tok::kw_while:
   case tok::kw__Bool:
   case tok::kw__Complex:
   case tok::kw___alignof:
   case tok::kw___auto_type:
     IdentifierInfo *II = Tok.getIdentifierInfo();
     SelectorLoc = ConsumeToken();

clang/lib/Parse/ParseTentative.cpp

if (Tok.isOneOf(tok::star, tok::amp, tok::caret, tok::ampamp) ||
         (Tok.is(tok::annot_cxxscope) && NextToken().is(tok::star))) {
       // ptr-operator
       ConsumeAnyToken();
 
       // Skip attributes.
       if (!TrySkipAttributes())
         return TPResult::Error;
 
-      while (Tok.isOneOf(tok::kw_const, tok::kw_volatile, tok::kw_restrict,
+      while (Tok.isOneOf(tok::kw_const, tok::kw_volatile, tok::kw__Optional, tok::kw_restrict,
                          tok::kw__Nonnull, tok::kw__Nullable,
                          tok::kw__Nullable_result, tok::kw__Null_unspecified,
                          tok::kw__Atomic))
         ConsumeToken();
     } else {
       return TPResult::True;
     }
   }
Parser::isCXXDeclarationSpecifier(ImplicitTypenameContext AllowImplicitTypename,
   case tok::kw_struct:
   case tok::kw_union:
   case tok::kw___interface:
     // enum-specifier
   case tok::kw_enum:
     // cv-qualifier
   case tok::kw_const:
   case tok::kw_volatile:
+  case tok::kw__Optional:
     return TPResult::True;
 
     // OpenCL address space qualifiers
   case tok::kw_private:
     if (!getLangOpts().OpenCL)
       return TPResult::False;
     [[fallthrough]];
   case tok::kw___private:
bool Parser::isCXXFunctionDeclarator(
   TPResult TPR = TryParseParameterDeclarationClause(
       &InvalidAsDeclaration, /*VersusTemplateArgument=*/false,
       AllowImplicitTypename);
   if (TPR == TPResult::Ambiguous) {
     if (Tok.isNot(tok::r_paren))
       TPR = TPResult::False;
     else {
       const Token &Next = NextToken();
-      if (Next.isOneOf(tok::amp, tok::ampamp, tok::kw_const, tok::kw_volatile,
+      if (Next.isOneOf(tok::amp, tok::ampamp, tok::kw_const, tok::kw_volatile, tok::kw__Optional,
                        tok::kw_throw, tok::kw_noexcept, tok::l_square,
                        tok::l_brace, tok::kw_try, tok::equal, tok::arrow) ||
           isCXX11VirtSpecifier(Next))
         // The next token cannot appear after a constructor-style initializer,
         // and can appear next in a function definition. This must be a function
         // declarator.
         TPR = TPResult::True;
       else if (InvalidAsDeclaration)
Parser::TPResult Parser::TryParseFunctionDeclarator() {
   if (TPR == TPResult::False || TPR == TPResult::Error)
     return TPR;
 
   // Parse through the parens.
   if (!SkipUntil(tok::r_paren, StopAtSemi))
     return TPResult::Error;
 
   // cv-qualifier-seq
-  while (Tok.isOneOf(tok::kw_const, tok::kw_volatile, tok::kw___unaligned,
+  while (Tok.isOneOf(tok::kw_const, tok::kw_volatile, tok::kw__Optional, tok::kw___unaligned,
                      tok::kw_restrict))
     ConsumeToken();
 
   // ref-qualifier[opt]
   if (Tok.isOneOf(tok::amp, tok::ampamp))
     ConsumeToken();
 
   // exception-specification

clang/lib/Sema/DeclSpec.cpp

 }
 
 void DeclSpec::forEachCVRUQualifier(
     llvm::function_ref<void(TQ, StringRef, SourceLocation)> Handle) {
   if (TypeQualifiers & TQ_const)
     Handle(TQ_const, "const", TQ_constLoc);
   if (TypeQualifiers & TQ_volatile)
     Handle(TQ_volatile, "volatile", TQ_volatileLoc);
+  if (TypeQualifiers & TQ_optional)
+    Handle(TQ_optional, "_Optional", TQ_optionalLoc);
   if (TypeQualifiers & TQ_restrict)
     Handle(TQ_restrict, "restrict", TQ_restrictLoc);
   if (TypeQualifiers & TQ_unaligned)
     Handle(TQ_unaligned, "unaligned", TQ_unalignedLoc);
 }
 
 void DeclSpec::forEachQualifier(
     llvm::function_ref<void(TQ, StringRef, SourceLocation)> Handle) {

 }
 
 const char *DeclSpec::getSpecifierName(TQ T) {
   switch (T) {
   case DeclSpec::TQ_unspecified: return "unspecified";
   case DeclSpec::TQ_const:       return "const";
   case DeclSpec::TQ_restrict:    return "restrict";
   case DeclSpec::TQ_volatile:    return "volatile";
+  case DeclSpec::TQ_optional:    return "_Optional";
   case DeclSpec::TQ_atomic:      return "_Atomic";
   case DeclSpec::TQ_unaligned:   return "__unaligned";
   }
   llvm_unreachable("Unknown typespec!");
 }
 
 bool DeclSpec::SetStorageClassSpec(Sema &S, SCS SC, SourceLocation Loc,
                                    const char *&PrevSpec,

 bool DeclSpec::SetTypeQual(TQ T, SourceLocation Loc) {
   TypeQualifiers |= T;
 
   switch (T) {
   case TQ_unspecified: break;
   case TQ_const:    TQ_constLoc = Loc; return false;
   case TQ_restrict: TQ_restrictLoc = Loc; return false;
   case TQ_volatile: TQ_volatileLoc = Loc; return false;
+  case TQ_optional: TQ_optionalLoc = Loc; return false;
   case TQ_unaligned: TQ_unalignedLoc = Loc; return false;
   case TQ_atomic:   TQ_atomicLoc = Loc; return false;
   }
 
   llvm_unreachable("Unknown type qualifier!");
 }
 
 bool DeclSpec::setFunctionSpecInline(SourceLocation Loc, const char *&PrevSpec,
void DeclSpec::Finish(Sema &S, const PrintingPolicy &Policy) {
 
   // If decltype(auto) is used, no other type specifiers are permitted.
   if (TypeSpecType == TST_decltype_auto &&
       (getTypeSpecWidth() != TypeSpecifierWidth::Unspecified ||
        TypeSpecComplex != TSC_unspecified ||
        getTypeSpecSign() != TypeSpecifierSign::Unspecified ||
        TypeAltiVecVector || TypeAltiVecPixel || TypeAltiVecBool ||
        TypeQualifiers)) {
-    const unsigned NumLocs = 9;
+    const unsigned NumLocs = 10;
     SourceLocation ExtraLocs[NumLocs] = {
         TSWRange.getBegin(), TSCLoc,       TSSLoc,
         AltiVecLoc,          TQ_constLoc,  TQ_restrictLoc,
-        TQ_volatileLoc,      TQ_atomicLoc, TQ_unalignedLoc};
+        TQ_volatileLoc,      TQ_optionalLoc, TQ_atomicLoc,
+        TQ_unalignedLoc};
     FixItHint Hints[NumLocs];
     SourceLocation FirstLoc;
     for (unsigned I = 0; I != NumLocs; ++I) {
       if (ExtraLocs[I].isValid()) {
         if (FirstLoc.isInvalid() ||
             S.getSourceManager().isBeforeInTranslationUnit(ExtraLocs[I],
                                                            FirstLoc))
           FirstLoc = ExtraLocs[I];

clang/lib/Sema/SemaCodeComplete.cpp

 }
 
 static void AddTypeQualifierResults(DeclSpec &DS, ResultBuilder &Results,
                                     const LangOptions &LangOpts) {
   if (!(DS.getTypeQualifiers() & DeclSpec::TQ_const))
     Results.AddResult("const");
   if (!(DS.getTypeQualifiers() & DeclSpec::TQ_volatile))
     Results.AddResult("volatile");
+  if (!(DS.getTypeQualifiers() & DeclSpec::TQ_optional))
+    Results.AddResult("_Optional");
   if (LangOpts.C99 && !(DS.getTypeQualifiers() & DeclSpec::TQ_restrict))
     Results.AddResult("restrict");
   if (LangOpts.C11 && !(DS.getTypeQualifiers() & DeclSpec::TQ_atomic))
     Results.AddResult("_Atomic");
   if (LangOpts.MSVCCompat && !(DS.getTypeQualifiers() & DeclSpec::TQ_unaligned))
     Results.AddResult("__unaligned");
 }
 

clang/lib/Sema/SemaDecl.cpp

Decl *Sema::ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS,
   if (DeclSpec::TSCS TSCS = DS.getThreadStorageClassSpec())
     Diag(DS.getThreadStorageClassSpecLoc(), DiagID)
       << DeclSpec::getSpecifierName(TSCS);
   if (DS.getTypeQualifiers()) {
     if (DS.getTypeQualifiers() & DeclSpec::TQ_const)
       Diag(DS.getConstSpecLoc(), DiagID) << "const";
     if (DS.getTypeQualifiers() & DeclSpec::TQ_volatile)
       Diag(DS.getConstSpecLoc(), DiagID) << "volatile";
+    if (DS.getTypeQualifiers() & DeclSpec::TQ_optional)
+      Diag(DS.getConstSpecLoc(), DiagID) << "_Optional";
     // Restrict is covered above.
     if (DS.getTypeQualifiers() & DeclSpec::TQ_atomic)
       Diag(DS.getAtomicSpecLoc(), DiagID) << "_Atomic";
     if (DS.getTypeQualifiers() & DeclSpec::TQ_unaligned)
       Diag(DS.getUnalignedSpecLoc(), DiagID) << "__unaligned";
   }
 
   // Warn about ignored type attributes, for example:
if (DS.getTypeQualifiers()) {
         Diag(DS.getConstSpecLoc(), diag::ext_anonymous_struct_union_qualified)
           << Record->isUnion() << "const"
           << FixItHint::CreateRemoval(DS.getConstSpecLoc());
       if (DS.getTypeQualifiers() & DeclSpec::TQ_volatile)
         Diag(DS.getVolatileSpecLoc(),
              diag::ext_anonymous_struct_union_qualified)
           << Record->isUnion() << "volatile"
           << FixItHint::CreateRemoval(DS.getVolatileSpecLoc());
+      if (DS.getTypeQualifiers() & DeclSpec::TQ_optional)
+        Diag(DS.getOptionalSpecLoc(),
+             diag::ext_anonymous_struct_union_qualified)
+          << Record->isUnion() << "_Optional"
+          << FixItHint::CreateRemoval(DS.getOptionalSpecLoc());
       if (DS.getTypeQualifiers() & DeclSpec::TQ_restrict)
         Diag(DS.getRestrictSpecLoc(),
              diag::ext_anonymous_struct_union_qualified)
           << Record->isUnion() << "restrict"
           << FixItHint::CreateRemoval(DS.getRestrictSpecLoc());
       if (DS.getTypeQualifiers() & DeclSpec::TQ_atomic)
         Diag(DS.getAtomicSpecLoc(),
              diag::ext_anonymous_struct_union_qualified)

clang/lib/Sema/SemaDeclCXX.cpp

if (SC == SC_Static) {
     D.setInvalidType();
     SC = SC_None;
   }
 
   if (unsigned TypeQuals = D.getDeclSpec().getTypeQualifiers()) {
     diagnoseIgnoredQualifiers(
         diag::err_constructor_return_type, TypeQuals, SourceLocation(),
         D.getDeclSpec().getConstSpecLoc(), D.getDeclSpec().getVolatileSpecLoc(),
-        D.getDeclSpec().getRestrictSpecLoc(),
+        D.getDeclSpec().getOptionalSpecLoc(), D.getDeclSpec().getRestrictSpecLoc(),
         D.getDeclSpec().getAtomicSpecLoc());
     D.setInvalidType();
   }
 
   checkMethodTypeQualifiers(*this, D, diag::err_invalid_qualified_constructor);
 
   // C++0x [class.ctor]p4:
   //   A constructor shall not be declared with a ref-qualifier.
if (D.getDeclSpec().hasTypeSpecifier())
       Diag(D.getIdentifierLoc(), diag::err_destructor_return_type)
         << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
         << SourceRange(D.getIdentifierLoc());
     else if (unsigned TypeQuals = D.getDeclSpec().getTypeQualifiers()) {
       diagnoseIgnoredQualifiers(diag::err_destructor_return_type, TypeQuals,
                                 SourceLocation(),
                                 D.getDeclSpec().getConstSpecLoc(),
                                 D.getDeclSpec().getVolatileSpecLoc(),
+                                D.getDeclSpec().getOptionalSpecLoc(),
                                 D.getDeclSpec().getRestrictSpecLoc(),
                                 D.getDeclSpec().getAtomicSpecLoc());
       D.setInvalidType();
     }
   }
 
   checkMethodTypeQualifiers(*this, D, diag::err_invalid_qualified_destructor);
 
Decl *Sema::ActOnFriendTypeDecl(Scope *S, const DeclSpec &DS,
   // Any declaration with a type qualifier does not have that form. (It's
   // legal to specify a qualified type as a friend, you just can't write the
   // keywords.)
   if (DS.getTypeQualifiers()) {
     if (DS.getTypeQualifiers() & DeclSpec::TQ_const)
       Diag(DS.getConstSpecLoc(), diag::err_friend_decl_spec) << "const";
     if (DS.getTypeQualifiers() & DeclSpec::TQ_volatile)
       Diag(DS.getVolatileSpecLoc(), diag::err_friend_decl_spec) << "volatile";
+    if (DS.getTypeQualifiers() & DeclSpec::TQ_optional)
+      Diag(DS.getOptionalSpecLoc(), diag::err_friend_decl_spec) << "_Optional";
     if (DS.getTypeQualifiers() & DeclSpec::TQ_restrict)
       Diag(DS.getRestrictSpecLoc(), diag::err_friend_decl_spec) << "restrict";
     if (DS.getTypeQualifiers() & DeclSpec::TQ_atomic)
       Diag(DS.getAtomicSpecLoc(), diag::err_friend_decl_spec) << "_Atomic";
     if (DS.getTypeQualifiers() & DeclSpec::TQ_unaligned)
       Diag(DS.getUnalignedSpecLoc(), diag::err_friend_decl_spec) << "__unaligned";
   }
 

clang/lib/Sema/SemaDeclObjC.cpp

auto resolveTypeReference = [&](TypeOrClassDecl typeDecl, SourceLocation loc)
     // add the '*'.
     if (type->getAs<ObjCInterfaceType>()) {
       SourceLocation starLoc = getLocForEndOfToken(loc);
       D.AddTypeInfo(DeclaratorChunk::getPointer(/*TypeQuals=*/0, starLoc,
                                                 SourceLocation(),
                                                 SourceLocation(),
                                                 SourceLocation(),
                                                 SourceLocation(),
+                                                SourceLocation(),
                                                 SourceLocation()),
                                                 starLoc);
 
       // Diagnose the missing '*'.
       Diag(loc, diag::err_objc_type_arg_missing_star)
         << type
         << FixItHint::CreateInsertion(starLoc, " *");
     }

clang/lib/Sema/SemaOverload.cpp

if (OldMethod && NewMethod &&
     // function yet (because we haven't yet resolved whether this is a static
     // or non-static member function). Add it now, on the assumption that this
     // is a redeclaration of OldMethod.
     auto OldQuals = OldMethod->getMethodQualifiers();
     auto NewQuals = NewMethod->getMethodQualifiers();
     if (!getLangOpts().CPlusPlus14 && NewMethod->isConstexpr() &&
         !isa<CXXConstructorDecl>(NewMethod))
       NewQuals.addConst();
-    // We do not allow overloading based off of '__restrict'.
+    // We do not allow overloading based off of '__restrict' or '_Optional'.
     OldQuals.removeRestrict();
+    OldQuals.removeOptional();
     NewQuals.removeRestrict();
+    NewQuals.removeOptional();
     if (OldQuals != NewQuals)
       return true;
   }
 
   // Though pass_object_size is placed on parameters and takes an argument, we
   // consider it to be a function-level modifier for the sake of function
   // identity. Either the function has one or more parameters with
   // pass_object_size or it doesn't.

clang/lib/Sema/SemaType.cpp

static void diagnoseAndRemoveTypeQualifiers(Sema &S, const DeclSpec &DS,
                                             unsigned RemoveTQs,
                                             unsigned DiagID) {
   // If this occurs outside a template instantiation, warn the user about
   // it; they probably didn't mean to specify a redundant qualifier.
   typedef std::pair<DeclSpec::TQ, SourceLocation> QualLoc;
   for (QualLoc Qual : {QualLoc(DeclSpec::TQ_const, DS.getConstSpecLoc()),
                        QualLoc(DeclSpec::TQ_restrict, DS.getRestrictSpecLoc()),
                        QualLoc(DeclSpec::TQ_volatile, DS.getVolatileSpecLoc()),
+                       QualLoc(DeclSpec::TQ_optional, DS.getOptionalSpecLoc()),
                        QualLoc(DeclSpec::TQ_atomic, DS.getAtomicSpecLoc())}) {
     if (!(RemoveTQs & Qual.first))
       continue;
 
     if (!S.inTemplateInstantiation()) {
       if (TypeQuals & Qual.first)
         S.Diag(Qual.second, DiagID)
           << DeclSpec::getSpecifierName(Qual.first) << TypeSoFar
if (unsigned TypeQuals = DS.getTypeQualifiers()) {
     //   or decltype-specifier, in which case the cv-qualifiers are ignored.
     //
     // There don't appear to be any other contexts in which a cv-qualified
     // reference type could be formed, so the 'ill-formed' clause here appears
     // to never happen.
     if (TypeQuals && Result->isReferenceType()) {
       diagnoseAndRemoveTypeQualifiers(
           S, DS, TypeQuals, Result,
-          DeclSpec::TQ_const | DeclSpec::TQ_volatile | DeclSpec::TQ_atomic,
+          DeclSpec::TQ_const | DeclSpec::TQ_volatile | DeclSpec::TQ_optional | DeclSpec::TQ_atomic,
           diag::warn_typecheck_reference_qualifiers);
     }
 
     // C90 6.5.3 constraints: "The same type qualifier shall not appear more
     // than once in the same specifier-list or qualifier-list, either directly
     // or via one or more typedefs."
     if (!S.getLangOpts().C99 && !S.getLangOpts().CPlusPlus
         && TypeQuals & Result.getCVRQualifiers()) {
       if (TypeQuals & DeclSpec::TQ_const && Result.isConstQualified()) {
         S.Diag(DS.getConstSpecLoc(), diag::ext_duplicate_declspec)
           << "const";
       }
 
       if (TypeQuals & DeclSpec::TQ_volatile && Result.isVolatileQualified()) {
         S.Diag(DS.getVolatileSpecLoc(), diag::ext_duplicate_declspec)
           << "volatile";
       }
 
-      // C90 doesn't have restrict nor _Atomic, so it doesn't force us to
+      // C90 doesn't have restrict, nor _Optional, nor _Atomic, so it doesn't force us to
       // produce a warning in this case.
     }
 
     QualType Qualified = S.BuildQualifiedType(Result, DeclLoc, TypeQuals, &DS);
 
     // If adding qualifiers fails, just use the unqualified type.
     if (Qualified.isNull())
       declarator.setInvalidType(true);

 QualType Sema::BuildQualifiedType(QualType T, SourceLocation Loc,
                                   unsigned CVRAU, const DeclSpec *DS) {
   if (T.isNull())
     return QualType();
 
   // Ignore any attempt to form a cv-qualified reference.
   if (T->isReferenceType())
     CVRAU &=
-        ~(DeclSpec::TQ_const | DeclSpec::TQ_volatile | DeclSpec::TQ_atomic);
+        ~(DeclSpec::TQ_const | DeclSpec::TQ_volatile | DeclSpec::TQ_optional | DeclSpec::TQ_atomic);
 
   // Convert from DeclSpec::TQ to Qualifiers::TQ by just dropping TQ_atomic and
   // TQ_unaligned;
   unsigned CVR = CVRAU & ~(DeclSpec::TQ_atomic | DeclSpec::TQ_unaligned);
 
   // C11 6.7.3/5:
   //   If the same qualifier appears more than once in the same
   //   specifier-qualifier-list, either directly or via one or more typedefs,
done:
 
   // TODO: mark whether we did this inference?
 }
 
 void Sema::diagnoseIgnoredQualifiers(unsigned DiagID, unsigned Quals,
                                      SourceLocation FallbackLoc,
                                      SourceLocation ConstQualLoc,
                                      SourceLocation VolatileQualLoc,
+                                     SourceLocation OptionalQualLoc,
                                      SourceLocation RestrictQualLoc,
                                      SourceLocation AtomicQualLoc,
                                      SourceLocation UnalignedQualLoc) {
   if (!Quals)
     return;
 
   struct Qual {
     const char *Name;
     unsigned Mask;
     SourceLocation Loc;
-  } const QualKinds[5] = {
+  } const QualKinds[6] = {
     { "const", DeclSpec::TQ_const, ConstQualLoc },
     { "volatile", DeclSpec::TQ_volatile, VolatileQualLoc },
+    { "_Optional", DeclSpec::TQ_optional, OptionalQualLoc },
     { "restrict", DeclSpec::TQ_restrict, RestrictQualLoc },
     { "__unaligned", DeclSpec::TQ_unaligned, UnalignedQualLoc },
     { "_Atomic", DeclSpec::TQ_atomic, AtomicQualLoc }
   };
 
   SmallString<32> QualStr;
   unsigned NumQuals = 0;
   SourceLocation Loc;
-  FixItHint FixIts[5];
+  FixItHint FixIts[6];
 
   // Build a string naming the redundant qualifiers.
   for (auto &E : QualKinds) {
     if (Quals & E.Mask) {
       if (!QualStr.empty()) QualStr += ' ';
       QualStr += E.Name;
 
       // If we have a location for the qualifier, offer a fixit.
       SourceLocation QualLoc = E.Loc;
       if (QualLoc.isValid()) {
         FixIts[NumQuals] = FixItHint::CreateRemoval(QualLoc);
         if (Loc.isInvalid() ||
             getSourceManager().isBeforeInTranslationUnit(QualLoc, Loc))
           Loc = QualLoc;
       }
 
       ++NumQuals;
     }
   }
 
   Diag(Loc.isInvalid() ? FallbackLoc : Loc, DiagID)
-    << QualStr << NumQuals << FixIts[0] << FixIts[1] << FixIts[2] << FixIts[3];
+    << QualStr << NumQuals << FixIts[0] << FixIts[1] << FixIts[2] << FixIts[3] << FixIts[4];
 }
 
 // Diagnose pointless type qualifiers on the return type of a function.
 static void diagnoseRedundantReturnTypeQualifiers(Sema &S, QualType RetTy,
                                                   Declarator &D,
                                                   unsigned FunctionChunkIndex) {
   const DeclaratorChunk::FunctionTypeInfo &FTI =
       D.getTypeObject(FunctionChunkIndex).Fun;
for (unsigned OuterChunkIndex = FunctionChunkIndex + 1,
     case DeclaratorChunk::Pointer: {
       DeclaratorChunk::PointerTypeInfo &PTI = OuterChunk.Ptr;
       S.diagnoseIgnoredQualifiers(
           diag::warn_qual_return_type,
           PTI.TypeQuals,
           SourceLocation(),
           PTI.ConstQualLoc,
           PTI.VolatileQualLoc,
+          PTI.OptionalQualLoc,
           PTI.RestrictQualLoc,
           PTI.AtomicQualLoc,
           PTI.UnalignedQualLoc);
       return;
     }
 
     case DeclaratorChunk::Function:
     case DeclaratorChunk::BlockPointer:
static void diagnoseRedundantReturnTypeQualifiers(Sema &S, QualType RetTy,
 
   // Just parens all the way out to the decl specifiers. Diagnose any qualifiers
   // which are present there.
   S.diagnoseIgnoredQualifiers(diag::warn_qual_return_type,
                               D.getDeclSpec().getTypeQualifiers(),
                               D.getIdentifierLoc(),
                               D.getDeclSpec().getConstSpecLoc(),
                               D.getDeclSpec().getVolatileSpecLoc(),
+                              D.getDeclSpec().getOptionalSpecLoc(),
                               D.getDeclSpec().getRestrictSpecLoc(),
                               D.getDeclSpec().getAtomicSpecLoc(),
                               D.getDeclSpec().getUnalignedSpecLoc());
 }
 
 static std::pair<QualType, TypeSourceInfo *>
 InventTemplateParameter(TypeProcessingState &state, QualType T,
                         TypeSourceInfo *TrailingTSI, AutoType *Auto,

lldb/include/lldb/Symbol/Type.h

enum EncodingDataType {
     /// This type is L value reference to a type whose UID is m_encoding_uid.
     eEncodingIsLValueReferenceUID,
     /// This type is R value reference to a type whose UID is m_encoding_uid.
     eEncodingIsRValueReferenceUID,
     /// This type is the type whose UID is m_encoding_uid as an atomic type.
     eEncodingIsAtomicUID,
     /// This type is the synthetic type whose UID is m_encoding_uid.
     eEncodingIsSyntheticUID
+    /// This type is the type whose UID is m_encoding_uid with the _Optional
+    /// qualifier added.
+    eEncodingIsOptionalUID,
   };
 
   enum class ResolveState : unsigned char {
     Unresolved = 0,
     Forward = 1,
     Layout = 2,
     Full = 3
   };

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

TypeSP DWARFASTParserClang::ParseTypeFromDWARF(const SymbolContext &sc,
   switch (tag) {
   case DW_TAG_typedef:
   case DW_TAG_base_type:
   case DW_TAG_pointer_type:
   case DW_TAG_reference_type:
   case DW_TAG_rvalue_reference_type:
   case DW_TAG_const_type:
   case DW_TAG_restrict_type:
+  case DW_TAG_optional_type:
   case DW_TAG_volatile_type:
   case DW_TAG_atomic_type:
   case DW_TAG_unspecified_type: {
     type_sp = ParseTypeModifier(sc, die, attrs);
     break;
   }
 
   case DW_TAG_structure_type:
case DW_TAG_typedef:
     encoding_data_type = Type::eEncodingIsTypedefUID;
     break;
   case DW_TAG_const_type:
     encoding_data_type = Type::eEncodingIsConstUID;
     break;
   case DW_TAG_restrict_type:
     encoding_data_type = Type::eEncodingIsRestrictUID;
     break;
+  case DW_TAG_optional_type:
+    encoding_data_type = Type::eEncodingIsOptionalUID;
+    break;
   case DW_TAG_volatile_type:
     encoding_data_type = Type::eEncodingIsVolatileUID;
     break;
   case DW_TAG_atomic_type:
     encoding_data_type = Type::eEncodingIsAtomicUID;
     break;
   }
 
case DW_TAG_formal_parameter: {
               uint32_t encoding_mask = this_type->GetEncodingMask();
               if (encoding_mask & Type::eEncodingIsPointerUID) {
                 is_static = false;
 
                 if (encoding_mask & (1u << Type::eEncodingIsConstUID))
                   type_quals |= clang::Qualifiers::Const;
                 if (encoding_mask & (1u << Type::eEncodingIsVolatileUID))
                   type_quals |= clang::Qualifiers::Volatile;
+                if (encoding_mask & (1u << Type::eEncodingIsOptionalUID))
+                  type_quals |= clang::Qualifiers::Optional;
               }
             }
           }
           skip = true;
         }
 
         if (!skip) {
           Type *type = die.ResolveTypeUID(param_type_die_form.Reference());

lldb/source/Plugins/SymbolFile/DWARF/DWARFDIE.cpp

case DW_TAG_union_type:
     s.PutCString("union ");
     break;
   case DW_TAG_unspecified_type:
     s.PutCString("unspecified ");
     break;
   case DW_TAG_volatile_type:
     s.PutCString("volatile ");
     break;
+  case DW_TAG_optional_type:
+    s.PutCString("_Optional ");
+    break;
   case DW_TAG_LLVM_ptrauth_type: {
     unsigned key = GetAttributeValueAsUnsigned(DW_AT_LLVM_ptrauth_key, 0);
     bool isAddressDiscriminated = GetAttributeValueAsUnsigned(
         DW_AT_LLVM_ptrauth_address_discriminated, 0);
     unsigned extraDiscriminator =
         GetAttributeValueAsUnsigned(DW_AT_LLVM_ptrauth_extra_discriminator, 0);
     bool isaPointer =
         GetAttributeValueAsUnsigned(DW_AT_LLVM_ptrauth_isa_pointer, 0);

lldb/source/Plugins/SymbolFile/NativePDB/PdbAstBuilder.cpp

if ((pointer.getOptions() & PointerOptions::Const) != PointerOptions::None)
     pointer_type.addConst();
 
   if ((pointer.getOptions() & PointerOptions::Volatile) != PointerOptions::None)
     pointer_type.addVolatile();
 
   if ((pointer.getOptions() & PointerOptions::Restrict) != PointerOptions::None)
     pointer_type.addRestrict();
 
+  if ((pointer.getOptions() & PointerOptions::Optional) != PointerOptions::None)
+    pointer_type.addOptional();
+
   return pointer_type;
 }
 
 clang::QualType
 PdbAstBuilder::CreateModifierType(const ModifierRecord &modifier) {
   clang::QualType unmodified_type = GetOrCreateType(modifier.ModifiedType);
   if (unmodified_type.isNull())
     return {};

lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp

if (!clang_type.IsValid()) {
       type_resolve_state = Type::ResolveState::Forward;
 
     if (udt->isConstType())
       clang_type = clang_type.AddConstModifier();
 
     if (udt->isVolatileType())
       clang_type = clang_type.AddVolatileModifier();
 
+    if (udt->isOptionalType())
+      clang_type = clang_type.AddOptionalModifier();
+
     GetDeclarationForSymbol(type, decl);
     return m_ast.GetSymbolFile()->MakeType(
         type.getSymIndexId(), ConstString(name), udt->getLength(), nullptr,
         LLDB_INVALID_UID, lldb_private::Type::eEncodingIsUID, decl, clang_type,
         type_resolve_state);
   } break;
   case PDB_SymType::Enum: {
     auto enum_type = llvm::dyn_cast<PDBSymbolTypeEnum>(&type);
case PDB_SymType::Enum: {
     }
 
     if (enum_type->isConstType())
       ast_enum = ast_enum.AddConstModifier();
 
     if (enum_type->isVolatileType())
       ast_enum = ast_enum.AddVolatileModifier();
 
+    if (enum_type->isOptionalType())
+      ast_enum = ast_enum.AddOptionalModifier();
+
     GetDeclarationForSymbol(type, decl);
     return m_ast.GetSymbolFile()->MakeType(
         type.getSymIndexId(), ConstString(name), bytes, nullptr,
         LLDB_INVALID_UID, lldb_private::Type::eEncodingIsUID, decl, ast_enum,
         lldb_private::Type::ResolveState::Full);
   } break;
   case PDB_SymType::Typedef: {
     auto type_def = llvm::dyn_cast<PDBSymbolTypeTypedef>(&type);
case PDB_SymType::Typedef: {
     }
 
     if (type_def->isConstType())
       ast_typedef = ast_typedef.AddConstModifier();
 
     if (type_def->isVolatileType())
       ast_typedef = ast_typedef.AddVolatileModifier();
 
+    if (type_def->isOptionalType())
+      ast_typedef = ast_typedef.AddOptionalModifier();
+
     GetDeclarationForSymbol(type, decl);
     std::optional<uint64_t> size;
     if (type_def->getLength())
       size = type_def->getLength();
     return m_ast.GetSymbolFile()->MakeType(
         type_def->getSymIndexId(), ConstString(name), size, nullptr,
         target_type->GetID(), lldb_private::Type::eEncodingIsTypedefUID, decl,
         ast_typedef, lldb_private::Type::ResolveState::Full);
case PDB_SymType::FunctionSig: {
     if (!return_type)
       return nullptr;
     CompilerType return_ast_type = return_type->GetFullCompilerType();
     uint32_t type_quals = 0;
     if (func_sig->isConstType())
       type_quals |= clang::Qualifiers::Const;
     if (func_sig->isVolatileType())
       type_quals |= clang::Qualifiers::Volatile;
+    if (func_sig->isOptionalType())
+      type_quals |= clang::Qualifiers::Optional;
     auto cc = TranslateCallingConvention(func_sig->getCallingConvention());
     CompilerType func_sig_ast_type =
         m_ast.CreateFunctionType(return_ast_type, arg_list.data(),
                                  arg_list.size(), is_variadic, type_quals, cc);
 
     GetDeclarationForSymbol(type, decl);
     return m_ast.GetSymbolFile()->MakeType(
         type.getSymIndexId(), ConstString(name), std::nullopt, nullptr,
CompilerType builtin_ast_type = GetBuiltinTypeForPDBEncodingAndBitSize(
         m_ast, *builtin_type, encoding, bytes.value_or(0) * 8);
 
     if (builtin_type->isConstType())
       builtin_ast_type = builtin_ast_type.AddConstModifier();
 
     if (builtin_type->isVolatileType())
       builtin_ast_type = builtin_ast_type.AddVolatileModifier();
 
+    if (builtin_type->isOptionalType())
+      builtin_ast_type = builtin_ast_type.AddOptionalModifier();
+
     auto type_name = GetPDBBuiltinTypeName(*builtin_type, builtin_ast_type);
 
     return m_ast.GetSymbolFile()->MakeType(
         builtin_type->getSymIndexId(), type_name, bytes, nullptr,
         LLDB_INVALID_UID, lldb_private::Type::eEncodingIsUID, decl,
         builtin_ast_type, lldb_private::Type::ResolveState::Full);
   } break;
   case PDB_SymType::PointerType: {
if (pointer_type->isConstType())
       pointer_ast_type = pointer_ast_type.AddConstModifier();
 
     if (pointer_type->isVolatileType())
       pointer_ast_type = pointer_ast_type.AddVolatileModifier();
 
     if (pointer_type->isRestrictedType())
       pointer_ast_type = pointer_ast_type.AddRestrictModifier();
 
+    if (pointer_type->isOptionalType())
+      pointer_ast_type = pointer_ast_type.AddOptionalModifier();
+
     return m_ast.GetSymbolFile()->MakeType(
         pointer_type->getSymIndexId(), ConstString(), pointer_type->getLength(),
         nullptr, LLDB_INVALID_UID, lldb_private::Type::eEncodingIsUID, decl,
         pointer_ast_type, lldb_private::Type::ResolveState::Full);
   } break;
   default:
     break;
   }

lldb/source/Symbol/Type.cpp

case eEncodingIsLValueReferenceUID:
       s->PutCString(" (unresolved L value reference)");
       break;
     case eEncodingIsRValueReferenceUID:
       s->PutCString(" (unresolved R value reference)");
       break;
     case eEncodingIsSyntheticUID:
       s->PutCString(" (synthetic type)");
       break;
+    case eEncodingIsOptionalUID:
+      s->PutCString(" (unresolved _Optional type)");
+      break;
     }
   }
 }
 
 void Type::Dump(Stream *s, bool show_context, lldb::DescriptionLevel level) {
   s->Printf("%p: ", static_cast<void *>(this));
   s->Indent();
   *s << "Type" << static_cast<const UserID &>(*this) << ' ';
case eEncodingIsLValueReferenceUID:
       s->PutCString(" (unresolved L value reference)");
       break;
     case eEncodingIsRValueReferenceUID:
       s->PutCString(" (unresolved R value reference)");
       break;
     case eEncodingIsSyntheticUID:
       s->PutCString(" (synthetic type)");
       break;
+    case eEncodingIsOptionalUID:
+      s->PutCString(" (unresolved _Optional type)");
+      break;
     }
   }
 
   //
   //  if (m_access)
   //      s->Printf(", access = %u", m_access);
   s->EOL();
 }
std::optional<uint64_t> Type::GetByteSize(ExecutionContextScope *exe_scope) {
   switch (m_encoding_uid_type) {
   case eEncodingInvalid:
   case eEncodingIsSyntheticUID:
     break;
   case eEncodingIsUID:
   case eEncodingIsConstUID:
   case eEncodingIsRestrictUID:
   case eEncodingIsVolatileUID:
+  case eEncodingIsOptionalUID:
   case eEncodingIsAtomicUID:
   case eEncodingIsTypedefUID: {
     Type *encoding_type = GetEncodingType();
     if (encoding_type)
       if (std::optional<uint64_t> size =
               encoding_type->GetByteSize(exe_scope)) {
         m_byte_size = *size;
         m_byte_size_has_value = true;
if (encoding_type) {
             encoding_type->GetForwardCompilerType().AddRestrictModifier();
         break;
 
       case eEncodingIsVolatileUID:
         m_compiler_type =
             encoding_type->GetForwardCompilerType().AddVolatileModifier();
         break;
 
+      case eEncodingIsOptionalUID:
+        m_compiler_type =
+            encoding_type->GetForwardCompilerType().AddOptionalModifier();
+        break;
+
       case eEncodingIsAtomicUID:
         m_compiler_type =
             encoding_type->GetForwardCompilerType().GetAtomicType();
         break;
 
       case eEncodingIsTypedefUID:
         m_compiler_type = encoding_type->GetForwardCompilerType().CreateTypedef(
             m_name.AsCString("__lldb_invalid_typedef_name"),
if (encoding_type) {
         case eEncodingIsRestrictUID:
           m_compiler_type = void_compiler_type.AddRestrictModifier();
           break;
 
         case eEncodingIsVolatileUID:
           m_compiler_type = void_compiler_type.AddVolatileModifier();
           break;
 
+        case eEncodingIsOptionalUID:
+          m_compiler_type = void_compiler_type.AddOptionalModifier();
+          break;
+
         case eEncodingIsAtomicUID:
           m_compiler_type = void_compiler_type.GetAtomicType();
           break;
 
         case eEncodingIsTypedefUID:
           m_compiler_type = void_compiler_type.CreateTypedef(
               m_name.AsCString("__lldb_invalid_typedef_name"),
               GetSymbolFile()->GetDeclContextContainingUID(GetID()), m_payload);

llvm/docs/LangRef.rst

 
 ``DW_TAG_inheritance`` and ``DW_TAG_friend`` are used in the ``elements:``
 field of :ref:`composite types <DICompositeType>` to describe parents and
 friends.
 
 ``DW_TAG_typedef`` is used to provide a name for the ``baseType:``.
 
 ``DW_TAG_pointer_type``, ``DW_TAG_reference_type``, ``DW_TAG_const_type``,
-``DW_TAG_volatile_type``, ``DW_TAG_restrict_type``, ``DW_TAG_atomic_type`` and
-``DW_TAG_immutable_type`` are used to qualify the ``baseType:``.
+``DW_TAG_volatile_type``, ``DW_TAG_restrict_type``, ``DW_TAG_LLVM_optional_type``,
+``DW_TAG_atomic_type`` and ``DW_TAG_immutable_type`` are used to qualify the
+``baseType:``.
 
 Note that the ``void *`` type is expressed as a type derived from NULL.
 
 .. _DICompositeType:
 
 DICompositeType
 """""""""""""""
 

llvm/docs/SourceLevelDebugging.rst

 * DW_TAG_base_type
 * DW_TAG_const_type
 * DW_TAG_immutable_type
 * DW_TAG_file_type
 * DW_TAG_namelist
 * DW_TAG_packed_type
 * DW_TAG_volatile_type
 * DW_TAG_restrict_type
+* DW_TAG_LLVM_optional_type
 * DW_TAG_atomic_type
 * DW_TAG_interface_type
 * DW_TAG_unspecified_type
 * DW_TAG_shared_type
 
 Only entries with a ``DW_AT_name`` attribute are included, and the entry must
 not be a forward declaration (``DW_AT_declaration`` attribute with a non-zero
 value).  For example, using the following code:

llvm/include/llvm/BinaryFormat/Dwarf.def

 HANDLE_DW_TAG(0x0044, coarray_type, 5, DWARF, DW_KIND_TYPE)
 HANDLE_DW_TAG(0x0045, generic_subrange, 5, DWARF, DW_KIND_NONE)
 HANDLE_DW_TAG(0x0046, dynamic_type, 5, DWARF, DW_KIND_TYPE)
 HANDLE_DW_TAG(0x0047, atomic_type, 5, DWARF, DW_KIND_TYPE)
 HANDLE_DW_TAG(0x0048, call_site, 5, DWARF, DW_KIND_NONE)
 HANDLE_DW_TAG(0x0049, call_site_parameter, 5, DWARF, DW_KIND_NONE)
 HANDLE_DW_TAG(0x004a, skeleton_unit, 5, DWARF, DW_KIND_NONE)
 HANDLE_DW_TAG(0x004b, immutable_type, 5, DWARF, DW_KIND_TYPE)
+
 // Vendor extensions:
 HANDLE_DW_TAG(0x4081, MIPS_loop, 0, MIPS, DW_KIND_NONE)
 // Conflicting:
 // HANDLE_DW_TAG(0x4081, HP_array_descriptor, 0, HP, DW_KIND_NONE)
 HANDLE_DW_TAG(0x4101, format_label, 0, GNU, DW_KIND_NONE)
 HANDLE_DW_TAG(0x4102, function_template, 0, GNU, DW_KIND_NONE)
 HANDLE_DW_TAG(0x4103, class_template, 0, GNU, DW_KIND_NONE)
 

 HANDLE_DW_TAG(0x5101, ALTIUM_circ_type, 0, ALTIUM, DW_KIND_NONE)
 HANDLE_DW_TAG(0x5102, ALTIUM_mwa_circ_type, 0, ALTIUM, DW_KIND_NONE)
 HANDLE_DW_TAG(0x5103, ALTIUM_rev_carry_type, 0, ALTIUM, DW_KIND_NONE)
 // M16 __rom qualifier
 HANDLE_DW_TAG(0x5111, ALTIUM_rom, 0, ALTIUM, DW_KIND_NONE)
 
 // LLVM
 HANDLE_DW_TAG(0x6000, LLVM_annotation, 0, LLVM, DW_KIND_NONE)
+HANDLE_DW_TAG(0x6001, LLVM_optional_type, 0, LLVM, DW_KIND_TYPE)
+
 
 // Green Hills.
 HANDLE_DW_TAG(0x8004, GHS_namespace, 0, GHS, DW_KIND_NONE)
 HANDLE_DW_TAG(0x8005, GHS_using_namespace, 0, GHS, DW_KIND_NONE)
 HANDLE_DW_TAG(0x8006, GHS_using_declaration, 0, GHS, DW_KIND_NONE)
 HANDLE_DW_TAG(0x8007, GHS_template_templ_param, 0, GHS, DW_KIND_NONE)
 
 // Unified Parallel C.

llvm/include/llvm/DebugInfo/CodeView/CodeView.h

 };
 
 /// Equivalent to CV_modifier_t.
 /// TODO: Add flag for _Atomic modifier
 enum class ModifierOptions : uint16_t {
   None = 0x0000,
   Const = 0x0001,
   Volatile = 0x0002,
-  Unaligned = 0x0004
+  Unaligned = 0x0004,
+  Optional = 0x0008
 };
 CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(ModifierOptions)
 
 // If the subsection kind has this bit set, then the linker should ignore it.
 enum : uint32_t { SubsectionIgnoreFlag = 0x80000000 };
 
 enum class DebugSubsectionKind : uint32_t {
   None = 0,

 /// Equivalent to misc lfPointerAttr bitfields.
 enum class PointerOptions : uint32_t {
   None = 0x00000000,
   Flat32 = 0x00000100,
   Volatile = 0x00000200,
   Const = 0x00000400,
   Unaligned = 0x00000800,
   Restrict = 0x00001000,
+  Optional = 0x00002000,
   WinRTSmartPointer = 0x00080000,
   LValueRefThisPointer = 0x00100000,
   RValueRefThisPointer = 0x00200000
 };
 CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(PointerOptions)
 
 /// Equivalent to CV_pmtype_e.
 enum class PointerToMemberRepresentation : uint16_t {

llvm/include/llvm/DebugInfo/CodeView/TypeRecord.h

public:
   bool isUnaligned() const {
     return !!(Attrs & uint32_t(PointerOptions::Unaligned));
   }
 
   bool isRestrict() const {
     return !!(Attrs & uint32_t(PointerOptions::Restrict));
   }
 
+  bool isOptional() const {
+    return !!(Attrs & uint32_t(PointerOptions::Optional));
+  }
+
   bool isLValueReferenceThisPtr() const {
     return !!(Attrs & uint32_t(PointerOptions::LValueRefThisPointer));
   }
 
   bool isRValueReferenceThisPtr() const {
     return !!(Attrs & uint32_t(PointerOptions::RValueRefThisPointer));
   }
 

llvm/include/llvm/DebugInfo/DWARF/DWARFTypePrinter.h

DWARFDie appendUnqualifiedNameBefore(DWARFDie D,
                                        std::string *OriginalFullName = nullptr);
 
   void appendUnqualifiedNameAfter(DWARFDie D, DWARFDie Inner,
                                   bool SkipFirstParamIfArtificial = false);
   void appendQualifiedName(DWARFDie D);
   DWARFDie appendQualifiedNameBefore(DWARFDie D);
   bool appendTemplateParameters(DWARFDie D, bool *FirstParameter = nullptr);
   void decomposeConstVolatile(DWARFDie &N, DWARFDie &T, DWARFDie &C,
-                              DWARFDie &V);
+                              DWARFDie &V, DWARFDie &O);
   void appendConstVolatileQualifierAfter(DWARFDie N);
   void appendConstVolatileQualifierBefore(DWARFDie N);
 
   /// Recursively append the DIE type name when applicable.
   void appendUnqualifiedName(DWARFDie D,
                              std::string *OriginalFullName = nullptr);
 
   void appendSubroutineNameAfter(DWARFDie D, DWARFDie Inner,
                                  bool SkipFirstParamIfArtificial, bool Const,
-                                 bool Volatile);
+                                 bool Volatile, bool Optional);
   void appendScopes(DWARFDie D);
 };
 
 } // namespace llvm
 
 #endif // LLVM_DEBUGINFO_DWARF_DWARFTYPEPRINTER_H

llvm/include/llvm/DebugInfo/PDB/DIA/DIARawSymbol.h

public:
   bool hasPrivateSymbols() const override;
   bool isUnalignedType() const override;
   bool isUnreached() const override;
   bool isValueUdt() const override;
   bool isVirtual() const override;
   bool isVirtualBaseClass() const override;
   bool isVirtualInheritance() const override;
   bool isVolatileType() const override;
+  bool isOptionalType() const override;
   bool wasInlined() const override;
   std::string getUnused() const override;
 
 private:
   const DIASession &Session;
   CComPtr<IDiaSymbol> Symbol;
 };
 }
 }
 
 #endif

llvm/include/llvm/DebugInfo/PDB/IPDBRawSymbol.h

public:
   virtual bool hasPrivateSymbols() const = 0;
   virtual bool isUnalignedType() const = 0;
   virtual bool isUnreached() const = 0;
   virtual bool isValueUdt() const = 0;
   virtual bool isVirtual() const = 0;
   virtual bool isVirtualBaseClass() const = 0;
   virtual bool isVirtualInheritance() const = 0;
   virtual bool isVolatileType() const = 0;
+  virtual bool isOptionalType() const = 0;
   virtual bool wasInlined() const = 0;
   virtual std::string getUnused() const = 0;
 };
 
 LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();
 
 } // namespace pdb
 } // namespace llvm
 
 #endif

llvm/include/llvm/DebugInfo/PDB/Native/NativeRawSymbol.h

public:
   bool hasPrivateSymbols() const override;
   bool isUnalignedType() const override;
   bool isUnreached() const override;
   bool isValueUdt() const override;
   bool isVirtual() const override;
   bool isVirtualBaseClass() const override;
   bool isVirtualInheritance() const override;
   bool isVolatileType() const override;
+  bool isOptionalType() const override;
   bool wasInlined() const override;
   std::string getUnused() const override;
 
 protected:
   NativeSession &Session;
   PDB_SymType Tag;
   SymIndexId SymbolId;
 };
 
 } // end namespace pdb
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_PDB_NATIVE_NATIVERAWSYMBOL_H

llvm/include/llvm/DebugInfo/PDB/Native/NativeSymbolEnumerator.h

public:
   SymIndexId getClassParentId() const override;
   SymIndexId getLexicalParentId() const override;
   std::string getName() const override;
   SymIndexId getTypeId() const override;
   PDB_DataKind getDataKind() const override;
   PDB_LocType getLocationType() const override;
   bool isConstType() const override;
   bool isVolatileType() const override;
+  bool isOptionalType() const override;
   bool isUnalignedType() const override;
   Variant getValue() const override;
 
 protected:
   const NativeTypeEnum &Parent;
   codeview::EnumeratorRecord Record;
 };
 
 } // namespace pdb
 } // namespace llvm
 
 #endif // LLVM_DEBUGINFO_PDB_NATIVE_NATIVESYMBOLENUMERATOR_H

llvm/include/llvm/DebugInfo/PDB/Native/NativeTypeArray.h

public:
   void dump(raw_ostream &OS, int Indent, PdbSymbolIdField ShowIdFields,
             PdbSymbolIdField RecurseIdFields) const override;
 
   SymIndexId getArrayIndexTypeId() const override;
 
   bool isConstType() const override;
   bool isUnalignedType() const override;
   bool isVolatileType() const override;
+  bool isOptionalType() const override;
 
   uint32_t getCount() const override;
   SymIndexId getTypeId() const override;
   uint64_t getLength() const override;
 
 protected:
   codeview::ArrayRecord Record;
   codeview::TypeIndex Index;
 };
 
 } // namespace pdb
 } // namespace llvm
 
 #endif

llvm/include/llvm/DebugInfo/PDB/Native/NativeTypeBuiltin.h

public:
 
   PDB_SymType getSymTag() const override;
 
   PDB_BuiltinType getBuiltinType() const override;
   bool isConstType() const override;
   uint64_t getLength() const override;
   bool isUnalignedType() const override;
   bool isVolatileType() const override;
+  bool isOptionalType() const override;
 
 protected:
   NativeSession &Session;
   codeview::ModifierOptions Mods;
   PDB_BuiltinType Type;
   uint64_t Length;
 };
 
 } // namespace pdb
 } // namespace llvm
 
 #endif

llvm/include/llvm/DebugInfo/PDB/Native/NativeTypeEnum.h

public:
   SymIndexId getUnmodifiedTypeId() const override;
   bool hasConstructor() const override;
   bool hasAssignmentOperator() const override;
   bool hasCastOperator() const override;
   uint64_t getLength() const override;
   std::string getName() const override;
   bool isConstType() const override;
   bool isVolatileType() const override;
+  bool isOptionalType() const override;
   bool isUnalignedType() const override;
   bool isNested() const override;
   bool hasOverloadedOperator() const override;
   bool hasNestedTypes() const override;
   bool isIntrinsic() const override;
   bool isPacked() const override;
   bool isScoped() const override;
   SymIndexId getTypeId() const override;

llvm/include/llvm/DebugInfo/PDB/Native/NativeTypeFunctionSig.h

public:
   SymIndexId getTypeId() const override;
   int32_t getThisAdjust() const override;
   bool hasConstructor() const override;
   bool isConstType() const override;
   bool isConstructorVirtualBase() const override;
   bool isCxxReturnUdt() const override;
   bool isUnalignedType() const override;
   bool isVolatileType() const override;
+  bool isOptionalType() const override;
 
 private:
   void initializeArgList(codeview::TypeIndex ArgListTI);
 
   union {
     codeview::MemberFunctionRecord MemberFunc;
     codeview::ProcedureRecord Proc;
   };

llvm/include/llvm/DebugInfo/PDB/Native/NativeTypePointer.h

public:
   uint64_t getLength() const override;
   bool isReference() const override;
   bool isRValueReference() const override;
   bool isPointerToDataMember() const override;
   bool isPointerToMemberFunction() const override;
   SymIndexId getTypeId() const override;
   bool isRestrictedType() const override;
   bool isVolatileType() const override;
+  bool isOptionalType() const override;
   bool isUnalignedType() const override;
 
   bool isSingleInheritance() const override;
   bool isMultipleInheritance() const override;
   bool isVirtualInheritance() const override;
 
 protected:
   bool isMemberPointer() const;
   codeview::TypeIndex TI;
   std::optional<codeview::PointerRecord> Record;
 };
 
 } // namespace pdb
 } // namespace llvm
 
 #endif // LLVM_DEBUGINFO_PDB_NATIVE_NATIVETYPEPOINTER_H

llvm/include/llvm/DebugInfo/PDB/Native/NativeTypeUDT.h

public:
   bool isIntrinsic() const override;
   bool isNested() const override;
   bool isPacked() const override;
   bool isRefUdt() const override;
   bool isScoped() const override;
   bool isValueUdt() const override;
   bool isUnalignedType() const override;
   bool isVolatileType() const override;
+  bool isOptionalType() const override;
 
 protected:
   codeview::TypeIndex Index;
 
   std::optional<codeview::ClassRecord> Class;
   std::optional<codeview::UnionRecord> Union;
   NativeTypeUDT *UnmodifiedType = nullptr;
   codeview::TagRecord *Tag = nullptr;
   std::optional<codeview::ModifierRecord> Modifiers;
 };
 
 } // namespace pdb
 } // namespace llvm
 
 #endif // LLVM_DEBUGINFO_PDB_NATIVE_NATIVETYPEUDT_H

llvm/include/llvm/DebugInfo/PDB/Native/NativeTypeVTShape.h

public:
 
   ~NativeTypeVTShape() override;
 
   void dump(raw_ostream &OS, int Indent, PdbSymbolIdField ShowIdFields,
             PdbSymbolIdField RecurseIdFields) const override;
 
   bool isConstType() const override;
   bool isVolatileType() const override;
+  bool isOptionalType() const override;
   bool isUnalignedType() const override;
   uint32_t getCount() const override;
 
 protected:
   codeview::TypeIndex TI;
   codeview::VFTableShapeRecord Record;
 };
 
 } // namespace pdb
 } // namespace llvm
 
 #endif // LLVM_DEBUGINFO_PDB_NATIVE_NATIVETYPEVTSHAPE_H

llvm/include/llvm/DebugInfo/PDB/PDBSymbolData.h

public:
   FORWARD_SYMBOL_METHOD(getRelativeVirtualAddress)
   FORWARD_SYMBOL_METHOD(getSlot)
   FORWARD_SYMBOL_METHOD(getToken)
   FORWARD_SYMBOL_ID_METHOD(getType)
   FORWARD_SYMBOL_METHOD(isUnalignedType)
   FORWARD_SYMBOL_METHOD(getValue)
   FORWARD_SYMBOL_METHOD(getVirtualAddress)
   FORWARD_SYMBOL_METHOD(isVolatileType)
+  FORWARD_SYMBOL_METHOD(isOptionalType)
 
   std::unique_ptr<IPDBEnumLineNumbers> getLineNumbers() const;
   uint32_t getCompilandId() const;
 };
 } // namespace pdb
 } // namespace llvm
 
 #endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLDATA_H

llvm/include/llvm/DebugInfo/PDB/PDBSymbolFunc.h

public:
   FORWARD_CONCRETE_SYMBOL_ID_METHOD_WITH_NAME(PDBSymbolTypeFunctionSig, getType,
                                               getSignature)
   FORWARD_SYMBOL_METHOD(isUnalignedType)
   FORWARD_SYMBOL_METHOD(getUndecoratedName)
   FORWARD_SYMBOL_METHOD(isVirtual)
   FORWARD_SYMBOL_METHOD(getVirtualAddress)
   FORWARD_SYMBOL_METHOD(getVirtualBaseOffset)
   FORWARD_SYMBOL_METHOD(isVolatileType)
+  FORWARD_SYMBOL_METHOD(isOptionalType)
 
   std::unique_ptr<IPDBEnumLineNumbers> getLineNumbers() const;
   uint32_t getCompilandId() const;
 };
 
 } // namespace pdb
 } // namespace llvm
 
 #endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLFUNC_H

llvm/include/llvm/DebugInfo/PDB/PDBSymbolThunk.h

public:
   FORWARD_SYMBOL_METHOD(getTargetSection)
   FORWARD_SYMBOL_METHOD(getThunkOrdinal)
   FORWARD_SYMBOL_ID_METHOD(getType)
   FORWARD_SYMBOL_METHOD(isUnalignedType)
   FORWARD_SYMBOL_METHOD(isVirtual)
   FORWARD_SYMBOL_METHOD(getVirtualAddress)
   FORWARD_SYMBOL_METHOD(getVirtualBaseOffset)
   FORWARD_SYMBOL_METHOD(isVolatileType)
+  FORWARD_SYMBOL_METHOD(isOptionalType)
 };
 } // namespace pdb
 } // namespace llvm
 
 #endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTHUNK_H

llvm/include/llvm/DebugInfo/PDB/PDBSymbolTypeArray.h

public:
   FORWARD_SYMBOL_METHOD(isConstType)
   FORWARD_SYMBOL_METHOD(getCount)
   FORWARD_SYMBOL_METHOD(getLength)
   FORWARD_SYMBOL_ID_METHOD(getLexicalParent)
   FORWARD_SYMBOL_METHOD(getRank)
   FORWARD_SYMBOL_ID_METHOD_WITH_NAME(getType, getElementType)
   FORWARD_SYMBOL_METHOD(isUnalignedType)
   FORWARD_SYMBOL_METHOD(isVolatileType)
+  FORWARD_SYMBOL_METHOD(isOptionalType)
 };
 
 } // namespace pdb
 } // namespace llvm
 
 #endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEARRAY_H

llvm/include/llvm/DebugInfo/PDB/PDBSymbolTypeBaseClass.h

public:
   FORWARD_SYMBOL_METHOD(isUnalignedType)
 
   FORWARD_SYMBOL_METHOD(isVirtualBaseClass)
   FORWARD_SYMBOL_METHOD(getVirtualBaseDispIndex)
   FORWARD_SYMBOL_METHOD(getVirtualBasePointerOffset)
   // FORWARD_SYMBOL_METHOD(getVirtualBaseTableType)
   FORWARD_SYMBOL_ID_METHOD(getVirtualTableShape)
   FORWARD_SYMBOL_METHOD(isVolatileType)
+  FORWARD_SYMBOL_METHOD(isOptionalType)
 };
 
 } // namespace pdb
 } // namespace llvm
 
 #endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEBASECLASS_H

llvm/include/llvm/DebugInfo/PDB/PDBSymbolTypeBuiltin.h

public:
   void dump(PDBSymDumper &Dumper) const override;
 
   FORWARD_SYMBOL_METHOD(getBuiltinType)
   FORWARD_SYMBOL_METHOD(isConstType)
   FORWARD_SYMBOL_METHOD(getLength)
   FORWARD_SYMBOL_ID_METHOD(getLexicalParent)
   FORWARD_SYMBOL_METHOD(isUnalignedType)
   FORWARD_SYMBOL_METHOD(isVolatileType)
+  FORWARD_SYMBOL_METHOD(isOptionalType)
 };
 
 } // namespace pdb
 } // namespace llvm
 
 #endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEBUILTIN_H

llvm/include/llvm/DebugInfo/PDB/PDBSymbolTypeEnum.h

public:
   FORWARD_SYMBOL_METHOD(isNested)
   FORWARD_SYMBOL_METHOD(hasOverloadedOperator)
   FORWARD_SYMBOL_METHOD(isPacked)
   FORWARD_SYMBOL_METHOD(isScoped)
   FORWARD_CONCRETE_SYMBOL_ID_METHOD_WITH_NAME(PDBSymbolTypeBuiltin, getType,
                                               getUnderlyingType)
   FORWARD_SYMBOL_METHOD(isUnalignedType)
   FORWARD_SYMBOL_METHOD(isVolatileType)
+  FORWARD_SYMBOL_METHOD(isOptionalType)
 };
 
 } // namespace pdb
 } // namespace llvm
 
 #endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEENUM_H

llvm/include/llvm/DebugInfo/PDB/PDBSymbolTypeFunctionSig.h

public:
   FORWARD_SYMBOL_METHOD(isConstType)
   FORWARD_SYMBOL_METHOD(getCount)
   FORWARD_SYMBOL_ID_METHOD(getLexicalParent)
   // FORWARD_SYMBOL_METHOD(getObjectPointerType)
   FORWARD_SYMBOL_METHOD(getThisAdjust)
   FORWARD_SYMBOL_ID_METHOD_WITH_NAME(getType, getReturnType)
   FORWARD_SYMBOL_METHOD(isUnalignedType)
   FORWARD_SYMBOL_METHOD(isVolatileType)
+  FORWARD_SYMBOL_METHOD(isOptionalType)
 };
 
 } // namespace pdb
 } // namespace llvm
 
 #endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEFUNCTIONSIG_H

llvm/include/llvm/DebugInfo/PDB/PDBSymbolTypePointer.h

public:
   FORWARD_SYMBOL_METHOD(isReference)
   FORWARD_SYMBOL_METHOD(isRValueReference)
   FORWARD_SYMBOL_METHOD(isPointerToDataMember)
   FORWARD_SYMBOL_METHOD(isPointerToMemberFunction)
   FORWARD_SYMBOL_ID_METHOD_WITH_NAME(getType, getPointeeType)
   FORWARD_SYMBOL_METHOD(isRestrictedType)
   FORWARD_SYMBOL_METHOD(isUnalignedType)
   FORWARD_SYMBOL_METHOD(isVolatileType)
+  FORWARD_SYMBOL_METHOD(isOptionalType)
 };
 
 } // namespace pdb
 } // namespace llvm
 
 #endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEPOINTER_H

llvm/include/llvm/DebugInfo/PDB/PDBSymbolTypeTypedef.h

public:
   FORWARD_SYMBOL_METHOD(isPacked)
   FORWARD_SYMBOL_METHOD(isReference)
   FORWARD_SYMBOL_METHOD(isScoped)
   FORWARD_SYMBOL_ID_METHOD(getType)
   FORWARD_SYMBOL_METHOD(getUdtKind)
   FORWARD_SYMBOL_METHOD(isUnalignedType)
   FORWARD_SYMBOL_ID_METHOD(getVirtualTableShape)
   FORWARD_SYMBOL_METHOD(isVolatileType)
+  FORWARD_SYMBOL_METHOD(isOptionalType)
 };
 
 } // namespace pdb
 } // namespace llvm
 
 #endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPETYPEDEF_H

llvm/include/llvm/DebugInfo/PDB/PDBSymbolTypeUDT.h

public:
   FORWARD_SYMBOL_METHOD(hasOverloadedOperator)
   FORWARD_SYMBOL_METHOD(isPacked)
   FORWARD_SYMBOL_METHOD(isScoped)
   FORWARD_SYMBOL_METHOD(getUdtKind)
   FORWARD_SYMBOL_METHOD(isUnalignedType)
   FORWARD_SYMBOL_ID_METHOD(getVirtualTableShape)
   FORWARD_SYMBOL_METHOD(isVolatileType)
   FORWARD_SYMBOL_METHOD(getAccess)
+  FORWARD_SYMBOL_METHOD(isOptionalType)
 };
 }
 } // namespace llvm
 
 #endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEUDT_H

llvm/include/llvm/DebugInfo/PDB/PDBSymbolTypeVTable.h

public:
 
   FORWARD_SYMBOL_ID_METHOD(getClassParent)
   FORWARD_SYMBOL_METHOD(getOffset)
   FORWARD_SYMBOL_METHOD(isConstType)
   FORWARD_SYMBOL_ID_METHOD(getLexicalParent)
   FORWARD_SYMBOL_ID_METHOD(getType)
   FORWARD_SYMBOL_METHOD(isUnalignedType)
   FORWARD_SYMBOL_METHOD(isVolatileType)
+  FORWARD_SYMBOL_METHOD(isOptionalType)
 };
 
 } // namespace pdb
 } // namespace llvm
 
 #endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEVTABLE_H

llvm/include/llvm/DebugInfo/PDB/PDBSymbolTypeVTableShape.h

 public:
   void dump(PDBSymDumper &Dumper) const override;
 
   FORWARD_SYMBOL_METHOD(isConstType)
   FORWARD_SYMBOL_METHOD(getCount)
   FORWARD_SYMBOL_ID_METHOD(getLexicalParent)
   FORWARD_SYMBOL_METHOD(isUnalignedType)
   FORWARD_SYMBOL_METHOD(isVolatileType)
+  FORWARD_SYMBOL_METHOD(isOptionalType)
 };
 
 } // namespace pdb
 } // namespace llvm
 
 #endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEVTABLESHAPE_H

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

TypeIndex CodeViewDebug::lowerType(const DIType *Ty, const DIType *ClassTy) {
   case dwarf::DW_TAG_reference_type:
   case dwarf::DW_TAG_rvalue_reference_type:
     return lowerTypePointer(cast<DIDerivedType>(Ty));
   case dwarf::DW_TAG_ptr_to_member_type:
     return lowerTypeMemberPointer(cast<DIDerivedType>(Ty));
   case dwarf::DW_TAG_restrict_type:
   case dwarf::DW_TAG_const_type:
   case dwarf::DW_TAG_volatile_type:
+  case dwarf::DW_TAG_LLVM_optional_type:
   // TODO: add support for DW_TAG_atomic_type here
     return lowerTypeModifier(cast<DIDerivedType>(Ty));
   case dwarf::DW_TAG_subroutine_type:
     if (ClassTy) {
       // The member function type of a member function pointer has no
       // ThisAdjustment.
       return lowerTypeMemberFunction(cast<DISubroutineType>(Ty), ClassTy,
                                      /*ThisAdjustment=*/0,
while (IsModifier && BaseTy) {
     case dwarf::DW_TAG_const_type:
       Mods |= ModifierOptions::Const;
       PO |= PointerOptions::Const;
       break;
     case dwarf::DW_TAG_volatile_type:
       Mods |= ModifierOptions::Volatile;
       PO |= PointerOptions::Volatile;
       break;
+    case dwarf::DW_TAG_LLVM_optional_type:
+      Mods |= ModifierOptions::Optional;
+      PO |= PointerOptions::Optional;
+      break;
     case dwarf::DW_TAG_restrict_type:
       // Only pointer types be marked with __restrict. There is no known flag
       // for __restrict in LF_MODIFIER records.
       PO |= PointerOptions::Restrict;
       break;
     default:
       IsModifier = false;
       break;
void CodeViewDebug::collectMemberInfo(ClassInfo &Info,
   assert((DDTy->getOffsetInBits() % 8) == 0 && "Unnamed bitfield member!");
   uint64_t Offset = DDTy->getOffsetInBits();
   const DIType *Ty = DDTy->getBaseType();
   bool FullyResolved = false;
   while (!FullyResolved) {
     switch (Ty->getTag()) {
     case dwarf::DW_TAG_const_type:
     case dwarf::DW_TAG_volatile_type:
+    case dwarf::DW_TAG_LLVM_optional_type:
       // FIXME: we should apply the qualifier types to the indirect fields
       // rather than dropping them.
       Ty = cast<DIDerivedType>(Ty)->getBaseType();
       break;
     default:
       FullyResolved = true;
       break;
     }

llvm/lib/CodeGen/AsmPrinter/DebugHandlerBase.cpp

uint64_t DebugHandlerBase::getBaseTypeSize(const DIType *Ty) {
   if (!DDTy)
     return Ty->getSizeInBits();
 
   unsigned Tag = DDTy->getTag();
 
   if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef &&
       Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type &&
       Tag != dwarf::DW_TAG_restrict_type && Tag != dwarf::DW_TAG_atomic_type &&
-      Tag != dwarf::DW_TAG_immutable_type)
+      Tag != dwarf::DW_TAG_immutable_type && Tag != dwarf::DW_TAG_LLVM_optional_type)
     return DDTy->getSizeInBits();
 
   DIType *BaseType = DDTy->getBaseType();
 
   if (!BaseType)
     return 0;
 
   // If this is a derived type, go ahead and get the base type, unless it's a
if (auto *DTy = dyn_cast<DIDerivedType>(Ty)) {
     if (T == dwarf::DW_TAG_pointer_type ||
         T == dwarf::DW_TAG_ptr_to_member_type ||
         T == dwarf::DW_TAG_reference_type ||
         T == dwarf::DW_TAG_rvalue_reference_type)
       return true;
     assert(T == dwarf::DW_TAG_typedef || T == dwarf::DW_TAG_const_type ||
            T == dwarf::DW_TAG_volatile_type ||
            T == dwarf::DW_TAG_restrict_type || T == dwarf::DW_TAG_atomic_type ||
-           T == dwarf::DW_TAG_immutable_type);
+           T == dwarf::DW_TAG_immutable_type || T == dwarf::DW_TAG_LLVM_optional_type);
     assert(DTy->getBaseType() && "Expected valid base type");
     return isUnsignedDIType(DTy->getBaseType());
   }
 
   auto *BTy = cast<DIBasicType>(Ty);
   unsigned Encoding = BTy->getEncoding();
   assert((Encoding == dwarf::DW_ATE_unsigned ||
           Encoding == dwarf::DW_ATE_unsigned_char ||

llvm/lib/DWARFLinker/DWARFLinker.cpp

static bool isTypeTag(uint16_t Tag) {
   case dwarf::DW_TAG_base_type:
   case dwarf::DW_TAG_const_type:
   case dwarf::DW_TAG_constant:
   case dwarf::DW_TAG_file_type:
   case dwarf::DW_TAG_namelist:
   case dwarf::DW_TAG_packed_type:
   case dwarf::DW_TAG_volatile_type:
   case dwarf::DW_TAG_restrict_type:
+  case dwarf::DW_TAG_LLVM_optional_type:
   case dwarf::DW_TAG_atomic_type:
   case dwarf::DW_TAG_interface_type:
   case dwarf::DW_TAG_unspecified_type:
   case dwarf::DW_TAG_shared_type:
   case dwarf::DW_TAG_immutable_type:
     return true;
   default:
     break;

llvm/lib/DebugInfo/DWARF/DWARFDie.cpp

if (DWARFDie BaseType = getAttributeValueAsReferencedDie(DW_AT_type))
       if (BaseType.getTag() == DW_TAG_subroutine_type)
         return 2 * PointerSize;
     return PointerSize;
   }
   case DW_TAG_const_type:
   case DW_TAG_immutable_type:
   case DW_TAG_volatile_type:
   case DW_TAG_restrict_type:
+  case DW_TAG_LLVM_optional_type:
   case DW_TAG_typedef: {
     if (DWARFDie BaseType = getAttributeValueAsReferencedDie(DW_AT_type))
       return BaseType.getTypeSize(PointerSize);
     break;
   }
   case DW_TAG_array_type: {
     DWARFDie BaseType = getAttributeValueAsReferencedDie(DW_AT_type);
     if (!BaseType)

llvm/lib/DebugInfo/DWARF/DWARFTypePrinter.cpp

static DWARFDie resolveReferencedType(DWARFDie D,
                                       dwarf::Attribute Attr = DW_AT_type) {
   return D.getAttributeValueAsReferencedDie(Attr).resolveTypeUnitReference();
 }
 static DWARFDie resolveReferencedType(DWARFDie D, DWARFFormValue F) {
   return D.getAttributeValueAsReferencedDie(F).resolveTypeUnitReference();
 }
 DWARFDie DWARFTypePrinter::skipQualifiers(DWARFDie D) {
   while (D && (D.getTag() == DW_TAG_const_type ||
-               D.getTag() == DW_TAG_volatile_type))
+               D.getTag() == DW_TAG_volatile_type ||
+               D.getTag() == DW_TAG_LLVM_optional_type))
     D = resolveReferencedType(D);
   return D;
 }
 
 bool DWARFTypePrinter::needsParens(DWARFDie D) {
   D = skipQualifiers(D);
   return D && (D.getTag() == DW_TAG_subroutine_type ||
                D.getTag() == DW_TAG_array_type);
case DW_TAG_ptr_to_member_type: {
     Word = false;
     break;
   }
   case DW_TAG_LLVM_ptrauth_type:
     appendQualifiedNameBefore(Inner());
     break;
   case DW_TAG_const_type:
   case DW_TAG_volatile_type:
+  case DW_TAG_LLVM_optional_type:
     appendConstVolatileQualifierBefore(D);
     break;
   case DW_TAG_namespace: {
     if (const char *Name = dwarf::toString(D.find(DW_AT_name), nullptr))
       OS << Name;
     else
       OS << "(anonymous namespace)";
     break;

 
 void DWARFTypePrinter::appendUnqualifiedNameAfter(
     DWARFDie D, DWARFDie Inner, bool SkipFirstParamIfArtificial) {
   if (!D)
     return;
   switch (D.getTag()) {
   case DW_TAG_subroutine_type: {
     appendSubroutineNameAfter(D, Inner, SkipFirstParamIfArtificial, false,
-                              false);
+                              false, false);
     break;
   }
   case DW_TAG_array_type: {
     appendArrayType(D);
     break;
   }
   case DW_TAG_const_type:
   case DW_TAG_volatile_type:
+  case DW_TAG_LLVM_optional_type:
     appendConstVolatileQualifierAfter(D);
     break;
   case DW_TAG_ptr_to_member_type:
   case DW_TAG_reference_type:
   case DW_TAG_rvalue_reference_type:
   case DW_TAG_pointer_type: {
     if (needsParens(Inner))
       OS << ')';
bool DWARFTypePrinter::appendTemplateParameters(DWARFDie D,
   }
   if (IsTemplate && *FirstParameter && FirstParameter == &FirstParameterValue) {
     OS << '<';
     EndedWithTemplate = false;
   }
   return IsTemplate;
 }
 void DWARFTypePrinter::decomposeConstVolatile(DWARFDie &N, DWARFDie &T,
-                                              DWARFDie &C, DWARFDie &V) {
+                                              DWARFDie &C, DWARFDie &V, DWARFDie &O) {
+  switch (N.getTag()) {
+  case DW_TAG_const_type:
+    C = N;
+    break;
+  case DW_TAG_volatile_type:
+    V = N;
+    break;
+  case DW_TAG_LLVM_optional_type:
+    O = N;
+    break;
+  }
   (N.getTag() == DW_TAG_const_type ? C : V) = N;
   T = resolveReferencedType(N);
   if (T) {
-    auto Tag = T.getTag();
-    if (Tag == DW_TAG_const_type) {
+    switch (T.getTag()) {
+    case DW_TAG_const_type:
       C = T;
       T = resolveReferencedType(T);
-    } else if (Tag == DW_TAG_volatile_type) {
+      break;
+    case DW_TAG_volatile_type:
       V = T;
       T = resolveReferencedType(T);
+      break;
+    case DW_TAG_LLVM_optional_type:
+      O = T;
+      T = resolveReferencedType(T);
+      break;
     }
   }
 }
 void DWARFTypePrinter::appendConstVolatileQualifierAfter(DWARFDie N) {
   DWARFDie C;
   DWARFDie V;
+  DWARFDie O;
   DWARFDie T;
-  decomposeConstVolatile(N, T, C, V);
+  decomposeConstVolatile(N, T, C, V, O);
   if (T && T.getTag() == DW_TAG_subroutine_type)
     appendSubroutineNameAfter(T, resolveReferencedType(T), false, C.isValid(),
-                              V.isValid());
+                              V.isValid(), O.isValid());
   else
     appendUnqualifiedNameAfter(T, resolveReferencedType(T));
 }
 void DWARFTypePrinter::appendConstVolatileQualifierBefore(DWARFDie N) {
   DWARFDie C;
   DWARFDie V;
+  DWARFDie O;
   DWARFDie T;
-  decomposeConstVolatile(N, T, C, V);
+  decomposeConstVolatile(N, T, C, V, O);
   bool Subroutine = T && T.getTag() == DW_TAG_subroutine_type;
   DWARFDie A = T;
   while (A && A.getTag() == DW_TAG_array_type)
     A = resolveReferencedType(A);
   bool Leading =
       (!A || (A.getTag() != DW_TAG_pointer_type &&
               A.getTag() != llvm::dwarf::DW_TAG_ptr_to_member_type)) &&
       !Subroutine;
   if (Leading) {
     if (C)
       OS << "const ";
     if (V)
       OS << "volatile ";
+    if (O)
+      OS << "_Optional ";
   }
   appendQualifiedNameBefore(T);
   if (!Leading && !Subroutine) {
     Word = true;
     if (C)
       OS << "const";
     if (V) {
       if (C)
         OS << ' ';
       OS << "volatile";
     }
+    if (O) {
+      if (C || V)
+        OS << ' ';
+      OS << "_Optional";
+    }
   }
 }
 void DWARFTypePrinter::appendUnqualifiedName(DWARFDie D,
                                              std::string *OriginalFullName) {
   // FIXME: We should have pretty printers per language. Currently we print
   // everything as if it was C++ and fall back to the TAG type name.
   DWARFDie Inner = appendUnqualifiedNameBefore(D, OriginalFullName);
   appendUnqualifiedNameAfter(D, Inner);
 }
 void DWARFTypePrinter::appendSubroutineNameAfter(
     DWARFDie D, DWARFDie Inner, bool SkipFirstParamIfArtificial, bool Const,
-    bool Volatile) {
+    bool Volatile, bool Optional) {
   DWARFDie FirstParamIfArtificial;
   OS << '(';
   EndedWithTemplate = false;
   bool First = true;
   bool RealFirst = true;
   for (DWARFDie P : D) {
     if (P.getTag() != DW_TAG_formal_parameter &&
         P.getTag() != DW_TAG_unspecified_parameters)
void DWARFTypePrinter::appendSubroutineNameAfter(
   OS << ')';
   if (FirstParamIfArtificial) {
     if (DWARFDie P = FirstParamIfArtificial) {
       if (P.getTag() == DW_TAG_pointer_type) {
         auto CVStep = [&](DWARFDie CV) {
           if (DWARFDie U = resolveReferencedType(CV)) {
             Const |= U.getTag() == DW_TAG_const_type;
             Volatile |= U.getTag() == DW_TAG_volatile_type;
+            Optional |= U.getTag() == DW_TAG_LLVM_optional_type;
             return U;
           }
           return DWARFDie();
         };
         if (DWARFDie CV = CVStep(P)) {
           CVStep(CV);
         }
       }
case CallingConvention::DW_CC_LLVM_X86RegCall:
       break;
     }
   }
 
   if (Const)
     OS << " const";
   if (Volatile)
     OS << " volatile";
+  if (Optional)
+    OS << " _Optional";
   if (D.find(DW_AT_reference))
     OS << " &";
   if (D.find(DW_AT_rvalue_reference))
     OS << " &&";
 
   appendUnqualifiedNameAfter(Inner, resolveReferencedType(Inner));
 }
 void DWARFTypePrinter::appendScopes(DWARFDie D) {

llvm/lib/DebugInfo/PDB/DIA/DIARawSymbol.cpp

 bool DIARawSymbol::isVirtualInheritance() const {
   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isVirtualInheritance);
 }
 
 bool DIARawSymbol::isVolatileType() const {
   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_volatileType);
 }
 
+bool DIARawSymbol::isOptionalType() const {
+  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_optionalType);
+}
+
 bool DIARawSymbol::wasInlined() const {
   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_wasInlined);
 }
 
 std::string DIARawSymbol::getUnused() const {
   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_unused);
 }

llvm/lib/DebugInfo/PDB/Native/NativeRawSymbol.cpp

 bool NativeRawSymbol::isVirtualInheritance() const {
   return false;
 }
 
 bool NativeRawSymbol::isVolatileType() const {
   return false;
 }
 
+bool NativeRawSymbol::isOptionalType() const {
+  return false;
+}
+
 bool NativeRawSymbol::wasInlined() const {
   return false;
 }
 
 std::string NativeRawSymbol::getUnused() const {
   return {};
 }

llvm/lib/DebugInfo/PDB/Native/NativeSymbolEnumerator.cpp

void NativeSymbolEnumerator::dump(raw_ostream &OS, int Indent,
   dumpSymbolField(OS, "name", getName(), Indent);
   dumpSymbolIdField(OS, "typeId", getTypeId(), Indent, Session,
                     PdbSymbolIdField::Type, ShowIdFields, RecurseIdFields);
   dumpSymbolField(OS, "dataKind", getDataKind(), Indent);
   dumpSymbolField(OS, "locationType", getLocationType(), Indent);
   dumpSymbolField(OS, "constType", isConstType(), Indent);
   dumpSymbolField(OS, "unalignedType", isUnalignedType(), Indent);
   dumpSymbolField(OS, "volatileType", isVolatileType(), Indent);
+  dumpSymbolField(OS, "optionalType", isOptionalType(), Indent);
   dumpSymbolField(OS, "value", getValue(), Indent);
 }
 
 SymIndexId NativeSymbolEnumerator::getClassParentId() const {
   return Parent.getSymIndexId();
 }
 
 SymIndexId NativeSymbolEnumerator::getLexicalParentId() const { return 0; }

 PDB_LocType NativeSymbolEnumerator::getLocationType() const {
   return PDB_LocType::Constant;
 }
 
 bool NativeSymbolEnumerator::isConstType() const { return false; }
 
 bool NativeSymbolEnumerator::isVolatileType() const { return false; }
 
+bool NativeSymbolEnumerator::isOptionalType() const { return false; }
+
 bool NativeSymbolEnumerator::isUnalignedType() const { return false; }
 
 Variant NativeSymbolEnumerator::getValue() const {
   const NativeTypeBuiltin &BT = Parent.getUnderlyingBuiltinType();
 
   switch (BT.getBuiltinType()) {
   case PDB_BuiltinType::Int:
   case PDB_BuiltinType::Long:

llvm/lib/DebugInfo/PDB/Native/NativeTypeArray.cpp

void NativeTypeArray::dump(raw_ostream &OS, int Indent,
   dumpSymbolIdField(OS, "lexicalParentId", 0, Indent, Session,
                     PdbSymbolIdField::LexicalParent, ShowIdFields,
                     RecurseIdFields);
   dumpSymbolField(OS, "length", getLength(), Indent);
   dumpSymbolField(OS, "count", getCount(), Indent);
   dumpSymbolField(OS, "constType", isConstType(), Indent);
   dumpSymbolField(OS, "unalignedType", isUnalignedType(), Indent);
   dumpSymbolField(OS, "volatileType", isVolatileType(), Indent);
+  dumpSymbolField(OS, "optionalType", isOptionalType(), Indent);
 }
 
 SymIndexId NativeTypeArray::getArrayIndexTypeId() const {
   return Session.getSymbolCache().findSymbolByTypeIndex(Record.getIndexType());
 }
 
 bool NativeTypeArray::isConstType() const { return false; }
 
 bool NativeTypeArray::isUnalignedType() const { return false; }
 
 bool NativeTypeArray::isVolatileType() const { return false; }
 
+bool NativeTypeArray::isOptionalType() const { return false; }
+
 uint32_t NativeTypeArray::getCount() const {
   NativeRawSymbol &Element =
       Session.getSymbolCache().getNativeSymbolById(getTypeId());
   return getLength() / Element.getLength();
 }
 
 SymIndexId NativeTypeArray::getTypeId() const {
   return Session.getSymbolCache().findSymbolByTypeIndex(
       Record.getElementType());
 }
 
 uint64_t NativeTypeArray::getLength() const { return Record.Size; }

llvm/lib/DebugInfo/PDB/Native/NativeTypeBuiltin.cpp

 
 bool NativeTypeBuiltin::isUnalignedType() const {
   return (Mods & ModifierOptions::Unaligned) != ModifierOptions::None;
 }
 
 bool NativeTypeBuiltin::isVolatileType() const {
   return (Mods & ModifierOptions::Volatile) != ModifierOptions::None;
 }
+
+bool NativeTypeBuiltin::isOptionalType() const {
+  return (Mods & ModifierOptions::Optional) != ModifierOptions::None;
+}

llvm/lib/DebugInfo/PDB/Native/NativeTypeEnum.cpp

void NativeTypeEnum::dump(raw_ostream &OS, int Indent,
   dumpSymbolField(OS, "intrinsic", isIntrinsic(), Indent);
   dumpSymbolField(OS, "nested", isNested(), Indent);
   dumpSymbolField(OS, "packed", isPacked(), Indent);
   dumpSymbolField(OS, "isRefUdt", isRefUdt(), Indent);
   dumpSymbolField(OS, "scoped", isScoped(), Indent);
   dumpSymbolField(OS, "unalignedType", isUnalignedType(), Indent);
   dumpSymbolField(OS, "isValueUdt", isValueUdt(), Indent);
   dumpSymbolField(OS, "volatileType", isVolatileType(), Indent);
+  dumpSymbolField(OS, "optionalType", isOptionalType(), Indent);
 }
 
 std::unique_ptr<IPDBEnumSymbols>
 NativeTypeEnum::findChildren(PDB_SymType Type) const {
   if (Type != PDB_SymType::Data)
     return std::make_unique<NullEnumerator<PDBSymbol>>();
 
   const NativeTypeEnum *ClassParent = nullptr;

 
 bool NativeTypeEnum::isVolatileType() const {
   if (!Modifiers)
     return false;
   return ((Modifiers->getModifiers() & ModifierOptions::Volatile) !=
           ModifierOptions::None);
 }
 
+bool NativeTypeEnum::isOptionalType() const {
+  if (!Modifiers)
+    return false;
+  return ((Modifiers->getModifiers() & ModifierOptions::Optional) !=
+          ModifierOptions::None);
+}
+
 bool NativeTypeEnum::isUnalignedType() const {
   if (!Modifiers)
     return false;
   return ((Modifiers->getModifiers() & ModifierOptions::Unaligned) !=
           ModifierOptions::None);
 }
 
 const NativeTypeBuiltin &NativeTypeEnum::getUnderlyingBuiltinType() const {
   if (UnmodifiedType)
     return UnmodifiedType->getUnderlyingBuiltinType();
 
   return Session.getSymbolCache().getNativeSymbolById<NativeTypeBuiltin>(
       getTypeId());
 }

llvm/lib/DebugInfo/PDB/Native/NativeTypeFunctionSig.cpp

if (IsMemberFunction)
     dumpSymbolField(OS, "thisAdjust", getThisAdjust(), Indent);
   dumpSymbolField(OS, "constructor", hasConstructor(), Indent);
   dumpSymbolField(OS, "constType", isConstType(), Indent);
   dumpSymbolField(OS, "isConstructorVirtualBase", isConstructorVirtualBase(),
                   Indent);
   dumpSymbolField(OS, "isCxxReturnUdt", isCxxReturnUdt(), Indent);
   dumpSymbolField(OS, "unalignedType", isUnalignedType(), Indent);
   dumpSymbolField(OS, "volatileType", isVolatileType(), Indent);
+  dumpSymbolField(OS, "optionalType", isOptionalType(), Indent);
 }
 
 std::unique_ptr<IPDBEnumSymbols>
 NativeTypeFunctionSig::findChildren(PDB_SymType Type) const {
   if (Type != PDB_SymType::FunctionArg)
     return std::make_unique<NullEnumerator<PDBSymbol>>();
 
   auto NET = std::make_unique<NativeEnumTypes>(Session,
bool NativeTypeFunctionSig::isCxxReturnUdt() const {
   FunctionOptions Options =
       IsMemberFunction ? MemberFunc.getOptions() : Proc.getOptions();
   return (Options & FunctionOptions::CxxReturnUdt) != FunctionOptions::None;
 }
 
 bool NativeTypeFunctionSig::isUnalignedType() const { return false; }
 
 bool NativeTypeFunctionSig::isVolatileType() const { return false; }
+
+bool NativeTypeFunctionSig::isOptionalType() const { return false; }

llvm/lib/DebugInfo/PDB/Native/NativeTypePointer.cpp

if (isSingleInheritance())
       dumpSymbolField(OS, "isSingleInheritance", 1, Indent);
     else if (isMultipleInheritance())
       dumpSymbolField(OS, "isMultipleInheritance", 1, Indent);
     else if (isVirtualInheritance())
       dumpSymbolField(OS, "isVirtualInheritance", 1, Indent);
   }
   dumpSymbolField(OS, "unalignedType", isUnalignedType(), Indent);
   dumpSymbolField(OS, "volatileType", isVolatileType(), Indent);
+  dumpSymbolField(OS, "optionalType", isOptionalType(), Indent);
 }
 
 SymIndexId NativeTypePointer::getClassParentId() const {
   if (!isMemberPointer())
     return 0;
 
   assert(Record);
   const MemberPointerInfo &MPI = Record->getMemberInfo();

 
 bool NativeTypePointer::isVolatileType() const {
   if (!Record)
     return false;
   return (Record->getOptions() & PointerOptions::Volatile) !=
          PointerOptions::None;
 }
 
+bool NativeTypePointer::isOptionalType() const {
+  if (!Record)
+    return false;
+  return (Record->getOptions() & PointerOptions::Optional) !=
+         PointerOptions::None;
+}
+
 bool NativeTypePointer::isUnalignedType() const {
   if (!Record)
     return false;
   return (Record->getOptions() & PointerOptions::Unaligned) !=
          PointerOptions::None;
 }
 
 static inline bool isInheritanceKind(const MemberPointerInfo &MPI,

llvm/lib/DebugInfo/PDB/Native/NativeTypeUDT.cpp

void NativeTypeUDT::dump(raw_ostream &OS, int Indent,
   dumpSymbolField(OS, "intrinsic", isIntrinsic(), Indent);
   dumpSymbolField(OS, "nested", isNested(), Indent);
   dumpSymbolField(OS, "packed", isPacked(), Indent);
   dumpSymbolField(OS, "isRefUdt", isRefUdt(), Indent);
   dumpSymbolField(OS, "scoped", isScoped(), Indent);
   dumpSymbolField(OS, "unalignedType", isUnalignedType(), Indent);
   dumpSymbolField(OS, "isValueUdt", isValueUdt(), Indent);
   dumpSymbolField(OS, "volatileType", isVolatileType(), Indent);
+  dumpSymbolField(OS, "optionalType", isOptionalType(), Indent);
 }
 
 std::string NativeTypeUDT::getName() const {
   if (UnmodifiedType)
     return UnmodifiedType->getName();
 
   return std::string(Tag->getName());
 }

 }
 
 bool NativeTypeUDT::isVolatileType() const {
   if (!Modifiers)
     return false;
   return (Modifiers->Modifiers & ModifierOptions::Volatile) !=
          ModifierOptions::None;
 }
+
+bool NativeTypeUDT::isOptionalType() const {
+  if (!Modifiers)
+    return false;
+  return (Modifiers->Modifiers & ModifierOptions::Optional) !=
+         ModifierOptions::None;
+}

llvm/lib/DebugInfo/PDB/Native/NativeTypeVTShape.cpp

void NativeTypeVTShape::dump(raw_ostream &OS, int Indent,
 
   dumpSymbolIdField(OS, "lexicalParentId", 0, Indent, Session,
                     PdbSymbolIdField::LexicalParent, ShowIdFields,
                     RecurseIdFields);
   dumpSymbolField(OS, "count", getCount(), Indent);
   dumpSymbolField(OS, "constType", isConstType(), Indent);
   dumpSymbolField(OS, "unalignedType", isUnalignedType(), Indent);
   dumpSymbolField(OS, "volatileType", isVolatileType(), Indent);
+  dumpSymbolField(OS, "optionalType", isOptionalType(), Indent);
 }
 
 bool NativeTypeVTShape::isConstType() const { return false; }
 
 bool NativeTypeVTShape::isVolatileType() const { return false; }
 
+bool NativeTypeVTShape::isOptionalType() const { return false; }
+
 bool NativeTypeVTShape::isUnalignedType() const { return false; }
 
 uint32_t NativeTypeVTShape::getCount() const { return Record.Slots.size(); }

llvm/lib/IR/Verifier.cpp

CheckDI(N.getTag() == dwarf::DW_TAG_typedef ||
               N.getTag() == dwarf::DW_TAG_pointer_type ||
               N.getTag() == dwarf::DW_TAG_ptr_to_member_type ||
               N.getTag() == dwarf::DW_TAG_reference_type ||
               N.getTag() == dwarf::DW_TAG_rvalue_reference_type ||
               N.getTag() == dwarf::DW_TAG_const_type ||
               N.getTag() == dwarf::DW_TAG_immutable_type ||
               N.getTag() == dwarf::DW_TAG_volatile_type ||
               N.getTag() == dwarf::DW_TAG_restrict_type ||
+              N.getTag() == dwarf::DW_TAG_LLVM_optional_type ||
               N.getTag() == dwarf::DW_TAG_atomic_type ||
               N.getTag() == dwarf::DW_TAG_member ||
               N.getTag() == dwarf::DW_TAG_inheritance ||
               N.getTag() == dwarf::DW_TAG_friend ||
               N.getTag() == dwarf::DW_TAG_set_type,
           "invalid tag", &N);
   if (N.getTag() == dwarf::DW_TAG_ptr_to_member_type) {
     CheckDI(isType(N.getRawExtraData()), "invalid pointer to member type", &N,

llvm/lib/ObjectYAML/CodeViewYAMLTypes.cpp

void ScalarBitSetTraits<PointerOptions>::bitset(IO &IO,
   IO.bitSetCase(Options, "None", PointerOptions::None);
   IO.bitSetCase(Options, "Flat32", PointerOptions::Flat32);
   IO.bitSetCase(Options, "Volatile", PointerOptions::Volatile);
   IO.bitSetCase(Options, "Const", PointerOptions::Const);
   IO.bitSetCase(Options, "Unaligned", PointerOptions::Unaligned);
   IO.bitSetCase(Options, "Restrict", PointerOptions::Restrict);
   IO.bitSetCase(Options, "WinRTSmartPointer",
                 PointerOptions::WinRTSmartPointer);
+  IO.bitSetCase(Options, "Optional", PointerOptions::Optional);
 }
 
 void ScalarBitSetTraits<ModifierOptions>::bitset(IO &IO,
                                                  ModifierOptions &Options) {
   IO.bitSetCase(Options, "None", ModifierOptions::None);
   IO.bitSetCase(Options, "Const", ModifierOptions::Const);
   IO.bitSetCase(Options, "Volatile", ModifierOptions::Volatile);
   IO.bitSetCase(Options, "Unaligned", ModifierOptions::Unaligned);

llvm/lib/Target/BPF/BPFAbstractMemberAccess.cpp

void BPFAbstractMemberAccess::CheckAnonRecordType(DIDerivedType *ParentTy,
   else if (auto *DTy = dyn_cast<DIDerivedType>(Ty))
     return CheckDerivedType(ParentTy, DTy);
 }
 
 static bool SkipDIDerivedTag(unsigned Tag, bool skipTypedef) {
   if (Tag != dwarf::DW_TAG_typedef && Tag != dwarf::DW_TAG_const_type &&
       Tag != dwarf::DW_TAG_volatile_type &&
       Tag != dwarf::DW_TAG_restrict_type &&
+      Tag != dwarf::DW_TAG_LLVM_optional_type &&
       Tag != dwarf::DW_TAG_member)
     return false;
   if (Tag == dwarf::DW_TAG_typedef && !skipTypedef)
     return false;
   return true;
 }
 
 static DIType * stripQualifiers(DIType *Ty, bool skipTypedef = true) {

llvm/lib/Target/BPF/BPFPreserveDIType.cpp

for (auto *Call : PreserveDITypeCalls) {
     if (FlagValue == BPFCoreSharedInfo::BTF_TYPE_ID_LOCAL_RELOC) {
       Reloc = BPFCoreSharedInfo::BTF_TYPE_ID_LOCAL;
     } else {
       Reloc = BPFCoreSharedInfo::BTF_TYPE_ID_REMOTE;
       DIType *Ty = cast<DIType>(MD);
       while (auto *DTy = dyn_cast<DIDerivedType>(Ty)) {
         unsigned Tag = DTy->getTag();
         if (Tag != dwarf::DW_TAG_const_type &&
-            Tag != dwarf::DW_TAG_volatile_type)
+            Tag != dwarf::DW_TAG_volatile_type &&
+            Tag != dwarf::DW_TAG_LLVM_optional_type)
           break;
         Ty = DTy->getBaseType();
       }
 
       if (Ty->getName().empty()) {
         if (isa<DISubroutineType>(Ty))
           report_fatal_error(
               "SubroutineType not supported for BTF_TYPE_ID_REMOTE reloc");

llvm/lib/Target/BPF/BTF.def

 HANDLE_BTF_KIND(12, FUNC)
 HANDLE_BTF_KIND(13, FUNC_PROTO)
 HANDLE_BTF_KIND(14, VAR)
 HANDLE_BTF_KIND(15, DATASEC)
 HANDLE_BTF_KIND(16, FLOAT)
 HANDLE_BTF_KIND(17, DECL_TAG)
 HANDLE_BTF_KIND(18, TYPE_TAG)
 HANDLE_BTF_KIND(19, ENUM64)
+HANDLE_BTF_KIND(20, OPTIONAL)
 
 #undef HANDLE_BTF_KIND

llvm/lib/Target/BPF/BTFDebug.cpp

case dwarf::DW_TAG_volatile_type:
     Kind = BTF::BTF_KIND_VOLATILE;
     break;
   case dwarf::DW_TAG_typedef:
     Kind = BTF::BTF_KIND_TYPEDEF;
     break;
   case dwarf::DW_TAG_restrict_type:
     Kind = BTF::BTF_KIND_RESTRICT;
     break;
+  case dwarf::DW_TAG_LLVM_optional_type:
+    Kind = BTF::BTF_KIND_OPTIONAL;
+    break;
   default:
     llvm_unreachable("Unknown DIDerivedType Tag");
   }
   BTFType.Info = Kind << 24;
 }
 
 /// Used by DW_TAG_pointer_type only.
 BTFTypeDerived::BTFTypeDerived(unsigned NextTypeId, unsigned Tag,
void BTFTypeDerived::completeType(BTFDebug &BDebug) {
 
   if (NeedsFixup || !DTy)
     return;
 
   // The base type for PTR/CONST/VOLATILE could be void.
   const DIType *ResolvedType = DTy->getBaseType();
   if (!ResolvedType) {
     assert((Kind == BTF::BTF_KIND_PTR || Kind == BTF::BTF_KIND_CONST ||
-            Kind == BTF::BTF_KIND_VOLATILE) &&
+            Kind == BTF::BTF_KIND_VOLATILE || Kind == BTF::BTF_KIND_OPTIONAL) &&
            "Invalid null basetype");
     BTFType.Type = 0;
   } else {
     BTFType.Type = BDebug.getTypeId(ResolvedType);
   }
 }
 
 void BTFTypeDerived::emitType(MCStreamer &OS) { BTFTypeBase::emitType(OS); }
if (TmpTypeId >= 0) {
           std::make_unique<BTFTypeDerived>(TmpTypeId, Tag, DTy->getName());
       TypeId = addType(std::move(TypeDEntry), DTy);
     } else {
       auto TypeEntry = std::make_unique<BTFTypeDerived>(DTy, Tag, false);
       TypeId = addType(std::move(TypeEntry), DTy);
     }
   } else if (Tag == dwarf::DW_TAG_typedef || Tag == dwarf::DW_TAG_const_type ||
              Tag == dwarf::DW_TAG_volatile_type ||
-             Tag == dwarf::DW_TAG_restrict_type) {
+             Tag == dwarf::DW_TAG_restrict_type ||
+             Tag == dwarf::DW_TAG_LLVM_optional_type) {
     auto TypeEntry = std::make_unique<BTFTypeDerived>(DTy, Tag, false);
     TypeId = addType(std::move(TypeEntry), DTy);
     if (Tag == dwarf::DW_TAG_typedef)
       processDeclAnnotations(DTy->getAnnotations(), TypeId, -1);
   } else if (Tag != dwarf::DW_TAG_member) {
     return;
   }
 
void BTFDebug::visitMapDefType(const DIType *Ty, uint32_t &TypeId) {
   }
 
   // MapDef type may be a struct type or a non-pointer derived type
   const DIType *OrigTy = Ty;
   while (auto *DTy = dyn_cast<DIDerivedType>(Ty)) {
     auto Tag = DTy->getTag();
     if (Tag != dwarf::DW_TAG_typedef && Tag != dwarf::DW_TAG_const_type &&
         Tag != dwarf::DW_TAG_volatile_type &&
-        Tag != dwarf::DW_TAG_restrict_type)
+        Tag != dwarf::DW_TAG_restrict_type &&
+        Tag != dwarf::DW_TAG_LLVM_optional_type)
       break;
     Ty = DTy->getBaseType();
   }
 
   const auto *CTy = dyn_cast<DICompositeType>(Ty);
   if (!CTy)
     return;
 

llvm/tools/llvm-pdbutil/PrettyBuiltinDumper.cpp

 BuiltinDumper::BuiltinDumper(LinePrinter &P)
     : PDBSymDumper(false), Printer(P) {}
 
 void BuiltinDumper::start(const PDBSymbolTypeBuiltin &Symbol) {
   if (Symbol.isConstType())
     WithColor(Printer, PDB_ColorItem::Keyword).get() << "const ";
   if (Symbol.isVolatileType())
     WithColor(Printer, PDB_ColorItem::Keyword).get() << "volatile ";
+  if (Symbol.isOptionalType())
+    WithColor(Printer, PDB_ColorItem::Keyword).get() << "_Optional ";
   WithColor(Printer, PDB_ColorItem::Type).get() << getTypeName(Symbol);
 }
 
 StringRef BuiltinDumper::getTypeName(const PDBSymbolTypeBuiltin &Symbol) {
   PDB_BuiltinType Type = Symbol.getBuiltinType();
   switch (Type) {
   case PDB_BuiltinType::Float:
     if (Symbol.getLength() == 4)

llvm/tools/llvm-pdbutil/PrettyClassDefinitionDumper.cpp

void ClassDefinitionDumper::prettyPrintClassIntro(const ClassLayout &Layout) {
   const PDBSymbolTypeUDT &Class = Layout.getClass();
 
   if (Layout.getClass().isConstType())
     WithColor(Printer, PDB_ColorItem::Keyword).get() << "const ";
   if (Layout.getClass().isVolatileType())
     WithColor(Printer, PDB_ColorItem::Keyword).get() << "volatile ";
   if (Layout.getClass().isUnalignedType())
     WithColor(Printer, PDB_ColorItem::Keyword).get() << "unaligned ";
+  if (Layout.getClass().isOptionalType())
+    WithColor(Printer, PDB_ColorItem::Keyword).get() << "_Optional ";
 
   WithColor(Printer, PDB_ColorItem::Keyword).get() << Class.getUdtKind() << " ";
   WithColor(Printer, PDB_ColorItem::Type).get() << Class.getName();
   WithColor(Printer, PDB_ColorItem::Comment).get() << " [sizeof = " << Size
                                                    << "]";
   uint32_t BaseCount = Layout.bases().size();
   if (BaseCount > 0) {
     Printer.Indent();

llvm/tools/llvm-pdbutil/PrettyEnumDumper.cpp

 void EnumDumper::start(const PDBSymbolTypeEnum &Symbol) {
   if (Symbol.getUnmodifiedTypeId() != 0) {
     if (Symbol.isConstType())
       WithColor(Printer, PDB_ColorItem::Keyword).get() << "const ";
     if (Symbol.isVolatileType())
       WithColor(Printer, PDB_ColorItem::Keyword).get() << "volatile ";
     if (Symbol.isUnalignedType())
       WithColor(Printer, PDB_ColorItem::Keyword).get() << "unaligned ";
+    if (Symbol.isOptionalType())
+      WithColor(Printer, PDB_ColorItem::Keyword).get() << "_Optional ";
     WithColor(Printer, PDB_ColorItem::Keyword).get() << "enum ";
     WithColor(Printer, PDB_ColorItem::Type).get() << Symbol.getName();
     return;
   }
 
   WithColor(Printer, PDB_ColorItem::Keyword).get() << "enum ";
   WithColor(Printer, PDB_ColorItem::Type).get() << Symbol.getName();
   if (!opts::pretty::NoEnumDefs) {

llvm/tools/llvm-pdbutil/PrettyFunctionDumper.cpp

if (auto ChildEnum = Symbol.getArguments()) {
     }
   }
   Printer << ")";
 
   if (Symbol.isConstType())
     WithColor(Printer, PDB_ColorItem::Keyword).get() << " const";
   if (Symbol.isVolatileType())
     WithColor(Printer, PDB_ColorItem::Keyword).get() << " volatile";
+  if (Symbol.isOptionalType())
+    WithColor(Printer, PDB_ColorItem::Keyword).get() << " _Optional";
 }
 
 void FunctionDumper::start(const PDBSymbolFunc &Symbol, PointerType Pointer) {
   uint64_t FuncStart = Symbol.getVirtualAddress();
   uint64_t FuncEnd = FuncStart + Symbol.getLength();
 
   Printer << "func [";
   WithColor(Printer, PDB_ColorItem::Address).get() << format_hex(FuncStart, 10);
if (auto Arguments = Symbol.getArguments()) {
     if (Signature->isCVarArgs())
       Printer << ", ...";
   }
   Printer << ")";
   if (Symbol.isConstType())
     WithColor(Printer, PDB_ColorItem::Keyword).get() << " const";
   if (Symbol.isVolatileType())
     WithColor(Printer, PDB_ColorItem::Keyword).get() << " volatile";
+  if (Symbol.isOptionalType())
+    WithColor(Printer, PDB_ColorItem::Keyword).get() << " _Optional";
   if (Symbol.isPureVirtual())
     Printer << " = 0";
 }
 
 void FunctionDumper::dump(const PDBSymbolTypeArray &Symbol) {
   auto ElementType = Symbol.getElementType();
 
   ElementType->dump(*this);
if (auto FuncSig = unique_dyn_cast<PDBSymbolTypeFunctionSig>(PointeeType)) {
     PointerType Pointer =
         Symbol.isReference() ? PointerType::Reference : PointerType::Pointer;
     NestedDumper.start(*FuncSig, nullptr, Pointer);
   } else {
     if (Symbol.isConstType())
       WithColor(Printer, PDB_ColorItem::Keyword).get() << "const ";
     if (Symbol.isVolatileType())
       WithColor(Printer, PDB_ColorItem::Keyword).get() << "volatile ";
+    if (Symbol.isOptionalType())
+      WithColor(Printer, PDB_ColorItem::Keyword).get() << "_Optional ";
     PointeeType->dump(*this);
     Printer << (Symbol.isReference() ? "&" : "*");
 
     if (Symbol.getRawSymbol().isRestrictedType())
       WithColor(Printer, PDB_ColorItem::Keyword).get() << " __restrict";
   }
 }
 
 void FunctionDumper::dump(const PDBSymbolTypeUDT &Symbol) {
   WithColor(Printer, PDB_ColorItem::Type).get() << Symbol.getName();
 }

llvm/tools/llvm-pdbutil/PrettyTypeDumper.cpp

static void printClassDecl(LinePrinter &Printer,
                            const PDBSymbolTypeUDT &Class) {
   if (Class.getUnmodifiedTypeId() != 0) {
     if (Class.isConstType())
       WithColor(Printer, PDB_ColorItem::Keyword).get() << "const ";
     if (Class.isVolatileType())
       WithColor(Printer, PDB_ColorItem::Keyword).get() << "volatile ";
     if (Class.isUnalignedType())
       WithColor(Printer, PDB_ColorItem::Keyword).get() << "unaligned ";
+    if (Class.isOptionalType())
+      WithColor(Printer, PDB_ColorItem::Keyword).get() << "_Optional ";
   }
   WithColor(Printer, PDB_ColorItem::Keyword).get() << Class.getUdtKind() << " ";
   WithColor(Printer, PDB_ColorItem::Type).get() << Class.getName();
 }
 
 void TypeDumper::start(const PDBSymbolExe &Exe) {
   if (opts::pretty::Enums)
     dumpSymbolCategory<PDBSymbolTypeEnum>(Printer, Exe, *this, "Enums");

llvm/tools/llvm-pdbutil/PrettyTypedefDumper.cpp

void TypedefDumper::dump(const PDBSymbolTypeEnum &Symbol) {
   WithColor(Printer, PDB_ColorItem::Type).get() << " " << Symbol.getName();
 }
 
 void TypedefDumper::dump(const PDBSymbolTypePointer &Symbol) {
   if (Symbol.isConstType())
     WithColor(Printer, PDB_ColorItem::Keyword).get() << "const ";
   if (Symbol.isVolatileType())
     WithColor(Printer, PDB_ColorItem::Keyword).get() << "volatile ";
+  if (Symbol.isOptionalType())
+    WithColor(Printer, PDB_ColorItem::Keyword).get() << "_Optional ";
   auto PointeeType = Symbol.getPointeeType();
   if (auto FuncSig = unique_dyn_cast<PDBSymbolTypeFunctionSig>(PointeeType)) {
     FunctionDumper::PointerType Pointer = FunctionDumper::PointerType::Pointer;
     if (Symbol.isReference())
       Pointer = FunctionDumper::PointerType::Reference;
     FunctionDumper NestedDumper(Printer);
     NestedDumper.start(*FuncSig, nullptr, Pointer);
   } else {

llvm/tools/llvm-pdbutil/PrettyVariableDumper.cpp

if (auto Arguments = Symbol.getArguments()) {
     }
   }
   Printer << ")";
 
   if (Symbol.isConstType())
     WithColor(Printer, PDB_ColorItem::Keyword).get() << " const";
   if (Symbol.isVolatileType())
     WithColor(Printer, PDB_ColorItem::Keyword).get() << " volatile";
+  if (Symbol.isOptionalType())
+    WithColor(Printer, PDB_ColorItem::Keyword).get() << " _Optional";
 
   if (Symbol.getRawSymbol().isRestrictedType())
     WithColor(Printer, PDB_ColorItem::Keyword).get() << " __restrict";
 }
 
 void VariableDumper::dump(const PDBSymbolTypePointer &Symbol) {
   auto PointeeType = Symbol.getPointeeType();
   if (!PointeeType)
     return;
   PointeeType->dump(*this);
   if (auto FuncSig = unique_dyn_cast<PDBSymbolTypeFunctionSig>(PointeeType)) {
     // A hack to get the calling convention in the right spot.
     Printer << " (";
     PDB_CallingConv CC = FuncSig->getCallingConvention();
     WithColor(Printer, PDB_ColorItem::Keyword).get() << CC << " ";
   } else if (isa<PDBSymbolTypeArray>(PointeeType)) {
     Printer << " (";
   }
   Printer << (Symbol.isReference() ? "&" : "*");
   if (Symbol.isConstType())
     WithColor(Printer, PDB_ColorItem::Keyword).get() << " const ";
   if (Symbol.isVolatileType())
     WithColor(Printer, PDB_ColorItem::Keyword).get() << " volatile ";
+  if (Symbol.isOptionalType())
+    WithColor(Printer, PDB_ColorItem::Keyword).get() << " _Optional ";
 
   if (Symbol.getRawSymbol().isRestrictedType())
     WithColor(Printer, PDB_ColorItem::Keyword).get() << " __restrict ";
 }
 
 void VariableDumper::dumpRight(const PDBSymbolTypePointer &Symbol) {
   auto PointeeType = Symbol.getPointeeType();
   assert(PointeeType);

llvm/unittests/DebugInfo/PDB/PDBApiTest.cpp

public:
   MOCK_SYMBOL_ACCESSOR(hasPrivateSymbols)
   MOCK_SYMBOL_ACCESSOR(isUnalignedType)
   MOCK_SYMBOL_ACCESSOR(isUnreached)
   MOCK_SYMBOL_ACCESSOR(isValueUdt)
   MOCK_SYMBOL_ACCESSOR(isVirtual)
   MOCK_SYMBOL_ACCESSOR(isVirtualBaseClass)
   MOCK_SYMBOL_ACCESSOR(isVirtualInheritance)
   MOCK_SYMBOL_ACCESSOR(isVolatileType)
+  MOCK_SYMBOL_ACCESSOR(isOptionalType)
   MOCK_SYMBOL_ACCESSOR(getValue)
   MOCK_SYMBOL_ACCESSOR(wasInlined)
   MOCK_SYMBOL_ACCESSOR(getUnused)
 
 private:
   PDB_SymType Type;
 };
 

mlir/include/mlir/IR/Types.h

static T getEmptyKey() {
     return T::getFromOpaquePointer(pointer);
   }
   static T getTombstoneKey() {
     const void *pointer = llvm::DenseMapInfo<const void *>::getTombstoneKey();
     return T::getFromOpaquePointer(pointer);
   }
 };
 
-/// We align TypeStorage by 8, so allow LLVM to steal the low bits.
+/// We align TypeStorage by 16, so allow LLVM to steal the low bits.
 template <>
 struct PointerLikeTypeTraits<mlir::Type> {
 public:
   static inline void *getAsVoidPointer(mlir::Type I) {
     return const_cast<void *>(I.getAsOpaquePointer());
   }
   static inline mlir::Type getFromVoidPointer(void *P) {
     return mlir::Type::getFromOpaquePointer(P);
   }
-  static constexpr int NumLowBitsAvailable = 3;
+  static constexpr int NumLowBitsAvailable = 4;
 };
 
 /// Add support for llvm style casts.
 /// We provide a cast between To and From if From is mlir::Type or derives from
 /// it
 template <typename To, typename From>
 struct CastInfo<
     To, From,

mlir/include/mlir/Support/TypeID.h

 template <>
 struct PointerLikeTypeTraits<mlir::TypeID> {
   static inline void *getAsVoidPointer(mlir::TypeID info) {
     return const_cast<void *>(info.getAsOpaquePointer());
   }
   static inline mlir::TypeID getFromVoidPointer(void *ptr) {
     return mlir::TypeID::getFromOpaquePointer(ptr);
   }
-  static constexpr int NumLowBitsAvailable = 3;
+  static constexpr int NumLowBitsAvailable = 4;
 };
 
 } // namespace llvm
 
 #endif // MLIR_SUPPORT_TYPEID_H