[clang] Specify type of pthread_create builtin

[jrtc27]

Summary

Currently, pthread_create's type string is empty, so GetBuiltinType
fails and any header declaring it gives a -Wbuiltin-requires-header
warning, which gives a false-positive when including pthread.h itself
with -Wsystem-headers. By specifying its type, this false-positive goes
away and it behaves like every other builtin declared in system headers,
only warning when the declaration does not match the expected type.

This requires introducing a way to declare function pointer types in
builtin type strings, which requires refactoring GetBuiltinType to allow
recursive parsing of function types, expressed as a type string within
parentheses.

[jrtc27]

A separate point is whether it makes sense to be emitting this warning in the first place for GE_Missing_type. I'd argue that, if we don't know the type of the builtin, we should never emit the warning, since otherwise we always emit the warning even for legitimate instances, though that's not really important now we're not hitting that case any more.

[srhines]

clang/lib/AST/ASTContext.cpp

9753

I would just remove "of function" here, since it isn't correct when you are not decoding a function, and the two words don't make that much more meaningful even in the original case, so I don't think it justifies something like "of intrinsic/function".

[probinson]

We've started running into this too in building the PS4 system. +jdoerfert who added pthread_create to the builtin list.

Looking at the patch, it seems straightforward enough although clearly needs clang-format-diff run over it.
I don't touch Clang that much so I'm reluctant to okay it myself.

[jdoerfert]

In D58531#1599209, @probinson wrote:

We've started running into this too in building the PS4 system. +jdoerfert who added pthread_create to the builtin list.

Looking at the patch, it seems straightforward enough although clearly needs clang-format-diff run over it.
I don't touch Clang that much so I'm reluctant to okay it myself.

@probinson Thanks for making me aware of this patch.

A separate point is whether it makes sense to be emitting this warning in the first place for GE_Missing_type. I'd argue that, if we don't know the type of the builtin, we should never emit the warning

@jrtc27 I hope the immediate need for this is gone after D58091 was finally committed? Given that I caused this mess I can take a look at the patch if you are still interested in it, are you?

[jrtc27]

In D58531#1611356, @jdoerfert wrote:

In D58531#1599209, @probinson wrote:

We've started running into this too in building the PS4 system. +jdoerfert who added pthread_create to the builtin list.

Looking at the patch, it seems straightforward enough although clearly needs clang-format-diff run over it.
I don't touch Clang that much so I'm reluctant to okay it myself.

@probinson Thanks for making me aware of this patch.

A separate point is whether it makes sense to be emitting this warning in the first place for GE_Missing_type. I'd argue that, if we don't know the type of the builtin, we should never emit the warning

@jrtc27 I hope the immediate need for this is gone after D58091 was finally committed? Given that I caused this mess I can take a look at the patch if you are still interested in it, are you?

Yes, now that it's not a warning if we don't provide a type this is no longer completely necessary. I would still be slightly in favour of this patch though as then we can detect dodgy pthread_create declarations, but it's not a big deal.

[jdoerfert]

I like the patch and I think it is fine.

Small nits:
Could we have a test for " we can detect dodgy pthread_create declarations" and maybe pthread[_attr]_t?
There is an unresolved comment by @shrines.
@probinson: "it seems straightforward enough although clearly needs clang-format-diff run over it."

I'll accept this assuming the above points are easy to fix and given that no one expressed concerns but only positive comments were made.

clang/lib/AST/ASTContext.cpp

9391

I like the static helper function.

[jrtc27]

Rebased, added explicit no-warning test, clang-format'ed, updated assertion message.

[jrtc27]

In D58531#1662466, @jdoerfert wrote:

I like the patch and I think it is fine.

Small nits:
Could we have a test for " we can detect dodgy pthread_create declarations" and maybe pthread[_attr]_t?
There is an unresolved comment by @shrines.
@probinson: "it seems straightforward enough although clearly needs clang-format-diff run over it."

