[X86] Support of no_caller_saved_registers attribute (Clang part) - restart

[oren_ben_simhon]

Summary

This patch implements the Clang part for no_caller_saved_registers attribute as appear in interrupt and exception handler proposal

The review is a update for an old review:
Support of no_caller_saved_registers attribute (Clang part).

[aaron.ballman]

Please remove the svn prop changes for the two test files. Also, I'd like to see a test that this is properly diagnosed as both a function and a type attribute on a non-x86 architecture, as well as tests that it is properly diagnosed on a type other than a function pointer as well as with arguments on a function pointer (the current tests only test on a declaration rather than a type).

include/clang/AST/Type.h

2934–2935

You should read the comment above -- this goes over 10 bits, but you forgot to update the comment and Type::FunctionTypeBitfields.

include/clang/Basic/AttrDocs.td

2663–2666

This appears to be copied word for word from GCC's documentation...

2664

Single space instead of double space.

2670

call clobbered -> call-clobbered

2673

override -> overrides

2685

on -> in
Also, missing a full stop at the end of the sentence.

2688

register -> registers

include/clang/CodeGen/CGFunctionInfo.h

486

I would remove this and make the ASTCallingConvention have 7 bits. Alternatively, scrape the unused bits from all of the fields and make this an unnamed bit-field.

569

Missing a full stop at the end of the sentence.

lib/Sema/SemaDeclAttr.cpp

1947

attr doesn't match the usual naming conventions (though don't name it Attr because that's the name of a type).

1964

Same comment here.

[oren_ben_simhon]

aaron.ballman added a comment:
Please remove the svn prop changes for the two test files. Also, I'd like to see a test that this is properly diagnosed as both a function and a type attribute on a non-x86 architecture, as well as tests that it is properly diagnosed on a type other than a function pointer as well as with arguments on a function pointer (the current tests only test on a declaration rather than a type).

I removed the properties.
Please notice that the attribute is x86 specific.
Anyway, I added a test for non-x86 and also added more use-cases in the test.

I think all the suggested testcases are covered.
Please let me know if i missed anything. if so please provide an example to make sure i understand what you mean.

lib/Sema/SemaDeclAttr.cpp

1947

I agree with you that "attr" doesn't follow the naming convention.

But I beg to differ regarding the use of "Attr".
I prefer to follow the grandfather coding guideline rule and use it like the neighboring functions do.

[oren_ben_simhon]

Implemented comments posted until 04/10 (Thank you Aaron)

[aaron.ballman]

include/clang/AST/Type.h

2948

This offset looks incorrect -- according to the text above, the regparm offset should now be 8.

include/clang/CodeGen/CGFunctionInfo.h

486

This didn't scrape all of the unused bits. For instance, EffectiveCallingConvention and CallingConvention appear to have unused bits still.

lib/Sema/SemaDeclAttr.cpp

1947

This makes a bad problem worse, but in the end, it's not a huge issue -- the whole file could use a bit of churn to fix the problem. However, you should back out the unrelated changes to handleNoReturnAttr(). While I agree with them, they don't relate to the patch at hand.

test/SemaCXX/attr-non-x86-no_caller_saved_registers.cpp

1–4 ↗

