[demangler] Add co_await demangling

[urnathan]

Summary

The demangler doesn't understand 'aw' as an operator name. This adds the necessary smarts -- you may use this as an operator function name, but not as an expression operator.

[iains]

Thanks!
you added it before I had a chance to raise the "missing" PR.
LGTM, the demangled output agrees with binutils for the test cases.

libcxxabi/src/demangle/ItaniumDemangle.h

enum OIKind : unsigned char {
       Binary,      // Binary: lhs @ rhs
       Array,       // Array index:  lhs [ rhs ]
       Member,      // Member access: lhs @ rhs
       New,         // New
       Del,         // Delete
       Call,        // Function call: expr (expr*)
       CCast,       // C cast: (type)expr
       Conditional, // Conditional: expr ? expr : expr
+      NameOnly,    // Overload only, not allowed in expression.
       // Below do not have operator names
       NamedCast, // Named cast, @<type>(expr)
       OfIdOp,    // alignof, sizeof, typeid
 
       Unnameable = NamedCast,
     };
     char Enc[2];      // Encoding
     OIKind Kind;      // Kind of operator
AbstractManglingParser<Derived, Alloc>::parseOperatorEncoding() {
   static const OperatorInfo Ops[] = {
       // Keep ordered by encoding
       {"aN", OperatorInfo::Binary, false, "operator&="},
       {"aS", OperatorInfo::Binary, false, "operator="},
       {"aa", OperatorInfo::Binary, false, "operator&&"},
       {"ad", OperatorInfo::Prefix, false, "operator&"},
       {"an", OperatorInfo::Binary, false, "operator&"},
       {"at", OperatorInfo::OfIdOp, /*Type*/ true, "alignof ("},
+      {"aw", OperatorInfo::NameOnly, false, "operator co_await"},
       {"az", OperatorInfo::OfIdOp, /*Type*/ false, "alignof ("},
       {"cc", OperatorInfo::NamedCast, false, "const_cast"},
       {"cl", OperatorInfo::Call, false, "operator()"},
       {"cm", OperatorInfo::Binary, false, "operator,"},
       {"co", OperatorInfo::Prefix, false, "operator~"},
       {"cv", OperatorInfo::CCast, false, "operator"}, // C Cast
       {"dV", OperatorInfo::Binary, false, "operator/="},
       {"da", OperatorInfo::Del, /*Ary*/ true, "operator delete[]"},
if (Op) {
     case OperatorInfo::OfIdOp: {
       // [sizeof/alignof/typeid] ( <type>|<expr> )
       Node *Arg =
           Op->getFlag() ? getDerived().parseType() : getDerived().parseExpr();
       if (!Arg)
         return nullptr;
       return make<EnclosingExpr>(Sym, Arg, ")");
     }
+    case OperatorInfo::NameOnly: {
+      // Not valid as an expression operand.
+      return nullptr;
+    }
     }
     DEMANGLE_UNREACHABLE;
   }
 
   if (numLeft() < 2)
     return nullptr;
 
   if (look() == 'L')

libcxxabi/test/test_demangle.pass.cpp

     {"_ZN2FnIXgs4BaseEX4BaseEEEvv", "void Fn<::Base, Base>()"},
 
     {"_ZN2FnIXgsnw_iEEXna_ipiLi4EEEEEvv", "void Fn<::new int, new[] int(4)>()"},
     {"_ZN2FnIXnwLj4E_iEEXgsnaLj4E_ipiLi4EEEEEvv", "void Fn<new(4u) int, ::new[](4u) int(4)>()"},
     {"_ZN2FnIXgsdlLi4EEXdaLi4EEEEvv", "void Fn<::delete 4, delete[] 4>()"},
     {"_ZN2FnIXdlLj4EEXgsdaLj4EEEEvv", "void Fn<delete 4u, ::delete[] 4u>()"},
 
     {"_Z3TPLIiET_S0_", "int TPL<int>(int)"},
+
+    {"_ZN1XawEv", "X::operator co_await()"},
 };
 
 const unsigned N = sizeof(cases) / sizeof(cases[0]);
 
 struct FPLiteralCase {
   const char* mangled;
   // There are four possible demanglings of a given float.
   std::string expecting[4];
#endif
 
     "_ZN3TPLS_E",
     "_ZN3CLSIiEIiEE",
     "_ZN3CLSDtLi0EEE",
     "_ZN3CLSIiEEvNS_T_Ev",
 
     "_ZN1fIiEEvNTUt_E",
     "_ZNDTUt_Ev",
+
+    "_ZN1fIXawLi0EEEEvv",
 };
 
 const unsigned NI = sizeof(invalid_cases) / sizeof(invalid_cases[0]);
 
 void test() {
   std::size_t len = 0;
   char* buf = nullptr;
   bool failed = false;

llvm/include/llvm/Demangle/ItaniumDemangle.h

enum OIKind : unsigned char {
       Binary,      // Binary: lhs @ rhs
       Array,       // Array index:  lhs [ rhs ]
       Member,      // Member access: lhs @ rhs
       New,         // New
       Del,         // Delete
       Call,        // Function call: expr (expr*)
       CCast,       // C cast: (type)expr
       Conditional, // Conditional: expr ? expr : expr
+      NameOnly,    // Overload only, not allowed in expression.
       // Below do not have operator names
       NamedCast, // Named cast, @<type>(expr)
       OfIdOp,    // alignof, sizeof, typeid
 
       Unnameable = NamedCast,
     };
     char Enc[2];      // Encoding
     OIKind Kind;      // Kind of operator
AbstractManglingParser<Derived, Alloc>::parseOperatorEncoding() {
   static const OperatorInfo Ops[] = {
       // Keep ordered by encoding
       {"aN", OperatorInfo::Binary, false, "operator&="},
       {"aS", OperatorInfo::Binary, false, "operator="},
       {"aa", OperatorInfo::Binary, false, "operator&&"},
       {"ad", OperatorInfo::Prefix, false, "operator&"},
       {"an", OperatorInfo::Binary, false, "operator&"},
       {"at", OperatorInfo::OfIdOp, /*Type*/ true, "alignof ("},
+      {"aw", OperatorInfo::NameOnly, false, "operator co_await"},
       {"az", OperatorInfo::OfIdOp, /*Type*/ false, "alignof ("},
       {"cc", OperatorInfo::NamedCast, false, "const_cast"},
       {"cl", OperatorInfo::Call, false, "operator()"},
       {"cm", OperatorInfo::Binary, false, "operator,"},
       {"co", OperatorInfo::Prefix, false, "operator~"},
       {"cv", OperatorInfo::CCast, false, "operator"}, // C Cast
       {"dV", OperatorInfo::Binary, false, "operator/="},
       {"da", OperatorInfo::Del, /*Ary*/ true, "operator delete[]"},
if (Op) {
     case OperatorInfo::OfIdOp: {
       // [sizeof/alignof/typeid] ( <type>|<expr> )
       Node *Arg =
           Op->getFlag() ? getDerived().parseType() : getDerived().parseExpr();
       if (!Arg)
         return nullptr;
       return make<EnclosingExpr>(Sym, Arg, ")");
     }
+    case OperatorInfo::NameOnly: {
+      // Not valid as an expression operand.
+      return nullptr;
+    }
     }
     DEMANGLE_UNREACHABLE;
   }
 
   if (numLeft() < 2)
     return nullptr;
 
   if (look() == 'L')