[Sema] Get rid of unused default argument to Sema::CheckCallingConvAttr.

[jlebar]

Summary

All callers of CheckCallingConvAttr passed FD == nullptr, so just get
rid of the aspirational function arg.

[rnk]

I think you've discovered this bug:

struct F { void __attribute__((pcs("aapcs"))) f(); };
void __attribute__((pcs("aapcs"))) F::f() {}

Clang ignores the pcs convention on 32-bit x86, and because we don't have an FD here, we choose the wrong default calling convention (not thiscall) for F::f.

[jlebar]

I think you've discovered this bug:

Hm, I guess this is a step in the wrong direction, then.

(I spun this patch after writing some code in this function that assumed I'd get a FunctionDecl where appropriate, which of course doesn't work.)

[jlebar]

Thanks for the review, Reid.

[rnk]

In general we can't get an FD here because we might be in the middle of parsing the declarator. The calls from SemaType.cpp in particular can't actually provide one. They would have to thread through the IsVariadic and IsCXXMethod bools based on syntactic cues (the ellipsis, member pointer declarator chunks, being the appropriate declarator chunk in a record context, i.e. what getCCForDeclaratorChunk does).

clang/include/clang/Sema/Sema.h

public:
 
   /// Determine if type T is a valid subject for a nonnull and similar
   /// attributes. By default, we look through references (the behavior used by
   /// 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 CheckCallingConvAttr(const AttributeList &attr, CallingConv &CC);
   bool CheckNoReturnAttr(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,

clang/lib/Sema/SemaDeclAttr.cpp

 }
 
 static void handleCallConvAttr(Sema &S, Decl *D, const AttributeList &Attr) {
   if (hasDeclarator(D)) return;
 
   // Diagnostic is emitted elsewhere: here we store the (valid) Attr
   // in the Decl node for syntactic reasoning, e.g., pretty-printing.
   CallingConv CC;
-  if (S.CheckCallingConvAttr(Attr, CC, /*FD*/nullptr))
+  if (S.CheckCallingConvAttr(Attr, CC))
     return;
 
   if (!isa<ObjCMethodDecl>(D)) {
     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
       << Attr.getName() << ExpectedFunctionOrMethod;
     return;
   }
 
case AttributeList::AT_PreserveAll:
     D->addAttr(::new (S.Context) PreserveAllAttr(
         Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
     return;
   default:
     llvm_unreachable("unexpected attribute kind");
   }
 }
 
-bool Sema::CheckCallingConvAttr(const AttributeList &attr, CallingConv &CC, 
-                                const FunctionDecl *FD) {
+bool Sema::CheckCallingConvAttr(const AttributeList &attr, CallingConv &CC) {
   if (attr.isInvalid())
     return true;
 
   if (attr.hasProcessingCache()) {
     CC = (CallingConv) attr.getProcessingCache();
     return false;
   }
 
bool Sema::CheckCallingConvAttr(const AttributeList &attr, CallingConv &CC) {
   const TargetInfo &TI = Context.getTargetInfo();
   TargetInfo::CallingConvCheckResult A = TI.checkCallingConvention(CC);
   if (A != TargetInfo::CCCR_OK) {
     if (A == TargetInfo::CCCR_Warning)
       Diag(attr.getLoc(), diag::warn_cconv_ignored) << attr.getName();
 
     // This convention is not valid for the target. Use the default function or
     // method calling convention.
-    bool IsCXXMethod = false, IsVariadic = false;
-    if (FD) {
-      IsCXXMethod = FD->isCXXInstanceMember();
-      IsVariadic = FD->isVariadic();
-    }
-    CC = Context.getDefaultCallingConvention(IsVariadic, IsCXXMethod);
+    CC = Context.getDefaultCallingConvention(/*IsVariadic=*/false,
+                                             /*IsCXXMethod=*/false);
   }
 
   attr.setProcessingCache((unsigned) CC);
   return false;
 }
 
 /// Pointer-like types in the default address space.
 static bool isValidSwiftContextType(QualType type) {