Add a new attribute on records, __attribute__((adl_invisible)), and define

the x86-64 __va_list_tag with this attribute.  The attribute causes the
affected type to behave like a fundamental type when considered by ADL.

(x86-64 is the only target we currently provide with a struct-based
__builtin_va_list)

Fixes PR6762.



git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@104941 91177308-0d34-0410-b5e6-96231b3b80d8

include/clang/AST/Decl.h

@@ -1999,6 +1999,11 @@ class RecordDecl : public TagDecl {
   /// containing an object.
   bool HasObjectMember : 1;
 
+  /// InvisibleToADL - This is true if this struct is invisible to
+  /// argument-dependent lookup.  Certain builtin types have this
+  /// property.
+  bool InvisibleToADL : 1;
+
 protected:
   RecordDecl(Kind DK, TagKind TK, DeclContext *DC,
              SourceLocation L, IdentifierInfo *Id,
@@ -2041,6 +2046,18 @@ public:
   bool hasObjectMember() const { return HasObjectMember; }
   void setHasObjectMember (bool val) { HasObjectMember = val; }
 
+  /// \brief Determines whether this type is invisible to C++
+  /// argument-dependent lookup.
+  ///
+  /// Types with this bit set behave like fundamental types: they are
+  /// never associated classes, and they do not add their contexts as
+  /// associated namespaces.
+  ///
+  /// This can be specified in user code as __attribute__((adl_invisible)),
+  /// but it's generally better not to.
+  bool isInvisibleToADL() const { return InvisibleToADL; }
+  void setInvisibleToADL(bool val = true) { InvisibleToADL = val; }
+
   /// \brief Determines whether this declaration represents the
   /// injected class name.
   ///

include/clang/Basic/DiagnosticSemaKinds.td

@@ -884,9 +884,9 @@ def warn_attribute_wrong_decl_type : Warning<
 def err_attribute_wrong_decl_type : Error<
   "%0 attribute only applies to %select{function|union|"
   "variable and function|function or method|parameter|"
-  "parameter or Objective-C method |function, method or block|"
+  "parameter or Objective-C method|function, method or block|"
   "virtual method or class|function, method, or parameter|class|virtual method"
-  "|member}1 types">;
+  "|member|struct or union}1 types">;
 def warn_function_attribute_wrong_type : Warning<
   "%0 only applies to function types; type here is %1">;
 def warn_gnu_inline_attribute_requires_inline : Warning<

include/clang/Parse/AttributeList.h

@@ -115,6 +115,7 @@ public:
     AT_weakref,
     AT_weak_import,
     AT_reqd_wg_size,
+    AT_adl_invisible,
     IgnoredAttribute,
     UnknownAttribute
   };

lib/AST/Decl.cpp

@@ -1596,6 +1596,7 @@ RecordDecl::RecordDecl(Kind DK, TagKind TK, DeclContext *DC, SourceLocation L,
   HasFlexibleArrayMember = false;
   AnonymousStructOrUnion = false;
   HasObjectMember = false;
+  InvisibleToADL = false;
   assert(classof(static_cast<Decl*>(this)) && "Invalid Kind!");
 }
 

lib/Basic/Targets.cpp

@@ -1272,7 +1272,7 @@ public:
            "  unsigned fp_offset;"
            "  void* overflow_arg_area;"
            "  void* reg_save_area;"
-           "} __va_list_tag;"
+           "} __attribute__((adl_invisible)) __va_list_tag;"
            "typedef __va_list_tag __builtin_va_list[1];";
   }
   

lib/Frontend/PCHReaderDecl.cpp

