[Attribute] Add clang frame_pointer attribute

[steplong]

Summary

Add the ability to put attribute((frame_pointer(arg))) on functions.
arg is only allowed to be none, non_leaf, or all. Depends on D125719.
This patch is needed for D125723 to allow removing or adding the
attribute "frame-pointer"="foo" from a function.

[steplong]

Abandoning in favor of D126984

clang/include/clang/Basic/Attr.td

 }
 
 def MinSize : InheritableAttr {
   let Spellings = [Clang<"minsize">];
   let Subjects = SubjectList<[Function, ObjCMethod], ErrorDiag>;
   let Documentation = [Undocumented];
 }
 
+def FramePointer : InheritableAttr {
+  // This attribute has no spellings as it is only ever created implicitly.
+  let Spellings = [];
+  let Subjects = SubjectList<[Function]>;
+  let Args = [EnumArgument<"Kind", "Kind",
+                ["none", "non_leaf", "all"],
+                ["None", "NonLeaf", "All"]>];
+  let Documentation = [Undocumented];
+}
+
 def FlagEnum : InheritableAttr {
   let Spellings = [Clang<"flag_enum">];
   let Subjects = SubjectList<[Enum]>;
   let Documentation = [FlagEnumDocs];
   let SimpleHandler = 1;
 }
 
 def EnumExtensibility : InheritableAttr {

clang/include/clang/Basic/DiagnosticSemaKinds.td

 def err_hlsl_operator_unsupported : Error<
   "the '%select{&|*|->}0' operator is unsupported in HLSL">;
 
 // Layout randomization diagnostics.
 def err_non_designated_init_used : Error<
   "a randomized struct can only be initialized with a designated initializer">;
 def err_cast_from_randomized_struct : Error<
   "casting from randomized structure pointer type %0 to %1">;
+
+def warn_frame_pointer_type_not_supported : Warning<
+  "%0 frame_pointer argument not supported: %1">,
+  InGroup<IgnoredAttributes>;
 } // end of sema component.

clang/lib/CodeGen/CodeGenModule.cpp

void CodeGenModule::SetLLVMFunctionAttributes(GlobalDecl GD,
                                               const CGFunctionInfo &Info,
                                               llvm::Function *F, bool IsThunk) {
   unsigned CallingConv;
   llvm::AttributeList PAL;
   ConstructAttributeList(F->getName(), Info, GD, PAL, CallingConv,
                          /*AttrOnCallSite=*/false, IsThunk);
   F->setAttributes(PAL);
   F->setCallingConv(static_cast<llvm::CallingConv::ID>(CallingConv));
+  if (!GD.getDecl())
+    return;
+
+  if (GD.getDecl()->hasAttr<FramePointerAttr>()) {
+    F->removeFnAttr("frame-pointer");
+    FramePointerAttr *Attr = GD.getDecl()->getAttr<FramePointerAttr>();
+    switch (Attr->getKind()) {
+    case FramePointerAttr::None:
+      F->addFnAttr("frame-pointer", "none");
+      break;
+    case FramePointerAttr::NonLeaf:
+      F->addFnAttr("frame-pointer", "non-leaf");
+      break;
+    case FramePointerAttr::All:
+      F->addFnAttr("frame-pointer", "all");
+      break;
+    }
+  }
 }
 
 static void removeImageAccessQualifier(std::string& TyName) {
   std::string ReadOnlyQual("__read_only");
   std::string::size_type ReadOnlyPos = TyName.find(ReadOnlyQual);
   if (ReadOnlyPos != std::string::npos)
     // "+ 1" for the space after access qualifier.
     TyName.erase(ReadOnlyPos, ReadOnlyQual.size() + 1);

clang/lib/Sema/SemaDeclAttr.cpp

static void handleSwiftAsyncAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
   auto *AsyncAttr =
       ::new (S.Context) SwiftAsyncAttr(S.Context, AL, Kind, Idx);
   D->addAttr(AsyncAttr);
 
   if (auto *ErrorAttr = D->getAttr<SwiftAsyncErrorAttr>())
     checkSwiftAsyncErrorBlock(S, D, ErrorAttr, AsyncAttr);
 }
 
+static void handleFramePointer(Sema &S, Decl *D, const ParsedAttr &AL) {
+  if (!AL.isArgIdent(0)) {
+    S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
+        << AL << 1 << AANT_ArgumentIdentifier;
+    return;
+  }
+
+  FramePointerAttr::Kind Kind;
+  IdentifierInfo *II = AL.getArgAsIdent(0)->Ident;
+  if (!FramePointerAttr::ConvertStrToKind(II->getName(), Kind)) {
+    S.Diag(AL.getLoc(), diag::warn_frame_pointer_type_not_supported) << AL
+                                                                     << II;
+    return;
+  }
+
+  D->addAttr(::new (S.Context) FramePointerAttr(S.Context, AL, Kind));
+}
+
 //===----------------------------------------------------------------------===//
 // Microsoft specific attribute handlers.
 //===----------------------------------------------------------------------===//
 
 UuidAttr *Sema::mergeUuidAttr(Decl *D, const AttributeCommonInfo &CI,
                               StringRef UuidAsWritten, MSGuidDecl *GuidDecl) {
   if (const auto *UA = D->getAttr<UuidAttr>()) {
     if (declaresSameEntity(UA->getGuidDecl(), GuidDecl))
static void ProcessDeclAttribute(Sema &S, Scope *scope, Decl *D,
 
   case ParsedAttr::AT_BuiltinAlias:
     handleBuiltinAliasAttr(S, D, AL);
     break;
 
   case ParsedAttr::AT_UsingIfExists:
     handleSimpleAttribute<UsingIfExistsAttr>(S, D, AL);
     break;
+
+  case ParsedAttr::AT_FramePointer:
+    handleFramePointer(S, D, AL);
+    break;
   }
 }
 
 /// ProcessDeclAttributeList - Apply all the decl attributes in the specified
 /// attribute list to the specified decl, ignoring any type attributes.
 void Sema::ProcessDeclAttributeList(Scope *S, Decl *D,
                                     const ParsedAttributesView &AttrList,
                                     bool IncludeCXX11Attributes) {