I'll accept this assuming the above points are easy to fix and given that no one expressed concerns but only positive comments were made.

I believe I have addressed everything, with the possible exception of:

Could we have a test for " we can detect dodgy pthread_create declarations" and maybe pthread[_attr]_t?

Is that not what I had already added to clang/test/Sema/implicit-builtin-decl.c?

[rsmith]

clang/include/clang/Serialization/ASTBitCodes.h

1223

This presumably needs to be increased. Are we missing test coverage that would have caught this?

clang/lib/AST/ASTContext.cpp

9386–9389

Our convention for such helper functions is to pass the reference to the associated class (ASTContext in this case) as the first parameter. (I appreciate that DecodeTypeFromStr violates this convention.)

9677–9679

OK. We may eventually want a way to specify noreturn and nothrow here, because they're both part of the type in at least some cases, but this seems fine for the immediate future.

9739

Maybe "missing return type in builtin function type" or similar would be a more useful assert message here?

9756

Please assert(!RequiresICE || !IsNested) here; we shouldn't require parameters of function pointer parameters to be ICEs.

9765–9767

Should we do function -> pointer decay here too, so you can use (...) instead of (...)* in Builtins.def?

9775–9776

Do we need this special case and its associated flag? Can we make GetBuiltinType directly return QualType();for _GetExceptionInfo instead?

9778–9779

This will assert on (.).

clang/lib/Sema/SemaDecl.cpp

1971–1972

Could we use GE_Missing_type here instead? The LIBBUILTIN already lists "pthread.h" as the corresponding header, so that seems sufficient. I think we only need the special cases above to handle the non-LIBBUILTIN cases such as __builtin_fprintf that nonetheless require a header inclusion (in that case to provide FILE).

[MaskRay]

clang/include/clang/AST/ASTContext.h

2058

You can append a comma so that next time the list gets appended the diff does not have to touch this line.

[MaskRay]

Ping @jrtc27

clang/include/clang/AST/ASTContext.h

private:
   TypeDecl *jmp_bufDecl = nullptr;
 
   /// The type for the C sigjmp_buf type.
   TypeDecl *sigjmp_bufDecl = nullptr;
 
   /// The type for the C ucontext_t type.
   TypeDecl *ucontext_tDecl = nullptr;
 
+  /// The type for the C pthread_t type.
+  TypeDecl *pthread_tDecl = nullptr;
+
+  /// The type for the C pthread_attr_t type.
+  TypeDecl *pthread_attr_tDecl = nullptr;
+
   /// Type for the Block descriptor for Blocks CodeGen.
   ///
   /// Since this is only used for generation of debug info, it is not
   /// serialized.
   mutable RecordDecl *BlockDescriptorType = nullptr;
 
   /// Type for the Block descriptor for Blocks CodeGen.
   ///
public:
 
   /// Retrieve the C ucontext_t type.
   QualType getucontext_tType() const {
     if (ucontext_tDecl)
       return getTypeDeclType(ucontext_tDecl);
     return QualType();
   }
 
+  /// Set the type for the C pthread_t type.
+  void setpthread_tDecl(TypeDecl *pthread_tDecl) {
+    this->pthread_tDecl = pthread_tDecl;
+  }
+
+  /// Retrieve the C pthread_t type.
+  QualType getpthread_tType() const {
+    if (pthread_tDecl)
+      return getTypeDeclType(pthread_tDecl);
+    return QualType();
+  }
+
+  /// Set the type for the C pthread_attr_t type.
+  void setpthread_attr_tDecl(TypeDecl *pthread_attr_tDecl) {
+    this->pthread_attr_tDecl = pthread_attr_tDecl;
+  }
+
+  /// Retrieve the C pthread_attr_t type.
+  QualType getpthread_attr_tType() const {
+    if (pthread_attr_tDecl)
+      return getTypeDeclType(pthread_attr_tDecl);
+    return QualType();
+  }
+
   /// The result type of logical operations, '<', '>', '!=', etc.
   QualType getLogicalOperationType() const {
     return getLangOpts().CPlusPlus ? BoolTy : IntTy;
   }
 
   /// Emit the Objective-CC type encoding for the given type \p T into
   /// \p S.
   ///