(On Diff #94959)

I think you really only need one RUN line; having four doesn't add value.

15 ↗

(On Diff #94959)

Why is the same diagnostic triggering multiple times for the same line?

17 ↗

(On Diff #94959)

The formatting here is wrong.

26 ↗

(On Diff #94959)

Given that the attribute is not supported for any of the run lines, I am surprised at the expected error. That would make sense if the attribute were applied to foo, but it should not have been applied there. I think this is because the type attribute is not checking the target properly as the declaration attribute does (it happens automatically for declaration attributes, but not for type attributes).

test/SemaCXX/attr-x86-no_caller_saved_registers.cpp

2–6

Why so many run lines? I think you only need one.

19

Formatting is off.

25

Why two different diagnostics for the same issue?

[oren_ben_simhon]

Implemented comments posted until 04/17 (Thank you Aaron for reviewing, Thank you Erich for helping me)

[aaron.ballman]

lib/Sema/SemaDecl.cpp

2962

Is there a reason why this doesn't diagnose, such as ns_returns_retained and regparm attributes do?

lib/Sema/SemaDeclAttr.cpp

1972–1975

Formatting here is off.

test/SemaCXX/attr-non-x86-no_caller_saved_registers.cpp

10 ↗

(On Diff #95551)

This seems odd to me -- everywhere else this is an unknown attribute, except for arguments, where it suddenly is a known attribute that we diagnose. I think we want this to still be an unknown attribute in that case.

[oren_ben_simhon]

Implemented comments posted until 04/19 (Thank you Aaron again)

[aaron.ballman]

include/clang/Basic/DiagnosticSemaKinds.td

2804 ↗

(On Diff #95759)

Please quote the attribute name in both places (the other cases should be quoted as well, but that isn't your patch's problem).

[oren_ben_simhon]

Implemented comments posted until 04/20 (Thanks Aaron)

[aaron.ballman]

include/clang/Basic/DiagnosticSemaKinds.td

2804 ↗

(On Diff #95759)

This is a good, general diagnostic (we should eventually roll the other, similar diagnostics into this one, but that's a separate patch), but it's missing a test case to exercise it.

[oren_ben_simhon]

Implemented comments posted until 04/23 (10x Aaron)

[oren_ben_simhon]

include/clang/Basic/DiagnosticSemaKinds.td

2804 ↗

(On Diff #95759)

Sure, I will add it in my next patch.

[oren_ben_simhon]

Hi Aaron, Please let me know if you have additional comments.

[aaron.ballman]

In D31871#737914, @oren_ben_simhon wrote:

Hi Aaron, Please let me know if you have additional comments.

The missing test case is my last remaining issue with the patch.

[oren_ben_simhon]

In D31871#737969, @aaron.ballman wrote:

In D31871#737914, @oren_ben_simhon wrote:

Hi Aaron, Please let me know if you have additional comments.

The missing test case is my last remaining issue with the patch.

I added the test case in file test/SemaCXX/attr-x86-no_caller_saved_registers.cpp lines 22-24. Let me know if another test case is missing.

[aaron.ballman]

LGTM!

include/clang/AST/Type.h

public:
   // * TypePrinter::PrintFunctionProto
   // * AST read and write
   // * Codegen
   class ExtInfo {
     // Feel free to rearrange or add bits, but if you go over 10,
     // you'll need to adjust both the Bits field below and
     // Type::FunctionTypeBitfields.
 
-    //   |  CC  |noreturn|produces|regparm|
-    //   |0 .. 4|   5    |    6   | 7 .. 9|
+    //   |  CC  |noreturn|produces|nocallersavedregs|regparm|
+    //   |0 .. 4|   5    |    6   |       7         |8 .. 10|
     //
     // regparm is either 0 (no regparm attribute) or the regparm value+1.
     enum { CallConvMask = 0x1F };
     enum { NoReturnMask = 0x20 };
     enum { ProducesResultMask = 0x40 };
-    enum { RegParmMask = ~(CallConvMask | NoReturnMask | ProducesResultMask),
+    enum { NoCallerSavedRegsMask = 0x80 };
+    enum { RegParmMask = ~(CallConvMask | NoReturnMask | 
+                           ProducesResultMask | NoCallerSavedRegsMask ),
            RegParmOffset = 7 }; // Assumed to be the last field
 
     uint16_t Bits;
 
     ExtInfo(unsigned Bits) : Bits(static_cast<uint16_t>(Bits)) {}
 
     friend class FunctionType;
 
    public:
     // Constructor with no defaults. Use this when you know that you
     // have all the elements (when reading an AST file for example).
     ExtInfo(bool noReturn, bool hasRegParm, unsigned regParm, CallingConv cc,
-            bool producesResult) {
+            bool producesResult, bool noCallerSavedRegs) {
       assert((!hasRegParm || regParm < 7) && "Invalid regparm value");
       Bits = ((unsigned) cc) |
              (noReturn ? NoReturnMask : 0) |
              (producesResult ? ProducesResultMask : 0) |
+             (noCallerSavedRegs ?  NoCallerSavedRegsMask : 0) |
              (hasRegParm ? ((regParm + 1) << RegParmOffset) : 0);
     }
 
     // Constructor with all defaults. Use when for example creating a
     // function known to use defaults.
     ExtInfo() : Bits(CC_C) { }
 
     // Constructor with just the calling convention, which is an important part
     // of the canonical type.
     ExtInfo(CallingConv CC) : Bits(CC) { }
 
     bool getNoReturn() const { return Bits & NoReturnMask; }
     bool getProducesResult() const { return Bits & ProducesResultMask; }
+    bool getNoCallerSavedRegs() const { return Bits & NoCallerSavedRegsMask; }
     bool getHasRegParm() const { return (Bits >> RegParmOffset) != 0; }
     unsigned getRegParm() const {
       unsigned RegParm = Bits >> RegParmOffset;
       if (RegParm > 0)
         --RegParm;
       return RegParm;
     }
     CallingConv getCC() const { return CallingConv(Bits & CallConvMask); }
public:
 
     ExtInfo withProducesResult(bool producesResult) const {
       if (producesResult)
         return ExtInfo(Bits | ProducesResultMask);
       else
         return ExtInfo(Bits & ~ProducesResultMask);
     }
 
+    ExtInfo withNoCallerSavedRegs(bool noCallerSavedRegs) const {
+      if (noCallerSavedRegs)
+        return ExtInfo(Bits | NoCallerSavedRegsMask);
+      else
+        return ExtInfo(Bits & ~NoCallerSavedRegsMask);
+    }
+
     ExtInfo withRegParm(unsigned RegParm) const {
       assert(RegParm < 7 && "Invalid regparm value");
       return ExtInfo((Bits & ~RegParmMask) |
                      ((RegParm + 1) << RegParmOffset));
     }
 
     ExtInfo withCallingConv(CallingConv cc) const {
       return ExtInfo((Bits & ~CallConvMask) | (unsigned) cc);

include/clang/Basic/Attr.td

def AnyX86Interrupt : InheritableAttr, TargetSpecificAttr<TargetAnyX86> {
   // MSP430Interrupt's and MipsInterrupt's spellings must match.
   let Spellings = [GNU<"interrupt">];
   let Subjects = SubjectList<[HasFunctionProto]>;
   let ParseKind = "Interrupt";
   let HasCustomParsing = 1;
   let Documentation = [AnyX86InterruptDocs];
 }
 
+def AnyX86NoCallerSavedRegisters : InheritableAttr,
+                                   TargetSpecificAttr<TargetAnyX86> {
+  let Spellings = [GCC<"no_caller_saved_registers">];
+  let Subjects = SubjectList<[FunctionLike], WarnDiag, "ExpectedFunction">;
+  let Documentation = [AnyX86NoCallerSavedRegistersDocs];
+}
+
 def X86ForceAlignArgPointer : InheritableAttr, TargetSpecificAttr<TargetX86> {
   let Spellings = [GNU<"force_align_arg_pointer">];
   // Technically, this appertains to a FunctionDecl, but the target-specific
   // code silently allows anything function-like (such as typedefs or function
   // pointers), but does not apply the attribute to them.
   let Documentation = [Undocumented];
 }
 

include/clang/Basic/AttrDocs.td

2. exception handler:
   and compiler pops 'ERROR_CODE' off stack before the 'IRET' instruction.
 
   The exception handler should only be used for exceptions which push an
   error code and all other exceptions must use the interrupt handler.
   The system will crash if the wrong handler is used.
   }];
 }
 
+def AnyX86NoCallerSavedRegistersDocs : Documentation {
+  let Category = DocCatFunction;
+  let Content = [{
+Use this attribute to indicate that the specified function has no
+caller-saved registers.  That is, all registers are callee-saved.
+The compiler generates proper function entry and exit sequences to
+save and restore any modified registers.
+
+The user can call functions specified with the 'no_caller_saved_registers'
+attribute from an interrupt handler without saving and restoring all
+call clobbered registers.
+
+Note that 'no_caller_saved_registers' attribute is not a calling convention.
+In fact, it only override the decision of what registers should be saved by
+the caller, but not how the parameters are passed from the caller to the callee.
+
+For example:
+
+  .. code-block:: c
+
+    __attribute__ ((no_caller_saved_registers, fastcall))
+    void f (int arg1, int arg2) {
+      ...
+    }
+
+  In this case parameters 'arg1' and 'arg2' will be passed on registers
+  In this case, on 32-bit x86 targets, the function 'f' will use ECX and EDX as
+  register parameters. However, it will not assume any scratch registers and
+  should save and restore any modified register.
+  }];
+}
+
 def SwiftCallDocs : Documentation {
   let Category = DocCatVariable;
   let Content = [{
 The ``swiftcall`` attribute indicates that a function should be called
 using the Swift calling convention for a function or function pointer.
 
 The lowering for the Swift calling convention, as described by the Swift
 ABI documentation, occurs in multiple phases.  The first, "high-level"

include/clang/CodeGen/CGFunctionInfo.h

class CGFunctionInfo final
   /// user).
   unsigned CallingConvention : 8;
 
   /// The LLVM::CallingConv to actually use for this function, which may
   /// depend on the ABI.
   unsigned EffectiveCallingConvention : 8;
 
   /// The clang::CallingConv that this was originally created with.
-  unsigned ASTCallingConvention : 8;
+  unsigned ASTCallingConvention : 6;
 
   /// Whether this is an instance method.
   unsigned InstanceMethod : 1;
 
   /// Whether this is a chain call.
   unsigned ChainCall : 1;
 
   /// Whether this function is noreturn.
   unsigned NoReturn : 1;
 
   /// Whether this function is returns-retained.
   unsigned ReturnsRetained : 1;
 
+  /// Whether this function saved caller registers.
+  unsigned NoCallerSavedRegs : 1;
+
   /// How many arguments to pass inreg.
   unsigned HasRegParm : 1;
   unsigned RegParm : 3;
 
+  /// Unused bits, available for future use.
+  unsigned UnusedBits : 1;
+
   RequiredArgs Required;
 
   /// The struct representing all arguments passed in memory.  Only used when
   /// passing non-trivial types with inalloca.  Not part of the profile.
   llvm::StructType *ArgStruct;
   unsigned ArgStructAlign : 31;
   unsigned HasExtParameterInfos : 1;
 
public:
   bool isChainCall() const { return ChainCall; }
 
   bool isNoReturn() const { return NoReturn; }
 
   /// In ARC, whether this function retains its return value.  This
   /// is not always reliable for call sites.
   bool isReturnsRetained() const { return ReturnsRetained; }
 
+  /// Whether this function no longer saves caller registers
+  bool isNoCallerSavedRegs() const { return NoCallerSavedRegs; }
+
   /// getASTCallingConvention() - Return the AST-specified calling
   /// convention.
   CallingConv getASTCallingConvention() const {
     return CallingConv(ASTCallingConvention);
   }
 
   /// getCallingConvention - Return the user specified calling
   /// convention, which has been translated into an LLVM CC.
public:
 
   bool getHasRegParm() const { return HasRegParm; }
   unsigned getRegParm() const { return RegParm; }
 
   FunctionType::ExtInfo getExtInfo() const {
     return FunctionType::ExtInfo(isNoReturn(),
                                  getHasRegParm(), getRegParm(),
                                  getASTCallingConvention(),
-                                 isReturnsRetained());
+                                 isReturnsRetained(),
+                                 isNoCallerSavedRegs());
   }
 
   CanQualType getReturnType() const { return getArgsBuffer()[0].type; }
 
   ABIArgInfo &getReturnInfo() { return getArgsBuffer()[0].info; }
   const ABIArgInfo &getReturnInfo() const { return getArgsBuffer()[0].info; }
 
   ArrayRef<ExtParameterInfo> getExtParameterInfos() const {
public:
   }
 
   void Profile(llvm::FoldingSetNodeID &ID) {
     ID.AddInteger(getASTCallingConvention());
     ID.AddBoolean(InstanceMethod);
     ID.AddBoolean(ChainCall);
     ID.AddBoolean(NoReturn);
     ID.AddBoolean(ReturnsRetained);
+    ID.AddBoolean(NoCallerSavedRegs);
     ID.AddBoolean(HasRegParm);
     ID.AddInteger(RegParm);
     ID.AddInteger(Required.getOpaqueData());
     ID.AddBoolean(HasExtParameterInfos);
     if (HasExtParameterInfos) {
       for (auto paramInfo : getExtParameterInfos())
         ID.AddInteger(paramInfo.getOpaqueValue());
     }
static void Profile(llvm::FoldingSetNodeID &ID,
                       RequiredArgs required,
                       CanQualType resultType,
                       ArrayRef<CanQualType> argTypes) {
     ID.AddInteger(info.getCC());
     ID.AddBoolean(InstanceMethod);
     ID.AddBoolean(ChainCall);
     ID.AddBoolean(info.getNoReturn());
     ID.AddBoolean(info.getProducesResult());
+    ID.AddBoolean(info.getNoCallerSavedRegs());
     ID.AddBoolean(info.getHasRegParm());
     ID.AddInteger(info.getRegParm());
     ID.AddInteger(required.getOpaqueData());
     ID.AddBoolean(!paramInfos.empty());
     if (!paramInfos.empty()) {
       for (auto paramInfo : paramInfos)
         ID.AddInteger(paramInfo.getOpaqueValue());
     }

include/clang/Sema/Sema.h

public:
   /// nonnull), but if the second parameter is true, then we treat a reference
   /// type as valid.
   bool isValidPointerAttrType(QualType T, bool RefOkay = false);
 
   bool CheckRegparmAttr(const AttributeList &attr, unsigned &value);
   bool CheckCallingConvAttr(const AttributeList &attr, CallingConv &CC,
                             const FunctionDecl *FD = nullptr);
   bool CheckNoReturnAttr(const AttributeList &attr);
+  bool CheckNoCallerSavedRegsAttr(const AttributeList &attr);
   bool checkStringLiteralArgumentAttr(const AttributeList &Attr,
                                       unsigned ArgNum, StringRef &Str,
                                       SourceLocation *ArgLocation = nullptr);
   bool checkSectionName(SourceLocation LiteralLoc, StringRef Str);
   void checkTargetAttr(SourceLocation LiteralLoc, StringRef Str);
   bool checkMSInheritanceAttrOnDefinition(
       CXXRecordDecl *RD, SourceRange Range, bool BestCase,
       MSInheritanceAttr::Spelling SemanticSpelling);

lib/AST/ASTContext.cpp

QualType ASTContext::mergeFunctionTypes(QualType lhs, QualType rhs,
   // Regparm is part of the calling convention.
   if (lbaseInfo.getHasRegParm() != rbaseInfo.getHasRegParm())
     return QualType();
   if (lbaseInfo.getRegParm() != rbaseInfo.getRegParm())
     return QualType();
 
   if (lbaseInfo.getProducesResult() != rbaseInfo.getProducesResult())
     return QualType();
+  if (lbaseInfo.getNoCallerSavedRegs() != rbaseInfo.getNoCallerSavedRegs())
+    return QualType();
 
   // FIXME: some uses, e.g. conditional exprs, really want this to be 'both'.
   bool NoReturn = lbaseInfo.getNoReturn() || rbaseInfo.getNoReturn();
 
   if (lbaseInfo.getNoReturn() != NoReturn)
     allLTypes = false;
   if (rbaseInfo.getNoReturn() != NoReturn)
     allRTypes = false;

lib/AST/TypePrinter.cpp

if (!InsideCCAttribute) {
     }
   }
 
   if (Info.getNoReturn())
     OS << " __attribute__((noreturn))";
   if (Info.getRegParm())
     OS << " __attribute__((regparm ("
        << Info.getRegParm() << ")))";
+  if (Info.getNoCallerSavedRegs())
+    OS << "__attribute__((no_caller_saved_registers))";
 
   if (unsigned quals = T->getTypeQuals()) {
     OS << ' ';
     AppendTypeQualList(OS, quals, Policy.Restrict);
   }
 
   switch (T->getRefQualifier()) {
   case RQ_None:

lib/CodeGen/CGCall.cpp

CGFunctionInfo *CGFunctionInfo::create(unsigned llvmCC,
   CGFunctionInfo *FI = new(buffer) CGFunctionInfo();
   FI->CallingConvention = llvmCC;
   FI->EffectiveCallingConvention = llvmCC;
   FI->ASTCallingConvention = info.getCC();
   FI->InstanceMethod = instanceMethod;
   FI->ChainCall = chainCall;
   FI->NoReturn = info.getNoReturn();
   FI->ReturnsRetained = info.getProducesResult();
+  FI->NoCallerSavedRegs = info.getNoCallerSavedRegs();
   FI->Required = required;
   FI->HasRegParm = info.getHasRegParm();
   FI->RegParm = info.getRegParm();
   FI->ArgStruct = nullptr;
   FI->ArgStructAlign = 0;
   FI->NumArgs = argTypes.size();
   FI->HasExtParameterInfos = !paramInfos.empty();
   FI->getArgsBuffer()[0].type = resultType;
if (TargetDecl) {
     } else if (TargetDecl->hasAttr<NoAliasAttr>()) {
       FuncAttrs.addAttribute(llvm::Attribute::ArgMemOnly);
       FuncAttrs.addAttribute(llvm::Attribute::NoUnwind);
     }
     if (TargetDecl->hasAttr<RestrictAttr>())
       RetAttrs.addAttribute(llvm::Attribute::NoAlias);
     if (TargetDecl->hasAttr<ReturnsNonNullAttr>())
       RetAttrs.addAttribute(llvm::Attribute::NonNull);
+    if (TargetDecl->hasAttr<AnyX86NoCallerSavedRegistersAttr>())
+      FuncAttrs.addAttribute("no_caller_saved_registers");
 
     HasOptnone = TargetDecl->hasAttr<OptimizeNoneAttr>();
     if (auto *AllocSize = TargetDecl->getAttr<AllocSizeAttr>()) {
       Optional<unsigned> NumElemsParam;
       // alloc_size args are base-1, 0 means not present.
       if (unsigned N = AllocSize->getNumElemsParam())
         NumElemsParam = N - 1;
       FuncAttrs.addAllocSizeAttr(AllocSize->getElemSizeParam() - 1,

lib/Sema/SemaDecl.cpp

if (NewTypeInfo.getProducesResult()) {
       Diag(OldLocation, diag::note_previous_declaration);
       return true;
     }
 
     NewTypeInfo = NewTypeInfo.withProducesResult(true);
     RequiresAdjustment = true;
   }
 
+  if (OldTypeInfo.getNoCallerSavedRegs() !=
+      NewTypeInfo.getNoCallerSavedRegs()) {
+    NewTypeInfo = NewTypeInfo.withNoCallerSavedRegs(true);
+    RequiresAdjustment = true;
+  }
+
   if (RequiresAdjustment) {
     const FunctionType *AdjustedType = New->getType()->getAs<FunctionType>();
     AdjustedType = Context.adjustFunctionType(AdjustedType, NewTypeInfo);
     New->setType(QualType(AdjustedType, 0));
     NewQType = Context.getCanonicalType(New->getType());
     NewType = cast<FunctionType>(NewQType);
   }
 

lib/Sema/SemaDeclAttr.cpp

if (!isa<ObjCMethodDecl>(D)) {
     return;
   }
 
   D->addAttr(::new (S.Context)
              NoReturnAttr(attr.getRange(), S.Context,
                           attr.getAttributeSpellingListIndex()));
 }
 
+static void handleNoCallerSavedRegsAttr(Sema &S, Decl *D,
+                                        const AttributeList &attr) {
+  if (S.CheckNoCallerSavedRegsAttr(attr))
+    return;
+
+  D->addAttr(::new (S.Context) AnyX86NoCallerSavedRegistersAttr(
+      attr.getRange(), S.Context, attr.getAttributeSpellingListIndex()));
+}
+
 bool Sema::CheckNoReturnAttr(const AttributeList &attr) {
   if (!checkAttributeNumArgs(*this, attr, 0)) {
     attr.setInvalid();
     return true;
   }
 
   return false;
 }
 
+bool Sema::CheckNoCallerSavedRegsAttr(const AttributeList &attr) {
+  if (!checkAttributeNumArgs(*this, attr, 0)) {
+    attr.setInvalid();
+    return true;
+  }
+
+  return false;
+}
+
 static void handleAnalyzerNoReturnAttr(Sema &S, Decl *D,
                                        const AttributeList &Attr) {
   
   // The checking path for 'noreturn' and 'analyzer_noreturn' are different
   // because 'analyzer_noreturn' does not impact the type.
   if (!isFunctionOrMethodOrBlock(D)) {
     ValueDecl *VD = dyn_cast<ValueDecl>(D);
     if (!VD || (!VD->getType()->isBlockPointerType() &&
                 !VD->getType()->isFunctionPointerType())) {
       S.Diag(Attr.getLoc(),
              Attr.isCXX11Attribute() ? diag::err_attribute_wrong_decl_type
static void ProcessDeclAttribute(Sema &S, Scope *scope, Decl *D,
 
   // Type safety attributes.
   case AttributeList::AT_ArgumentWithTypeTag:
     handleArgumentWithTypeTagAttr(S, D, Attr);
     break;
   case AttributeList::AT_TypeTagForDatatype:
     handleTypeTagForDatatypeAttr(S, D, Attr);
     break;
+  case AttributeList::AT_AnyX86NoCallerSavedRegisters:
+    handleNoCallerSavedRegsAttr(S, D, Attr);
+    break;
   case AttributeList::AT_RenderScriptKernel:
     handleSimpleAttribute<RenderScriptKernelAttr>(S, D, Attr);
     break;
   // XRay attributes.
   case AttributeList::AT_XRayInstrument:
     handleSimpleAttribute<XRayInstrumentAttr>(S, D, Attr);
     break;
   case AttributeList::AT_XRayLogArgs:

lib/Sema/SemaType.cpp

#define CALLING_CONV_ATTRS_CASELIST \
     case AttributeList::AT_IntelOclBicc: \
     case AttributeList::AT_PreserveMost: \
     case AttributeList::AT_PreserveAll
 
 // Function type attributes.
 #define FUNCTION_TYPE_ATTRS_CASELIST \
     case AttributeList::AT_NoReturn: \
     case AttributeList::AT_Regparm: \
+    case AttributeList::AT_AnyX86NoCallerSavedRegisters: \
     CALLING_CONV_ATTRS_CASELIST
 
 // Microsoft-specific type qualifiers.
 #define MS_TYPE_ATTRS_CASELIST  \
     case AttributeList::AT_Ptr32: \
     case AttributeList::AT_Ptr64: \
     case AttributeList::AT_SPtr: \
     case AttributeList::AT_UPtr
if (!unwrapped.isFunctionType())
       return false;
 
     FunctionType::ExtInfo EI
       = unwrapped.get()->getExtInfo().withProducesResult(true);
     type = unwrapped.wrap(S, S.Context.adjustFunctionType(unwrapped.get(), EI));
     return true;
   }
 
+  if (attr.getKind() == AttributeList::AT_AnyX86NoCallerSavedRegisters) {
+    if (S.CheckNoCallerSavedRegsAttr(attr))
+      return true;
+
+    // Delay if this is not a function type.
+    if (!unwrapped.isFunctionType())
+      return false;
+
+    FunctionType::ExtInfo EI =
+        unwrapped.get()->getExtInfo().withNoCallerSavedRegs(true);
+    type = unwrapped.wrap(S, S.Context.adjustFunctionType(unwrapped.get(), EI));
+    return true;
+  }
+
   if (attr.getKind() == AttributeList::AT_Regparm) {
     unsigned value;
     if (S.CheckRegparmAttr(attr, value))
       return true;
 
     // Delay if this is not a function type.
     if (!unwrapped.isFunctionType())
       return false;

lib/Serialization/ASTReader.cpp

case TYPE_EXT_VECTOR: {
     }
 
     QualType ElementType = readType(*Loc.F, Record, Idx);
     unsigned NumElements = Record[1];
     return Context.getExtVectorType(ElementType, NumElements);
   }
 
   case TYPE_FUNCTION_NO_PROTO: {
-    if (Record.size() != 6) {
+    if (Record.size() != 7) {
       Error("incorrect encoding of no-proto function type");
       return QualType();
     }
     QualType ResultType = readType(*Loc.F, Record, Idx);
     FunctionType::ExtInfo Info(Record[1], Record[2], Record[3],
-                               (CallingConv)Record[4], Record[5]);
+                               (CallingConv)Record[4], Record[5],
+                               Record[6]);
     return Context.getFunctionNoProtoType(ResultType, Info);
   }
 
   case TYPE_FUNCTION_PROTO: {
     QualType ResultType = readType(*Loc.F, Record, Idx);
 
     FunctionProtoType::ExtProtoInfo EPI;
     EPI.ExtInfo = FunctionType::ExtInfo(/*noreturn*/ Record[1],
                                         /*hasregparm*/ Record[2],
                                         /*regparm*/ Record[3],
                                         static_cast<CallingConv>(Record[4]),
-                                        /*produces*/ Record[5]);
+                                        /*produces*/ Record[5],
+                                        /*nocallersavedregs*/ Record[6]);
 
-    unsigned Idx = 6;
+    unsigned Idx = 7;
 
     EPI.Variadic = Record[Idx++];
     EPI.HasTrailingReturn = Record[Idx++];
     EPI.TypeQuals = Record[Idx++];
     EPI.RefQualifier = static_cast<RefQualifierKind>(Record[Idx++]);
     SmallVector<QualType, 8> ExceptionStorage;
     readExceptionSpec(*Loc.F, ExceptionStorage, EPI.ExceptionSpec, Record, Idx);
 

lib/Serialization/ASTWriter.cpp

void ASTTypeWriter::VisitFunctionType(const FunctionType *T) {
   Record.AddTypeRef(T->getReturnType());
   FunctionType::ExtInfo C = T->getExtInfo();
   Record.push_back(C.getNoReturn());
   Record.push_back(C.getHasRegParm());
   Record.push_back(C.getRegParm());
   // FIXME: need to stabilize encoding of calling convention...
   Record.push_back(C.getCC());
   Record.push_back(C.getProducesResult());
+  Record.push_back(C.getNoCallerSavedRegs());
 
   if (C.getHasRegParm() || C.getRegParm() || C.getProducesResult())
     AbbrevToUse = 0;
 }
 
 void ASTTypeWriter::VisitFunctionNoProtoType(const FunctionNoProtoType *T) {
   VisitFunctionType(T);
   Code = TYPE_FUNCTION_NO_PROTO;
void ASTWriter::WriteTypeAbbrevs() {
   Abv->Add(BitCodeAbbrevOp(serialization::TYPE_FUNCTION_PROTO));
   // FunctionType
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // ReturnType
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // NoReturn
   Abv->Add(BitCodeAbbrevOp(0));                         // HasRegParm
   Abv->Add(BitCodeAbbrevOp(0));                         // RegParm
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 4)); // CC
   Abv->Add(BitCodeAbbrevOp(0));                         // ProducesResult
+  Abv->Add(BitCodeAbbrevOp(0));                         // NoCallerSavedRegs
   // FunctionProtoType
   Abv->Add(BitCodeAbbrevOp(0));                         // IsVariadic
   Abv->Add(BitCodeAbbrevOp(0));                         // HasTrailingReturn
   Abv->Add(BitCodeAbbrevOp(0));                         // TypeQuals
   Abv->Add(BitCodeAbbrevOp(0));                         // RefQualifier
   Abv->Add(BitCodeAbbrevOp(EST_None));                  // ExceptionSpec
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // NumParams
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));

test/CodeGenCXX/attr-x86-no_caller_saved_registers.cpp

+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu %s -emit-llvm -o - | FileCheck %s
+// RUN: %clang_cc1 -triple i386-unknown-linux-gnu %s -emit-llvm -o - | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-pc-win32 %s -emit-llvm -o - | FileCheck %s
+// RUN: %clang_cc1 -triple i386-pc-win32 %s -emit-llvm -o - | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnux32 %s -emit-llvm -o - | FileCheck %s
+
+// CHECK: foo{{[^#]*}}#[[ATTRS:[0-9]+]]
+__attribute__((no_caller_saved_registers)) void foo() {}
+namespace S {
+// CHECK: bar{{[^#]*}}#[[ATTRS]]
+__attribute__((no_caller_saved_registers)) void bar(int *a) { foo(); }
+}
+
+struct St {
+  static void baz(int *a) __attribute__((no_caller_saved_registers)) { S::bar(a); }
+};
+
+__attribute((no_caller_saved_registers)) void (*foobar)(void);
+
+// CHECK-LABEL: @main
+int main(int argc, char **argv) {
+  St::baz(&argc);
+  // CHECK: [[FOOBAR:%.+]] = load void ()*, void ()** @{{.*}}foobar{{.*}},
+  // CHECK-NEXT: call void [[FOOBAR]]() #[[ATTRS1:.+]]
+  foobar();
+  return 0;
+}
+
+// CHECK: baz{{[^#]*}}#[[ATTRS]]
+
+// CHECK: attributes #[[ATTRS]] = {
+// CHECK-SAME: "no_caller_saved_registers"
+// CHECK-SAME: }
+// CHECK: attributes #[[ATTRS1]] = { "no_caller_saved_registers" }

test/SemaCXX/attr-x86-no_caller_saved_registers.cpp

+// RUN: %clang_cc1 -std=c++11 -triple x86_64-unknown-linux-gnu -fsyntax-only -verify %s
+// RUN: %clang_cc1 -std=c++11 -triple i386-unknown-linux-gnu -fsyntax-only -verify %s
+// RUN: %clang_cc1 -std=c++11 -triple x86_64-pc-win32 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -std=c++11 -triple i386-pc-win32 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -std=c++11 -triple x86_64-unknown-linux-gnux32 -fsyntax-only -verify %s
+
+struct a {
+  int b __attribute__((no_caller_saved_registers)); // expected-warning {{'no_caller_saved_registers' only applies to function types; type here is 'int'}}
+  static void foo(int *a) __attribute__((no_caller_saved_registers)) {}
+};
+
+struct a test __attribute__((no_caller_saved_registers)); // expected-warning {{'no_caller_saved_registers' only applies to function types; type here is 'struct a'}}
+
+__attribute__((no_caller_saved_registers(999))) void bar(int *) {} // expected-error {{'no_caller_saved_registers' attribute takes no arguments}}
+
+__attribute__((no_caller_saved_registers)) void foo(int *) {}
+
+[[gnu::no_caller_saved_registers]] void foo2(int *) {}
+
+int main(int argc, char **argv) {
+  void(*fp)(int *) = foo; // expected-error {{cannot initialize a variable of type 'void (*)(int *)' with an lvalue of type 'void (int *)__attribute__((no_caller_saved_registers))'}}
+  a::foo(&argc);
+  foo(&argc);
+  return 0;
+}