diff --git a/include/clang/AST/Type.h b/include/clang/AST/Type.h
index 73bf981..20dd90e 100644
--- a/include/clang/AST/Type.h
+++ b/include/clang/AST/Type.h
@@ -1150,7 +1150,7 @@ protected:
 
     /// Extra information which affects how the function is called, like
     /// regparm and the calling convention.
-    unsigned ExtInfo : 8;
+    unsigned ExtInfo : 9;
 
     /// Whether the function is variadic.  Only used by FunctionProtoType.
     unsigned Variadic : 1;
@@ -2503,33 +2503,32 @@ class FunctionType : public Type {
   /// a FunctionType, although FunctionType does currently use the
   /// same bit-pattern.
   ///
-  // If you add a field (say Foo), other than the obvious places (both,
-  // constructors, compile failures), what you need to update is
-  // * Operator==
+  // If you add a field (say Foo), other than the obvious places (
+  // constructor, compile failures), what you need to update is
   // * getFoo
   // * withFoo
-  // * functionType. Add Foo, getFoo.
-  // * ASTContext::getFooType
+  // * functionType. Add getFoo.
   // * ASTContext::mergeFunctionTypes
-  // * FunctionNoProtoType::Profile
-  // * FunctionProtoType::Profile
-  // * TypePrinter::PrintFunctionProto
+  // * CGFunctionInfo::Profile
+  // * TypePrinter::printFunctionProto
   // * AST read and write
   // * Codegen
   class ExtInfo {
-    // Feel free to rearrange or add bits, but if you go over 8,
+    // Feel free to rearrange or add bits, but if you go over 9,
     // you'll need to adjust both the Bits field below and
     // Type::FunctionTypeBitfields.
 
-    //   |  CC  |noreturn|produces|regparm|
-    //   |0 .. 2|   3    |    4   | 5 .. 7|
+    //   |  CC  |noreturn|produces|returns_twice|regparm|
+    //   |0 .. 2|   3    |    4   |      5      | 6.. 8 |
     //
     // regparm is either 0 (no regparm attribute) or the regparm value+1.
     enum { CallConvMask = 0x7 };
     enum { NoReturnMask = 0x8 };
     enum { ProducesResultMask = 0x10 };
-    enum { RegParmMask = ~(CallConvMask | NoReturnMask | ProducesResultMask),
-           RegParmOffset = 5 }; // Assumed to be the last field
+    enum { ReturnsTwiceMask = 0x20 };
+    enum { RegParmMask = ~(CallConvMask | NoReturnMask | ProducesResultMask |
+                           ReturnsTwiceMask),
+           RegParmOffset = 6 }; // Assumed to be the last field
 
     uint16_t Bits;
 
@@ -2541,10 +2540,11 @@ class FunctionType : public Type {
     // 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 returnsTwice) {
       assert((!hasRegParm || regParm < 7) && "Invalid regparm value");
       Bits = ((unsigned) cc) |
              (noReturn ? NoReturnMask : 0) |
+             (returnsTwice ? ReturnsTwiceMask : 0) |
              (producesResult ? ProducesResultMask : 0) |
              (hasRegParm ? ((regParm + 1) << RegParmOffset) : 0);
     }
@@ -2553,6 +2553,7 @@ class FunctionType : public Type {
     // function know to use defaults.
     ExtInfo() : Bits(0) {}
 
+    bool getReturnsTwice() const { return Bits & ReturnsTwiceMask; }
     bool getNoReturn() const { return Bits & NoReturnMask; }
     bool getProducesResult() const { return Bits & ProducesResultMask; }
     bool getHasRegParm() const { return (Bits >> RegParmOffset) != 0; }
@@ -2574,6 +2575,13 @@ class FunctionType : public Type {
     // Note that we don't have setters. That is by design, use
     // the following with methods instead of mutating these objects.
 
+    ExtInfo withReturnsTwice(bool returnsTwice) const {
+      if (returnsTwice)
+        return ExtInfo(Bits | ReturnsTwiceMask);
+      else
+        return ExtInfo(Bits & ~ReturnsTwiceMask);
+    }
+
     ExtInfo withNoReturn(bool noReturn) const {
       if (noReturn)
         return ExtInfo(Bits | NoReturnMask);
@@ -2632,6 +2640,7 @@ public:
   bool getHasRegParm() const { return getExtInfo().getHasRegParm(); }
   unsigned getRegParmType() const { return getExtInfo().getRegParm(); }
   bool getNoReturnAttr() const { return getExtInfo().getNoReturn(); }
+  bool getReturnsTwiceAttr() const { return getExtInfo().getReturnsTwice(); }
   CallingConv getCallConv() const { return getExtInfo().getCC(); }
   ExtInfo getExtInfo() const { return ExtInfo(FunctionTypeBits.ExtInfo); }
 
@@ -3209,6 +3218,7 @@ public:
 
     // No operand.
     attr_noreturn,
+    attr_returns_twice,
     attr_cdecl,
     attr_fastcall,
     attr_stdcall,
diff --git a/include/clang/Basic/Builtins.def b/include/clang/Basic/Builtins.def
index 60bcde3..d3a5eaf 100644
--- a/include/clang/Basic/Builtins.def
+++ b/include/clang/Basic/Builtins.def
@@ -77,6 +77,7 @@
 //          in that it accepts its arguments as a va_list rather than
 //          through an ellipsis
 //  e -> const, but only when -fmath-errno=0
+//  j -> returns_twice (like setjmp)
 //  FIXME: gcc has nonnull
 
 #if defined(BUILTIN) && !defined(LIBBUILTIN)
@@ -427,7 +428,7 @@ BUILTIN(__builtin_return_address, "v*IUi", "n")
 BUILTIN(__builtin_extract_return_addr, "v*v*", "n")
 BUILTIN(__builtin_frame_address, "v*IUi", "n")
 BUILTIN(__builtin_flt_rounds, "i", "nc")
-BUILTIN(__builtin_setjmp, "iv**", "")
+BUILTIN(__builtin_setjmp, "iv**", "j")
 BUILTIN(__builtin_longjmp, "vv**i", "r")
 BUILTIN(__builtin_unwind_init, "v", "")
 BUILTIN(__builtin_eh_return_data_regno, "iIi", "nc")
@@ -672,6 +673,17 @@ LIBBUILTIN(bzero, "vv*z",         "f",     "strings.h", ALL_LANGUAGES)
 // POSIX unistd.h
 LIBBUILTIN(_exit, "vi",           "fr",    "unistd.h", ALL_LANGUAGES)
 // POSIX setjmp.h
+
+LIBBUILTIN(_setjmp, "iJ",         "fj",   "setjmp.h", ALL_LANGUAGES)
+LIBBUILTIN(__sigsetjmp, "iJ",     "fj",   "setjmp.h", ALL_LANGUAGES)
+LIBBUILTIN(setjmp, "iJ",          "fj",   "setjmp.h", ALL_LANGUAGES)
+LIBBUILTIN(sigsetjmp, "iJ",       "fj",   "setjmp.h", ALL_LANGUAGES)
+LIBBUILTIN(setjmp_syscall, "iJ",  "fj",   "setjmp.h", ALL_LANGUAGES)
+LIBBUILTIN(savectx, "iJ",         "fj",   "setjmp.h", ALL_LANGUAGES)
+LIBBUILTIN(qsetjmp, "iJ",         "fj",   "setjmp.h", ALL_LANGUAGES)
+LIBBUILTIN(vfork, "iJ",           "fj",   "setjmp.h", ALL_LANGUAGES)
+LIBBUILTIN(getcontext, "iJ",      "fj",   "setjmp.h", ALL_LANGUAGES)
+
 LIBBUILTIN(_longjmp, "vJi",       "fr",    "setjmp.h", ALL_LANGUAGES)
 LIBBUILTIN(siglongjmp, "vSJi",    "fr",    "setjmp.h", ALL_LANGUAGES)
 // non-standard but very common
diff --git a/include/clang/Basic/Builtins.h b/include/clang/Basic/Builtins.h
index fbf4ef4..5afa020 100644
--- a/include/clang/Basic/Builtins.h
+++ b/include/clang/Basic/Builtins.h
@@ -103,6 +103,11 @@ public:
     return strchr(GetRecord(ID).Attributes, 'r') != 0;
   }
 
+  /// isReturnsTwice - Return true if we know this builtin can return twice.
+  bool isReturnsTwice(unsigned ID) const {
+    return strchr(GetRecord(ID).Attributes, 'j') != 0;
+  }
+
   /// isLibFunction - Return true if this is a builtin for a libc/libm function,
   /// with a "__builtin_" prefix (e.g. __builtin_abs).
   bool isLibFunction(unsigned ID) const {
diff --git a/include/clang/Sema/Sema.h b/include/clang/Sema/Sema.h
index 9bb4022..670245f 100644
--- a/include/clang/Sema/Sema.h
+++ b/include/clang/Sema/Sema.h
@@ -1843,6 +1843,7 @@ public:
   bool CheckRegparmAttr(const AttributeList &attr, unsigned &value);
   bool CheckCallingConvAttr(const AttributeList &attr, CallingConv &CC);
   bool CheckNoReturnAttr(const AttributeList &attr);
+  bool CheckReturnsTwiceAttr(const AttributeList &attr);
 
   void WarnUndefinedMethod(SourceLocation ImpLoc, ObjCMethodDecl *method,
                            bool &IncompleteImpl, unsigned DiagID);
diff --git a/lib/AST/ASTContext.cpp b/lib/AST/ASTContext.cpp
index b625655..83e945c 100644
--- a/lib/AST/ASTContext.cpp
+++ b/lib/AST/ASTContext.cpp
@@ -5586,8 +5586,11 @@ QualType ASTContext::mergeFunctionTypes(QualType lhs, QualType rhs,
     allRTypes = false;
   // FIXME: some uses, e.g. conditional exprs, really want this to be 'both'.
   bool NoReturn = lbaseInfo.getNoReturn() || rbaseInfo.getNoReturn();
+  bool ReturnsTwice = lbaseInfo.getReturnsTwice() ||
+    rbaseInfo.getReturnsTwice();
 
-  FunctionType::ExtInfo einfo = lbaseInfo.withNoReturn(NoReturn);
+  FunctionType::ExtInfo einfo = lbaseInfo.withNoReturn(NoReturn)
+    .withReturnsTwice(ReturnsTwice);
 
   if (lproto && rproto) { // two C99 style function prototypes
     assert(!lproto->hasExceptionSpec() && !rproto->hasExceptionSpec() &&
@@ -6349,7 +6352,11 @@ QualType ASTContext::GetBuiltinType(unsigned Id,
          "'.' should only occur at end of builtin type list!");
 
   FunctionType::ExtInfo EI;
-  if (BuiltinInfo.isNoReturn(Id)) EI = EI.withNoReturn(true);
+  if (BuiltinInfo.isNoReturn(Id))
+    EI = EI.withNoReturn(true);
+
+  if (BuiltinInfo.isReturnsTwice(Id))
+    EI = EI.withReturnsTwice(true);
 
   bool Variadic = (TypeStr[0] == '.');
 
diff --git a/lib/AST/DeclPrinter.cpp b/lib/AST/DeclPrinter.cpp
index 73f5cdb..4f3e8ad 100644
--- a/lib/AST/DeclPrinter.cpp
+++ b/lib/AST/DeclPrinter.cpp
@@ -468,6 +468,10 @@ void DeclPrinter::VisitFunctionDecl(FunctionDecl *D) {
 
     if (D->hasAttr<NoReturnAttr>())
       Proto += " __attribute((noreturn))";
+
+    if (D->hasAttr<ReturnsTwiceAttr>())
+      Proto += " __attribute((returns_twice))";
+
     if (CXXConstructorDecl *CDecl = dyn_cast<CXXConstructorDecl>(D)) {
       bool HasInitializerList = false;
       for (CXXConstructorDecl::init_const_iterator B = CDecl->init_begin(),
diff --git a/lib/AST/TypePrinter.cpp b/lib/AST/TypePrinter.cpp
index fb7b918..c25c7a2 100644
--- a/lib/AST/TypePrinter.cpp
+++ b/lib/AST/TypePrinter.cpp
@@ -453,6 +453,8 @@ void TypePrinter::printFunctionProto(const FunctionProtoType *T,
   }
   if (Info.getNoReturn())
     S += " __attribute__((noreturn))";
+  if (Info.getReturnsTwice())
+    S += " __attribute__((returns_twice))";
   if (Info.getRegParm())
     S += " __attribute__((regparm (" +
         llvm::utostr_32(Info.getRegParm()) + ")))";
@@ -510,6 +512,8 @@ void TypePrinter::printFunctionNoProto(const FunctionNoProtoType *T,
   S += "()";
   if (T->getNoReturnAttr())
     S += " __attribute__((noreturn))";
+  if (T->getReturnsTwiceAttr())
+    S += " __attribute__((returs_twice))";
   print(T->getResultType(), S);
 }
 
@@ -940,6 +944,7 @@ void TypePrinter::printAttributed(const AttributedType *T,
     break;
 
   case AttributedType::attr_noreturn: S += "noreturn"; break;
+  case AttributedType::attr_returns_twice: S += "returns_twice"; break;
   case AttributedType::attr_cdecl: S += "cdecl"; break;
   case AttributedType::attr_fastcall: S += "fastcall"; break;
   case AttributedType::attr_stdcall: S += "stdcall"; break;
diff --git a/lib/CodeGen/CGCall.cpp b/lib/CodeGen/CGCall.cpp
index f52abef..5f280c7 100644
--- a/lib/CodeGen/CGCall.cpp
+++ b/lib/CodeGen/CGCall.cpp
@@ -260,7 +260,8 @@ const CGFunctionInfo &CodeGenTypes::getFunctionInfo(CanQualType ResTy,
     return *FI;
 
   // Construct the function info.
-  FI = new CGFunctionInfo(CC, Info.getNoReturn(), Info.getProducesResult(),
+  FI = new CGFunctionInfo(CC, Info.getNoReturn(), Info.getReturnsTwice(),
+                          Info.getProducesResult(),
                           Info.getHasRegParm(), Info.getRegParm(), ResTy,
                           ArgTys.data(), ArgTys.size());
   FunctionInfos.InsertNode(FI, InsertPos);
@@ -290,14 +291,16 @@ const CGFunctionInfo &CodeGenTypes::getFunctionInfo(CanQualType ResTy,
 }
 
 CGFunctionInfo::CGFunctionInfo(unsigned _CallingConvention,
-                               bool _NoReturn, bool returnsRetained,
+                               bool _NoReturn, bool _ReturnsTwice,
+                               bool returnsRetained,
                                bool _HasRegParm, unsigned _RegParm,
                                CanQualType ResTy,
                                const CanQualType *ArgTys,
                                unsigned NumArgTys)
   : CallingConvention(_CallingConvention),
     EffectiveCallingConvention(_CallingConvention),
-    NoReturn(_NoReturn), ReturnsRetained(returnsRetained),
+    NoReturn(_NoReturn), ReturnsTwice(_ReturnsTwice),
+    ReturnsRetained(returnsRetained),
     HasRegParm(_HasRegParm), RegParm(_RegParm)
 {
   NumArgs = NumArgTys;
@@ -727,6 +730,9 @@ void CodeGenModule::ConstructAttributeList(const CGFunctionInfo &FI,
   if (FI.isNoReturn())
     FuncAttrs |= llvm::Attribute::NoReturn;
 
+  if (FI.isReturnsTwice())
+    FuncAttrs |= llvm::Attribute::ReturnsTwice;
+
   // FIXME: handle sseregparm someday...
   if (TargetDecl) {
     if (TargetDecl->hasAttr<NoThrowAttr>())
diff --git a/lib/CodeGen/CGCall.h b/lib/CodeGen/CGCall.h
index 24ed366..a00dc30 100644
--- a/lib/CodeGen/CGCall.h
+++ b/lib/CodeGen/CGCall.h
@@ -123,6 +123,9 @@ namespace CodeGen {
     /// Whether this function is noreturn.
     bool NoReturn;
 
+    /// Whether this function is returns-twice.
+    bool ReturnsTwice;
+
     /// Whether this function is returns-retained.
     bool ReturnsRetained;
 
@@ -137,7 +140,7 @@ namespace CodeGen {
     typedef const ArgInfo *const_arg_iterator;
     typedef ArgInfo *arg_iterator;
 
-    CGFunctionInfo(unsigned CallingConvention, bool NoReturn,
+    CGFunctionInfo(unsigned CallingConvention, bool NoReturn, bool ReturnsTwice,
                    bool ReturnsRetained, bool HasRegParm, unsigned RegParm,
                    CanQualType ResTy,
                    const CanQualType *ArgTys, unsigned NumArgTys);
@@ -151,6 +154,7 @@ namespace CodeGen {
     unsigned  arg_size() const { return NumArgs; }
 
     bool isNoReturn() const { return NoReturn; }
+    bool isReturnsTwice() const { return ReturnsTwice; }
 
     /// In ARR, whether this function retains its return value.  This
     /// is not always reliable for call sites.
@@ -180,6 +184,7 @@ namespace CodeGen {
     void Profile(llvm::FoldingSetNodeID &ID) {
       ID.AddInteger(getCallingConvention());
       ID.AddBoolean(NoReturn);
+      ID.AddBoolean(ReturnsTwice);
       ID.AddBoolean(ReturnsRetained);
       ID.AddBoolean(HasRegParm);
       ID.AddInteger(RegParm);
@@ -195,6 +200,7 @@ namespace CodeGen {
                         Iterator end) {
       ID.AddInteger(Info.getCC());
       ID.AddBoolean(Info.getNoReturn());
+      ID.AddBoolean(Info.getReturnsTwice());
       ID.AddBoolean(Info.getProducesResult());
       ID.AddBoolean(Info.getHasRegParm());
       ID.AddInteger(Info.getRegParm());
diff --git a/lib/Sema/SemaDecl.cpp b/lib/Sema/SemaDecl.cpp
index d19023d..31e9917 100644
--- a/lib/Sema/SemaDecl.cpp
+++ b/lib/Sema/SemaDecl.cpp
@@ -1737,6 +1737,11 @@ bool Sema::MergeFunctionDecl(FunctionDecl *New, Decl *OldD) {
     RequiresAdjustment = true;
   }
 
+  if (OldTypeInfo.getReturnsTwice() != NewTypeInfo.getReturnsTwice()) {
+    NewTypeInfo = NewTypeInfo.withReturnsTwice(true);
+    RequiresAdjustment = true;
+  }
+
   // Merge regparm attribute.
   if (OldTypeInfo.getHasRegParm() != NewTypeInfo.getHasRegParm() ||
       OldTypeInfo.getRegParm() != NewTypeInfo.getRegParm()) {
diff --git a/lib/Sema/SemaDeclAttr.cpp b/lib/Sema/SemaDeclAttr.cpp
index f76bb58..6474245 100644
--- a/lib/Sema/SemaDeclAttr.cpp
+++ b/lib/Sema/SemaDeclAttr.cpp
@@ -1316,6 +1316,16 @@ bool Sema::CheckNoReturnAttr(const AttributeList &attr) {
   return false;
 }
 
+bool Sema::CheckReturnsTwiceAttr(const AttributeList &attr) {
+  if (attr.hasParameterOrArguments()) {
+    Diag(attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
+    attr.setInvalid();
+    return true;
+  }
+
+  return false;
+}
+
 static void handleAnalyzerNoReturnAttr(Sema &S, Decl *D,
                                        const AttributeList &Attr) {
   
diff --git a/lib/Sema/SemaType.cpp b/lib/Sema/SemaType.cpp
index 154b2a8..c7fcc83 100644
--- a/lib/Sema/SemaType.cpp
+++ b/lib/Sema/SemaType.cpp
@@ -95,6 +95,7 @@ static void diagnoseBadTypeAttribute(Sema &S, const AttributeList &attr,
 
 // Function type attributes.
 #define FUNCTION_TYPE_ATTRS_CASELIST \
+    case AttributeList::AT_returns_twice: \
     case AttributeList::AT_noreturn: \
     case AttributeList::AT_cdecl: \
     case AttributeList::AT_fastcall: \
@@ -2673,6 +2674,8 @@ static AttributeList::Kind getAttrListKind(AttributedType::Kind kind) {
     return AttributeList::AT_objc_ownership;
   case AttributedType::attr_noreturn:
     return AttributeList::AT_noreturn;
+  case AttributedType::attr_returns_twice:
+    return AttributeList::AT_returns_twice;
   case AttributedType::attr_cdecl:
     return AttributeList::AT_cdecl;
   case AttributedType::attr_fastcall:
@@ -3479,6 +3482,21 @@ static bool handleFunctionTypeAttr(TypeProcessingState &state,
     return true;
   }
 
+  if (attr.getKind() == AttributeList::AT_returns_twice) {
+    if (S.CheckReturnsTwiceAttr(attr))
+      return true;
+
+    // Delay if this is not a function type.
+    if (!unwrapped.isFunctionType())
+      return false;
+
+    // Otherwise we can process right away.
+    FunctionType::ExtInfo EI =
+      unwrapped.get()->getExtInfo().withReturnsTwice(true);
+    type = unwrapped.wrap(S, S.Context.adjustFunctionType(unwrapped.get(), EI));
+    return true;
+  }
+
   // ns_returns_retained is not always a type attribute, but if we got
   // here, we're treating it as one right now.
   if (attr.getKind() == AttributeList::AT_ns_returns_retained) {
diff --git a/lib/Serialization/ASTReader.cpp b/lib/Serialization/ASTReader.cpp
index 361c3b7..9d96d8f 100644
--- a/lib/Serialization/ASTReader.cpp
+++ b/lib/Serialization/ASTReader.cpp
@@ -3250,13 +3250,13 @@ QualType ASTReader::readTypeRecord(unsigned Index) {
   }
 
   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);
   }
 
@@ -3268,9 +3268,10 @@ QualType ASTReader::readTypeRecord(unsigned Index) {
                                         /*hasregparm*/ Record[2],
                                         /*regparm*/ Record[3],
                                         static_cast<CallingConv>(Record[4]),
-                                        /*produces*/ Record[5]);
+                                        /*produces*/ Record[5],
+                                        /*returnsTwice*/ Record[6]);
 
-    unsigned Idx = 6;
+    unsigned Idx = 7;
     unsigned NumParams = Record[Idx++];
     SmallVector<QualType, 16> ParamTypes;
     for (unsigned I = 0; I != NumParams; ++I)
diff --git a/lib/Serialization/ASTWriter.cpp b/lib/Serialization/ASTWriter.cpp
index b31262d..30eb4c4 100644
--- a/lib/Serialization/ASTWriter.cpp
+++ b/lib/Serialization/ASTWriter.cpp
@@ -172,6 +172,7 @@ void ASTTypeWriter::VisitFunctionType(const FunctionType *T) {
   // FIXME: need to stabilize encoding of calling convention...
   Record.push_back(C.getCC());
   Record.push_back(C.getProducesResult());
+  Record.push_back(C.getReturnsTwice());
 }
 
 void ASTTypeWriter::VisitFunctionNoProtoType(const FunctionNoProtoType *T) {
diff --git a/test/Analysis/security-syntax-checks.m b/test/Analysis/security-syntax-checks.m
index a04401b..6fb5b3c 100644
--- a/test/Analysis/security-syntax-checks.m
+++ b/test/Analysis/security-syntax-checks.m
@@ -170,7 +170,7 @@ void test_strcat() {
 //===----------------------------------------------------------------------===
 typedef int __int32_t;
 typedef __int32_t pid_t;
-pid_t vfork(void);
+pid_t vfork(void); //expected-warning{{declaration of built-in function 'vfork' requires inclusion of the header <setjmp.h>}}
 
 void test_vfork() {
   vfork(); //expected-warning{{Call to function 'vfork' is insecure as it can lead to denial of service situations in the parent process.}}
diff --git a/test/CodeGen/function-attributes.c b/test/CodeGen/function-attributes.c
index fd98458..6cbf40b 100644
--- a/test/CodeGen/function-attributes.c
+++ b/test/CodeGen/function-attributes.c
@@ -100,3 +100,14 @@ __attribute__ ((returns_twice)) void f17(void);
 __attribute__ ((returns_twice)) void f18(void) {
         f17();
 }
+
+// CHECK: define void @f19()
+// CHECK: {
+// CHECK: call i32 @setjmp(i32* null)
+// CHECK: returns_twice
+// CHECK: ret void
+typedef int jmp_buf[((9 * 2) + 3 + 16)];
+int setjmp(jmp_buf);
+void f19(void) {
+  setjmp(0);
+}
