[Attribute] Add clang optsize attribute

[steplong]

Summary

Add the ability to put __attribute__((optsize)) on functions. Depends on D125720.
This patch is needed by D125723 to allow removing or adding attribute optsize
on a function.

[steplong]

Abandoning in favor of D126984

clang/include/clang/Basic/Attr.td

def FramePointer : InheritableAttr {
   let Spellings = [];
   let Subjects = SubjectList<[Function]>;
   let Args = [EnumArgument<"Kind", "Kind",
                 ["none", "non_leaf", "all"],
                 ["None", "NonLeaf", "All"]>];
   let Documentation = [Undocumented];
 }
 
+def OptimizeSize: InheritableAttr {
+  // This attribute has no spellings as it is only ever created implicitly.
+  let Spellings = [];
+  let Subjects = SubjectList<[Function]>;
+  let Args = [EnumArgument<"Kind", "Kind",
+                ["off", "on"],
+                ["Off", "On"]>];
+  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/lib/CodeGen/CodeGenModule.cpp

void CodeGenModule::SetLLVMFunctionAttributes(GlobalDecl GD,
   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;
 
+  bool HasOptnone = GD.getDecl()->hasAttr<OptimizeNoneAttr>();
+  bool HasOptsizeOn = false;
+  bool HasOptsizeOff = false;
+  if (GD.getDecl()->hasAttr<OptimizeSizeAttr>()) {
+    OptimizeSizeAttr *Attr = GD.getDecl()->getAttr<OptimizeSizeAttr>();
+    HasOptsizeOn = Attr->getKind() == OptimizeSizeAttr::On;
+    HasOptsizeOff = Attr->getKind() == OptimizeSizeAttr::Off;
+  }
+  if (HasOptsizeOn && !HasOptnone)
+    F->addFnAttr(llvm::Attribute::OptimizeForSize);
+  if (HasOptsizeOff)
+    F->removeFnAttr(llvm::Attribute::OptimizeForSize);
+
   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:

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 handleOptimizeSizeAttr(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;
+  }
+
+  OptimizeSizeAttr::Kind Kind;
+  IdentifierInfo *II = AL.getArgAsIdent(0)->Ident;
+  OptimizeSizeAttr::ConvertStrToKind(II->getName(), Kind);
+  D->addAttr(::new (S.Context) OptimizeSizeAttr(S.Context, AL, Kind));
+}
+
 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;
case ParsedAttr::AT_ExtVectorType:
     handleExtVectorTypeAttr(S, D, AL);
     break;
   case ParsedAttr::AT_ExternalSourceSymbol:
     handleExternalSourceSymbolAttr(S, D, AL);
     break;
   case ParsedAttr::AT_MinSize:
     handleMinSizeAttr(S, D, AL);
     break;
+  case ParsedAttr::AT_OptimizeSize:
+    handleOptimizeSizeAttr(S, D, AL);
+    break;
   case ParsedAttr::AT_OptimizeNone:
     handleOptimizeNoneAttr(S, D, AL);
     break;
   case ParsedAttr::AT_NeverOptimizeNone:
     handleSimpleAttribute<NeverOptimizeNoneAttr>(S, D, AL);
     break;
   case ParsedAttr::AT_EnumExtensibility:
     handleEnumExtensibilityAttr(S, D, AL);