enum GetBuiltinTypeError {
 
     /// Missing a type from <stdio.h>
     GE_Missing_stdio,
 
     /// Missing a type from <setjmp.h>
     GE_Missing_setjmp,
 
     /// Missing a type from <ucontext.h>
-    GE_Missing_ucontext
+    GE_Missing_ucontext,
+
+    /// Missing a type from <pthread.h>
+    GE_Missing_pthread
   };
 
   /// Return the type for the specified builtin.
   ///
   /// If \p IntegerConstantArgs is non-null, it is filled in with a bitmask of
   /// arguments to the builtin that are required to be integer constant
   /// expressions.
   QualType GetBuiltinType(unsigned ID, GetBuiltinTypeError &Error,

clang/include/clang/Basic/Builtins.def

 //  E -> ext_vector, followed by the number of elements and the base type.
 //  X -> _Complex, followed by the base type.
 //  Y -> ptrdiff_t
 //  P -> FILE
 //  J -> jmp_buf
 //  SJ -> sigjmp_buf
 //  K -> ucontext_t
 //  p -> pid_t
+//  Q -> pthread_t
+//  SQ -> pthread_attr_t
+//  (T) -> function with type T parsed recursively
 //  . -> "...".  This may only occur at the end of the function list.
 //
 // Types may be prefixed with the following modifiers:
 //  L   -> long (e.g. Li for 'long int', Ld for 'long double')
 //  LL  -> long long (e.g. LLi for 'long long int', LLd for __float128)
 //  LLL -> __int128_t (e.g. LLLi)
 //  Z   -> int32_t (require a native 32-bit integer type on the target)
 //  W   -> int64_t (require a native 64-bit integer type on the target)

 #undef strcasecmp
 #undef strncasecmp
 LIBBUILTIN(strcasecmp, "icC*cC*", "f",     "strings.h", ALL_GNU_LANGUAGES)
 LIBBUILTIN(strncasecmp, "icC*cC*z", "f",   "strings.h", ALL_GNU_LANGUAGES)
 // POSIX unistd.h
 LIBBUILTIN(_exit, "vi",           "fr",    "unistd.h", ALL_GNU_LANGUAGES)
 LIBBUILTIN(vfork, "p",            "fj",    "unistd.h", ALL_LANGUAGES)
 // POSIX pthread.h
-LIBBUILTIN(pthread_create, "",  "fC<2,3>", "pthread.h", ALL_GNU_LANGUAGES)
+LIBBUILTIN(pthread_create, "iQ*SQC*(v*v*)*v*",  "fC<2,3>", "pthread.h", ALL_GNU_LANGUAGES)
 
 // POSIX setjmp.h
 
 LIBBUILTIN(_setjmp, "iJ",         "fj",   "setjmp.h", ALL_LANGUAGES)
 LIBBUILTIN(__sigsetjmp, "iSJi",   "fj",   "setjmp.h", ALL_LANGUAGES)
 LIBBUILTIN(sigsetjmp, "iSJi",     "fj",   "setjmp.h", ALL_LANGUAGES)
 LIBBUILTIN(savectx, "iJ",         "fj",   "setjmp.h", ALL_LANGUAGES)
 LIBBUILTIN(getcontext, "iK*",     "fj",   "setjmp.h", ALL_LANGUAGES)

clang/include/clang/Serialization/ASTBitCodes.h

enum SpecialTypeIDs {
 
       /// Objective-C "Class" redefinition type
       SPECIAL_TYPE_OBJC_CLASS_REDEFINITION     = 5,
 
       /// Objective-C "SEL" redefinition type
       SPECIAL_TYPE_OBJC_SEL_REDEFINITION       = 6,
 
       /// C ucontext_t typedef type
-      SPECIAL_TYPE_UCONTEXT_T                  = 7
+      SPECIAL_TYPE_UCONTEXT_T                  = 7,
+
+      /// C pthread_t typedef type
+      SPECIAL_TYPE_PTHREAD_T                   = 8,
+
+      /// C pthread_attr_t typedef type
+      SPECIAL_TYPE_PTHREAD_ATTR_T              = 9
     };
 
     /// The number of special type IDs.
     const unsigned NumSpecialTypeIDs = 8;
 
     /// Predefined declaration IDs.
     ///
     /// These declaration IDs correspond to predefined declarations in the AST
     /// context, such as the NULL declaration ID. Such declarations are never
     /// actually serialized, since they will be built by the AST context when
     /// it is created.
     enum PredefinedDeclIDs {

clang/lib/AST/ASTContext.cpp

 
 void ASTMutationListener::DeducedReturnType(const FunctionDecl *FD,
                                             QualType ReturnType) {}
 
 //===----------------------------------------------------------------------===//
 //                          Builtin Type Computation
 //===----------------------------------------------------------------------===//
 
+static QualType DecodeFunctionTypeFromStr(
+    const char *&TypeStr, bool IsNested, bool IsNoReturn, bool IsNoThrow,
+    bool ForceEmptyTy, const ASTContext &Context,
+    ASTContext::GetBuiltinTypeError &Error, unsigned *IntegerConstantArgs);
+
 /// DecodeTypeFromStr - This decodes one type descriptor from Str, advancing the
 /// pointer over the consumed characters.  This returns the resultant type.  If
 /// AllowTypeModifiers is false then modifier like * are not parsed, just basic
 /// types.  This allows "v2i*" to be parsed as a pointer to a v2i instead of
 /// a vector of "i*".
 ///
 /// RequiresICE is filled in on return to indicate whether the value is required
 /// to be an Integer Constant Expression.
 static QualType DecodeTypeFromStr(const char *&Str, const ASTContext &Context,
case 'K':
     if (Type.isNull()) {
       Error = ASTContext::GE_Missing_ucontext;
       return {};
     }
     break;
   case 'p':
     Type = Context.getProcessIDType();
     break;
+  case 'Q':
+    if (Signed)
+      Type = Context.getpthread_attr_tType();
+    else
+      Type = Context.getpthread_tType();
+
+    if (Type.isNull()) {
+      Error = ASTContext::GE_Missing_pthread;
+      return {};
+    }
+    break;
+  case '(':
+    Type = DecodeFunctionTypeFromStr(
+        Str, /*IsNested=*/true, /*IsNoReturn=*/false,
+        /*IsNoThrow=*/false, /*ForceEmptyTy=*/false, Context, Error, nullptr);
+    assert(Str[0] == ')' && "unmatched '('");
+    Str++;
+    break;
   }
 
   // If there are modifiers and if we're allowed to parse them, go for it.
   Done = !AllowTypeModifiers;
   while (!Done) {
     switch (char c = *Str++) {
     default: Done = true; --Str; break;
     case '*':
static QualType DecodeTypeFromStr(const char *&Str, const ASTContext &Context,
   }
 
   assert((!RequiresICE || Type->isIntegralOrEnumerationType()) &&
          "Integer constant 'I' type must be an integer");
 
   return Type;
 }
 
-/// GetBuiltinType - Return the type for the specified builtin.
-QualType ASTContext::GetBuiltinType(unsigned Id,
-                                    GetBuiltinTypeError &Error,
-                                    unsigned *IntegerConstantArgs) const {
-  const char *TypeStr = BuiltinInfo.getTypeString(Id);
+/// DecodeFunctionTypeFromStr - This decodes the entire type descriptor
+static QualType DecodeFunctionTypeFromStr(
+    const char *&TypeStr, bool IsNested, bool IsNoReturn, bool IsNoThrow,
+    bool ForceEmptyTy, const ASTContext &Context,
+    ASTContext::GetBuiltinTypeError &Error, unsigned *IntegerConstantArgs) {
   if (TypeStr[0] == '\0') {
-    Error = GE_Missing_type;
+    Error = ASTContext::GE_Missing_type;
+    return {};
+  }
+
+  if (TypeStr[0] == ')') {
+    assert(IsNested && "unmatched ')' found at end of type list");
+    Error = ASTContext::GE_Missing_type;
     return {};
   }
 
   SmallVector<QualType, 8> ArgTypes;
 
   bool RequiresICE = false;
-  Error = GE_None;
-  QualType ResType = DecodeTypeFromStr(TypeStr, *this, Error,
-                                       RequiresICE, true);
-  if (Error != GE_None)
+  Error = ASTContext::GE_None;
+  QualType ResType =
+      DecodeTypeFromStr(TypeStr, Context, Error, RequiresICE, true);
+  if (Error != ASTContext::GE_None)
     return {};
 
-  assert(!RequiresICE && "Result of intrinsic cannot be required to be an ICE");
+  assert(!RequiresICE && "Result cannot be required to be an ICE");
 
-  while (TypeStr[0] && TypeStr[0] != '.') {
-    QualType Ty = DecodeTypeFromStr(TypeStr, *this, Error, RequiresICE, true);
-    if (Error != GE_None)
+  while (TypeStr[0] && TypeStr[0] != '.' && TypeStr[0] != ')') {
+    QualType Ty = DecodeTypeFromStr(TypeStr, Context, Error, RequiresICE, true);
+    if (Error != ASTContext::GE_None)
       return {};
 
     // If this argument is required to be an IntegerConstantExpression and the
     // caller cares, fill in the bitmask we return.
     if (RequiresICE && IntegerConstantArgs)
       *IntegerConstantArgs |= 1 << ArgTypes.size();
 
     // Do array -> pointer decay.  The builtin should use the decayed type.
     if (Ty->isArrayType())
-      Ty = getArrayDecayedType(Ty);
+      Ty = Context.getArrayDecayedType(Ty);
 
     ArgTypes.push_back(Ty);
   }
 
-  if (Id == Builtin::BI__GetExceptionInfo)
+  assert((TypeStr[0] != ')' || IsNested) &&
+         "unmatched ')' found at end of type list");
+
+  if (ForceEmptyTy)
     return {};
 
   assert((TypeStr[0] != '.' || TypeStr[1] == 0) &&
          "'.' should only occur at end of builtin type list!");
 
   bool Variadic = (TypeStr[0] == '.');
 
-  FunctionType::ExtInfo EI(getDefaultCallingConvention(
+  FunctionType::ExtInfo EI(Context.getDefaultCallingConvention(
       Variadic, /*IsCXXMethod=*/false, /*IsBuiltin=*/true));
-  if (BuiltinInfo.isNoReturn(Id)) EI = EI.withNoReturn(true);
-
+  if (IsNoReturn)
+    EI = EI.withNoReturn(true);
 
   // We really shouldn't be making a no-proto type here.
-  if (ArgTypes.empty() && Variadic && !getLangOpts().CPlusPlus)
-    return getFunctionNoProtoType(ResType, EI);
+  if (ArgTypes.empty() && Variadic && !Context.getLangOpts().CPlusPlus)
+    return Context.getFunctionNoProtoType(ResType, EI);
 
   FunctionProtoType::ExtProtoInfo EPI;
   EPI.ExtInfo = EI;
   EPI.Variadic = Variadic;
-  if (getLangOpts().CPlusPlus && BuiltinInfo.isNoThrow(Id))
+  if (Context.getLangOpts().CPlusPlus && IsNoThrow)
     EPI.ExceptionSpec.Type =
-        getLangOpts().CPlusPlus11 ? EST_BasicNoexcept : EST_DynamicNone;
+        Context.getLangOpts().CPlusPlus11 ? EST_BasicNoexcept : EST_DynamicNone;
 
-  return getFunctionType(ResType, ArgTypes, EPI);
+  return Context.getFunctionType(ResType, ArgTypes, EPI);
+}
+
+/// GetBuiltinType - Return the type for the specified builtin.
+QualType ASTContext::GetBuiltinType(unsigned Id,
+                                    GetBuiltinTypeError &Error,
+                                    unsigned *IntegerConstantArgs) const {
+  const char *TypeStr = BuiltinInfo.getTypeString(Id);
+  return DecodeFunctionTypeFromStr(
+      TypeStr, /*IsNested=*/false, BuiltinInfo.isNoReturn(Id),
+      BuiltinInfo.isNoThrow(Id),
+      /*ForceEmptyTy=*/
+      Id == Builtin::BI__GetExceptionInfo, *this, Error, IntegerConstantArgs);
 }
 
 static GVALinkage basicGVALinkageForFunction(const ASTContext &Context,
                                              const FunctionDecl *FD) {
   if (!FD->isExternallyVisible())
     return GVA_Internal;
 
   // Non-user-provided functions get emitted as weak definitions with every

clang/lib/Sema/SemaDecl.cpp

static StringRef getHeaderName(Builtin::Context &BuiltinInfo, unsigned ID,
   case ASTContext::GE_Missing_type:
     return BuiltinInfo.getHeaderName(ID);
   case ASTContext::GE_Missing_stdio:
     return "stdio.h";
   case ASTContext::GE_Missing_setjmp:
     return "setjmp.h";
   case ASTContext::GE_Missing_ucontext:
     return "ucontext.h";
+  case ASTContext::GE_Missing_pthread:
+    return "pthread.h";
   }
   llvm_unreachable("unhandled error kind");
 }
 
 /// LazilyCreateBuiltin - The specified Builtin-ID was first used at
 /// file scope.  lazily create a decl for it. ForRedeclaration is true
 /// if we're creating this built-in in anticipation of redeclaring the
 /// built-in.
if (!NewTD->isInvalidDecl() &&
       if (II->isStr("FILE"))
         Context.setFILEDecl(NewTD);
       else if (II->isStr("jmp_buf"))
         Context.setjmp_bufDecl(NewTD);
       else if (II->isStr("sigjmp_buf"))
         Context.setsigjmp_bufDecl(NewTD);
       else if (II->isStr("ucontext_t"))
         Context.setucontext_tDecl(NewTD);
+      else if (II->isStr("pthread_t"))
+        Context.setpthread_tDecl(NewTD);
+      else if (II->isStr("pthread_attr_t"))
+        Context.setpthread_attr_tDecl(NewTD);
     }
 
   return NewTD;
 }
 
 /// Determines whether the given declaration is an out-of-scope
 /// previous declaration.
 ///

clang/lib/Serialization/ASTReader.cpp

if (unsigned Ucontext_t = SpecialTypes[SPECIAL_TYPE_UCONTEXT_T]) {
           Context.setucontext_tDecl(Typedef->getDecl());
         else {
           const TagType *Tag = Ucontext_tType->getAs<TagType>();
           assert(Tag && "Invalid ucontext_t type in AST file");
           Context.setucontext_tDecl(Tag->getDecl());
         }
       }
     }
+
+    if (unsigned Pthread_t = SpecialTypes[SPECIAL_TYPE_PTHREAD_T]) {
+      QualType Pthread_tType = GetType(Pthread_t);
+      if (Pthread_tType.isNull()) {
+        Error("pthread_t type is NULL");
+        return;
+      }
+
+      if (!Context.pthread_tDecl) {
+        if (const TypedefType *Typedef = Pthread_tType->getAs<TypedefType>())
+          Context.setpthread_tDecl(Typedef->getDecl());
+        else {
+          const TagType *Tag = Pthread_tType->getAs<TagType>();
+          assert(Tag && "Invalid pthread_t type in AST file");
+          Context.setpthread_tDecl(Tag->getDecl());
+        }
+      }
+    }
+
+    if (unsigned Pthread_attr_t = SpecialTypes[SPECIAL_TYPE_PTHREAD_ATTR_T]) {
+      QualType Pthread_attr_tType = GetType(Pthread_attr_t);
+      if (Pthread_attr_tType.isNull()) {
+        Error("pthread_attr_t type is NULL");
+        return;
+      }
+
+      if (!Context.pthread_attr_tDecl) {
+        if (const TypedefType *Typedef =
+                Pthread_attr_tType->getAs<TypedefType>())
+          Context.setpthread_attr_tDecl(Typedef->getDecl());
+        else {
+          const TagType *Tag = Pthread_attr_tType->getAs<TagType>();
+          assert(Tag && "Invalid pthread_attr_t type in AST file");
+          Context.setpthread_attr_tDecl(Tag->getDecl());
+        }
+      }
+    }
   }
 
   ReadPragmaDiagnosticMappings(Context.getDiagnostics());
 
   // If there were any CUDA special declarations, deserialize them.
   if (!CUDASpecialDeclRefs.empty()) {
     assert(CUDASpecialDeclRefs.size() == 1 && "More decl refs than expected!");
     Context.setcudaConfigureCallDecl(

clang/lib/Serialization/ASTWriter.cpp

ASTFileSignature ASTWriter::WriteASTCore(Sema &SemaRef, StringRef isysroot,
   AddTypeRef(Context.getRawCFConstantStringType(), SpecialTypes);
   AddTypeRef(Context.getFILEType(), SpecialTypes);
   AddTypeRef(Context.getjmp_bufType(), SpecialTypes);
   AddTypeRef(Context.getsigjmp_bufType(), SpecialTypes);
   AddTypeRef(Context.ObjCIdRedefinitionType, SpecialTypes);
   AddTypeRef(Context.ObjCClassRedefinitionType, SpecialTypes);
   AddTypeRef(Context.ObjCSelRedefinitionType, SpecialTypes);
   AddTypeRef(Context.getucontext_tType(), SpecialTypes);
+  AddTypeRef(Context.getpthread_tType(), SpecialTypes);
+  AddTypeRef(Context.getpthread_attr_tType(), SpecialTypes);
 
   if (Chain) {
     // Write the mapping information describing our module dependencies and how
     // each of those modules were mapped into our own offset/ID space, so that
     // the reader can build the appropriate mapping to its own offset/ID space.
     // The map consists solely of a blob with the following format:
     // *(module-kind:i8
     //   module-name-len:i16 module-name:len*i8

clang/test/Sema/implicit-builtin-decl.c

 struct __jmp_buf_tag {};
 void sigsetjmp(struct __jmp_buf_tag[1], int); // expected-warning{{declaration of built-in function 'sigsetjmp' requires the declaration of the 'jmp_buf' type, commonly provided in the header <setjmp.h>.}}
 
 // CHECK:     FunctionDecl {{.*}} <line:[[@LINE-2]]:1, col:44> col:6 sigsetjmp '
 // CHECK-NOT: FunctionDecl
 // CHECK:     ReturnsTwiceAttr {{.*}} <{{.*}}> Implicit
 
 // PR40692
-void pthread_create(); // no warning expected
+void pthread_create(); // expected-warning{{declaration of built-in function 'pthread_create' requires inclusion of the header <pthread.h>}}

clang/test/Sema/implicit-builtin-redecl.c

 
 static int index;
 
 int f3() {
   return index << 2;
 }
 
 typedef int rindex;
+
+// PR40692
+typedef void pthread_t;
+typedef void pthread_attr_t;
+int pthread_create(pthread_t *, const pthread_attr_t *, // no-warning
+                   void *(*)(void *), void *);