@@ -171,6 +171,7 @@ void PCHDeclReader::VisitRecordDecl(RecordDecl *RD) {
   RD->setHasFlexibleArrayMember(Record[Idx++]);
   RD->setAnonymousStructOrUnion(Record[Idx++]);
   RD->setHasObjectMember(Record[Idx++]);
+  RD->setInvisibleToADL(Record[Idx++]);
 }
 
 void PCHDeclReader::VisitValueDecl(ValueDecl *VD) {

lib/Frontend/PCHWriterDecl.cpp

@@ -169,6 +169,7 @@ void PCHDeclWriter::VisitRecordDecl(RecordDecl *D) {
   Record.push_back(D->hasFlexibleArrayMember());
   Record.push_back(D->isAnonymousStructOrUnion());
   Record.push_back(D->hasObjectMember());
+  Record.push_back(D->isInvisibleToADL());
   Code = pch::DECL_RECORD;
 }
 

lib/Parse/AttributeList.cpp

@@ -120,6 +120,7 @@ AttributeList::Kind AttributeList::getKind(const IdentifierInfo *Name) {
     .Case("cf_returns_retained", AT_cf_returns_retained)
     .Case("reqd_work_group_size", AT_reqd_wg_size)
     .Case("no_instrument_function", AT_no_instrument_function)
+    .Case("adl_invisible", AT_adl_invisible)
     .Case("thiscall", AT_thiscall)
     .Case("__cdecl", AT_cdecl)
     .Case("__stdcall", AT_stdcall)

lib/Sema/SemaDeclAttr.cpp

@@ -703,7 +703,7 @@ static void HandleObjCExceptionAttr(Decl *D, const AttributeList &Attr,
 
 static void HandleObjCNSObject(Decl *D, const AttributeList &Attr, Sema &S) {
   if (Attr.getNumArgs() != 0) {
-    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
+    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
     return;
   }
   if (TypedefDecl *TD = dyn_cast<TypedefDecl>(D)) {
@@ -720,7 +720,7 @@ static void HandleObjCNSObject(Decl *D, const AttributeList &Attr, Sema &S) {
 static void
 HandleOverloadableAttr(Decl *D, const AttributeList &Attr, Sema &S) {
   if (Attr.getNumArgs() != 0) {
-    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
+    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
     return;
   }
 
@@ -732,6 +732,21 @@ HandleOverloadableAttr(Decl *D, const AttributeList &Attr, Sema &S) {
   D->addAttr(::new (S.Context) OverloadableAttr());
 }
 
+static void HandleADLInvisibleAttr(Decl *d, const AttributeList &Attr, Sema &S) {
+  if (Attr.getNumArgs() != 0) {
+    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
+    return;
+  }
+
+  if (!isa<RecordDecl>(d)) {
+    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type)
+      << "adl_invisible" << 12;
+    return;
+  }
+
+  cast<RecordDecl>(d)->setInvisibleToADL();
+}
+
 static void HandleBlocksAttr(Decl *d, const AttributeList &Attr, Sema &S) {
   if (!Attr.getParameterName()) {
     S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string)
@@ -941,7 +956,7 @@ static void HandleReqdWorkGroupSize(Decl *D, const AttributeList &Attr,
                                     Sema &S) {
   // Attribute has 3 arguments.
   if (Attr.getNumArgs() != 3) {
-    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
+    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 3;
     return;
   }
 
@@ -1969,6 +1984,7 @@ static void ProcessDeclAttribute(Scope *scope, Decl *D,
     HandleObjCExceptionAttr(D, Attr, S);
     break;
   case AttributeList::AT_overloadable:HandleOverloadableAttr(D, Attr, S); break;
+  case AttributeList::AT_adl_invisible: HandleADLInvisibleAttr(D, Attr, S); break;
   case AttributeList::AT_nsobject:    HandleObjCNSObject    (D, Attr, S); break;
   case AttributeList::AT_blocks:      HandleBlocksAttr      (D, Attr, S); break;
   case AttributeList::AT_sentinel:    HandleSentinelAttr    (D, Attr, S); break;

lib/Sema/SemaLookup.cpp

@@ -1500,6 +1500,10 @@ addAssociatedClassesAndNamespaces(CXXRecordDecl *Class,
                                   ASTContext &Context,
                             Sema::AssociatedNamespaceSet &AssociatedNamespaces,
                             Sema::AssociatedClassSet &AssociatedClasses) {
+
+  // Some classes are invisible to ADL.
+  if (Class->isInvisibleToADL()) return;
+
   // C++ [basic.lookup.koenig]p2:
   //   [...]
   //     -- If T is a class type (including unions), its associated

test/CXX/basic/basic.lookup/basic.lookup.argdep/p2.cpp

@@ -97,3 +97,14 @@ namespace test5 {
     foo(&bar);
   }
 }
+
+// PR6762: __builtin_va_list should be invisible to ADL on all platforms.
+void test6_function(__builtin_va_list &argv);
+namespace test6 {
+  void test6_function(__builtin_va_list &argv);
+
+  void test() {
+    __builtin_va_list args;
+    test6_function(args);
+  }
+}