Index: include/clang/AST/Decl.h
===================================================================
--- include/clang/AST/Decl.h
+++ include/clang/AST/Decl.h
@@ -953,6 +953,9 @@
     /// Whether this variable is (C++0x) constexpr.
     unsigned IsConstexpr : 1;
 
+    /// Whether this variable is a suspension point for a resumable expression.
+    unsigned IsResumable : 1;
+
     /// Whether this variable is the implicit variable for a lambda
     /// init-capture.
     unsigned IsInitCapture : 1;
@@ -1386,6 +1389,15 @@
     NonParmVarDeclBits.IsConstexpr = IC;
   }
 
+  /// Wheither this variable is specified with the 'resumable' keyword.
+  bool isResumableSpecified() const {
+    return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.IsResumable;
+  }
+  void setResumableSpecified(bool IR) {
+    assert(!isa<ParmVarDecl>(this));
+    NonParmVarDeclBits.IsResumable = IR;
+  }
+
   /// Whether this variable is the implicit variable for a lambda init-capture.
   bool isInitCapture() const {
     return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.IsInitCapture;
@@ -1760,6 +1772,8 @@
   unsigned HasImplicitReturnZero : 1;
   unsigned IsLateTemplateParsed : 1;
   unsigned IsConstexpr : 1;
+  unsigned IsResumableSpecified : 1;
+  unsigned IsImplicitlyResumable : 1;
   unsigned InstantiationIsPending : 1;
 
   /// Indicates if the function uses __try.
@@ -1862,7 +1876,7 @@
   FunctionDecl(Kind DK, ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
                const DeclarationNameInfo &NameInfo, QualType T,
                TypeSourceInfo *TInfo, StorageClass S, bool isInlineSpecified,
-               bool isConstexprSpecified)
+               bool isConstexprSpecified, bool isResumableSpecified)
       : DeclaratorDecl(DK, DC, NameInfo.getLoc(), NameInfo.getName(), T, TInfo,
                        StartLoc),
         DeclContext(DK), redeclarable_base(C), SClass(S),
@@ -1870,13 +1884,15 @@
         IsExplicitSpecified(false), IsVirtualAsWritten(false), IsPure(false),
         HasInheritedPrototype(false), HasWrittenPrototype(true),
         IsDeleted(false), IsTrivial(false), IsTrivialForCall(false),
-        IsDefaulted(false),
-        IsExplicitlyDefaulted(false), HasImplicitReturnZero(false),
-        IsLateTemplateParsed(false), IsConstexpr(isConstexprSpecified),
-        InstantiationIsPending(false), UsesSEHTry(false), HasSkippedBody(false),
-        WillHaveBody(false), IsMultiVersion(false),
-        IsCopyDeductionCandidate(false), HasODRHash(false), ODRHash(0),
-        EndRangeLoc(NameInfo.getEndLoc()), DNLoc(NameInfo.getInfo()) {}
+        IsDefaulted(false), IsExplicitlyDefaulted(false),
+        HasImplicitReturnZero(false), IsLateTemplateParsed(false),
+        IsConstexpr(isConstexprSpecified),
+        IsResumableSpecified(isResumableSpecified),
+        IsImplicitlyResumable(false), InstantiationIsPending(false),
+        UsesSEHTry(false), HasSkippedBody(false), WillHaveBody(false),
+        IsMultiVersion(false), IsCopyDeductionCandidate(false),
+        HasODRHash(false), ODRHash(0), EndRangeLoc(NameInfo.getEndLoc()),
+        DNLoc(NameInfo.getInfo()) {}
 
   using redeclarable_base = Redeclarable<FunctionDecl>;
 
@@ -1906,29 +1922,23 @@
   using redeclarable_base::getMostRecentDecl;
   using redeclarable_base::isFirstDecl;
 
-  static FunctionDecl *Create(ASTContext &C, DeclContext *DC,
-                              SourceLocation StartLoc, SourceLocation NLoc,
-                              DeclarationName N, QualType T,
-                              TypeSourceInfo *TInfo,
-                              StorageClass SC,
-                              bool isInlineSpecified = false,
-                              bool hasWrittenPrototype = true,
-                              bool isConstexprSpecified = false) {
+  static FunctionDecl *
+  Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
+         SourceLocation NLoc, DeclarationName N, QualType T,
+         TypeSourceInfo *TInfo, StorageClass SC, bool isInlineSpecified = false,
+         bool hasWrittenPrototype = true, bool isConstexprSpecified = false,
+         bool isResumableSpecified = false) {
     DeclarationNameInfo NameInfo(N, NLoc);
-    return FunctionDecl::Create(C, DC, StartLoc, NameInfo, T, TInfo,
-                                SC,
+    return FunctionDecl::Create(C, DC, StartLoc, NameInfo, T, TInfo, SC,
                                 isInlineSpecified, hasWrittenPrototype,
-                                isConstexprSpecified);
+                                isConstexprSpecified, isResumableSpecified);
   }
 
-  static FunctionDecl *Create(ASTContext &C, DeclContext *DC,
-                              SourceLocation StartLoc,
-                              const DeclarationNameInfo &NameInfo,
-                              QualType T, TypeSourceInfo *TInfo,
-                              StorageClass SC,
-                              bool isInlineSpecified,
-                              bool hasWrittenPrototype,
-                              bool isConstexprSpecified = false);
+  static FunctionDecl *
+  Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
+         const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo,
+         StorageClass SC, bool isInlineSpecified, bool hasWrittenPrototype,
+         bool isConstexprSpecified = false, bool isResumableSpecified = false);
 
   static FunctionDecl *CreateDeserialized(ASTContext &C, unsigned ID);
                        
@@ -2088,6 +2098,16 @@
   bool isConstexpr() const { return IsConstexpr; }
   void setConstexpr(bool IC) { IsConstexpr = IC; }
 
+  bool isResumable() const {
+    return IsResumableSpecified || IsImplicitlyResumable;
+  }
+
+  bool isResumableSpecified() const { return IsResumableSpecified; }
+  void setResumableSpecified(bool IR) { IsResumableSpecified = IR; }
+
+  bool isImplicitlyResumable() const { return IsImplicitlyResumable; }
+  void setImplicitlyResumable(bool IR) { IsImplicitlyResumable = IR; }
+
   /// Whether the instantiation of this function is pending.
   /// This bit is set when the decision to instantiate this function is made
   /// and unset if and when the function body is created. That leaves out
Index: include/clang/AST/DeclCXX.h
===================================================================
--- include/clang/AST/DeclCXX.h
+++ include/clang/AST/DeclCXX.h
@@ -1984,7 +1984,7 @@
                         QualType T, TypeSourceInfo *TInfo,
                         SourceLocation EndLocation)
       : FunctionDecl(CXXDeductionGuide, C, DC, StartLoc, NameInfo, T, TInfo,
-                     SC_None, false, false) {
+                     SC_None, false, false, false) {
     if (EndLocation.isValid())
       setRangeEnd(EndLocation);
     IsExplicitSpecified = IsExplicit;
@@ -2034,11 +2034,11 @@
 protected:
   CXXMethodDecl(Kind DK, ASTContext &C, CXXRecordDecl *RD,
                 SourceLocation StartLoc, const DeclarationNameInfo &NameInfo,
-                QualType T, TypeSourceInfo *TInfo,
-                StorageClass SC, bool isInline,
-                bool isConstexpr, SourceLocation EndLocation)
-    : FunctionDecl(DK, C, RD, StartLoc, NameInfo, T, TInfo,
-                   SC, isInline, isConstexpr) {
+                QualType T, TypeSourceInfo *TInfo, StorageClass SC,
+                bool isInline, bool isConstexpr, bool isResumable,
+                SourceLocation EndLocation)
+      : FunctionDecl(DK, C, RD, StartLoc, NameInfo, T, TInfo, SC, isInline,
+                     isConstexpr, isResumable) {
     if (EndLocation.isValid())
       setRangeEnd(EndLocation);
   }
@@ -2046,12 +2046,10 @@
 public:
   static CXXMethodDecl *Create(ASTContext &C, CXXRecordDecl *RD,
                                SourceLocation StartLoc,
-                               const DeclarationNameInfo &NameInfo,
-                               QualType T, TypeSourceInfo *TInfo,
-                               StorageClass SC,
-                               bool isInline,
-                               bool isConstexpr,
-                               SourceLocation EndLocation);
+                               const DeclarationNameInfo &NameInfo, QualType T,
+                               TypeSourceInfo *TInfo, StorageClass SC,
+                               bool isInline, bool isConstexpr,
+                               bool isResumable, SourceLocation EndLocation);
 
   static CXXMethodDecl *CreateDeserialized(ASTContext &C, unsigned ID);
 
@@ -2475,14 +2473,14 @@
   unsigned IsInheritingConstructor : 1;
 
   CXXConstructorDecl(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
-                     const DeclarationNameInfo &NameInfo,
-                     QualType T, TypeSourceInfo *TInfo,
-                     bool isExplicitSpecified, bool isInline,
-                     bool isImplicitlyDeclared, bool isConstexpr,
+                     const DeclarationNameInfo &NameInfo, QualType T,
+                     TypeSourceInfo *TInfo, bool isExplicitSpecified,
+                     bool isInline, bool isImplicitlyDeclared, bool isConstexpr,
                      InheritedConstructor Inherited)
-    : CXXMethodDecl(CXXConstructor, C, RD, StartLoc, NameInfo, T, TInfo,
-                    SC_None, isInline, isConstexpr, SourceLocation()),
-      NumCtorInitializers(0), IsInheritingConstructor((bool)Inherited) {
+      : CXXMethodDecl(CXXConstructor, C, RD, StartLoc, NameInfo, T, TInfo,
+                      SC_None, isInline, isConstexpr, /*isResumable=*/false,
+                      SourceLocation()),
+        NumCtorInitializers(0), IsInheritingConstructor((bool)Inherited) {
     setImplicit(isImplicitlyDeclared);
     if (Inherited)
       *getTrailingObjects<InheritedConstructor>() = Inherited;
@@ -2693,12 +2691,12 @@
   Expr *OperatorDeleteThisArg = nullptr;
 
   CXXDestructorDecl(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
-                    const DeclarationNameInfo &NameInfo,
-                    QualType T, TypeSourceInfo *TInfo,
-                    bool isInline, bool isImplicitlyDeclared)
-    : CXXMethodDecl(CXXDestructor, C, RD, StartLoc, NameInfo, T, TInfo,
-                    SC_None, isInline, /*isConstexpr=*/false, SourceLocation())
-  {
+                    const DeclarationNameInfo &NameInfo, QualType T,
+                    TypeSourceInfo *TInfo, bool isInline,
+                    bool isImplicitlyDeclared)
+      : CXXMethodDecl(CXXDestructor, C, RD, StartLoc, NameInfo, T, TInfo,
+                      SC_None, isInline, /*isConstexpr=*/false,
+                      /*isResumable=*/false, SourceLocation()) {
     setImplicit(isImplicitlyDeclared);
   }
 
@@ -2750,9 +2748,10 @@
                     const DeclarationNameInfo &NameInfo, QualType T,
                     TypeSourceInfo *TInfo, bool isInline,
                     bool isExplicitSpecified, bool isConstexpr,
-                    SourceLocation EndLocation)
+                    bool isResumable, SourceLocation EndLocation)
       : CXXMethodDecl(CXXConversion, C, RD, StartLoc, NameInfo, T, TInfo,
-                      SC_None, isInline, isConstexpr, EndLocation) {
+                      SC_None, isInline, isConstexpr, isResumable,
+                      EndLocation) {
     IsExplicitSpecified = isExplicitSpecified;
   }
 
@@ -2762,13 +2761,11 @@
   friend class ASTDeclReader;
   friend class ASTDeclWriter;
 
-  static CXXConversionDecl *Create(ASTContext &C, CXXRecordDecl *RD,
-                                   SourceLocation StartLoc,
-                                   const DeclarationNameInfo &NameInfo,
-                                   QualType T, TypeSourceInfo *TInfo,
-                                   bool isInline, bool isExplicit,
-                                   bool isConstexpr,
-                                   SourceLocation EndLocation);
+  static CXXConversionDecl *
+  Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
+         const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo,
+         bool isInline, bool isExplicit, bool isConstexpr, bool isResumable,
+         SourceLocation EndLocation);
   static CXXConversionDecl *CreateDeserialized(ASTContext &C, unsigned ID);
 
   /// Whether this function is marked as explicit explicitly.
Index: include/clang/AST/Stmt.h
===================================================================
--- include/clang/AST/Stmt.h
+++ include/clang/AST/Stmt.h
@@ -113,6 +113,14 @@
     unsigned IsConstexpr : 1;
   };
 
+  class BreakStmtBitfields {
+    friend class BreakStmt;
+
+    unsigned : NumStmtBits;
+
+    unsigned IsResumable : 1;
+  };
+
   class ExprBitfields {
     friend class ASTStmtReader; // deserialization
     friend class AtomicExpr; // ctor
@@ -295,6 +303,7 @@
     StmtBitfields StmtBits;
     CompoundStmtBitfields CompoundStmtBits;
     IfStmtBitfields IfStmtBits;
+    BreakStmtBitfields BreakStmtBits;
     ExprBitfields ExprBits;
     CharacterLiteralBitfields CharacterLiteralBits;
     FloatingLiteralBitfields FloatingLiteralBits;
@@ -1396,21 +1405,36 @@
 /// BreakStmt - This represents a break.
 class BreakStmt : public Stmt {
   SourceLocation BreakLoc;
+  SourceLocation ResumableLoc;
 
 public:
-  BreakStmt(SourceLocation BL) : Stmt(BreakStmtClass), BreakLoc(BL) {
-    static_assert(sizeof(BreakStmt) == 2 * sizeof(SourceLocation),
+  BreakStmt(SourceLocation BL, bool IsResumable = false,
+            SourceLocation ResumableLoc = SourceLocation())
+      : Stmt(BreakStmtClass), BreakLoc(BL), ResumableLoc(ResumableLoc) {
+    assert(IsResumable == ResumableLoc.isValid());
+    BreakStmtBits.IsResumable = IsResumable;
+    // FIXME(EricWF): Figure out why this assert was here, and specified
+    // sizeof(BreakStmt) == 2 * sizeof(SourceLocation)
+    static_assert(sizeof(BreakStmt) == 4 * sizeof(SourceLocation),
                   "BreakStmt too large");
   }
 
   /// Build an empty break statement.
   explicit BreakStmt(EmptyShell Empty) : Stmt(BreakStmtClass, Empty) {}
 
+  bool isResumableSpecified() const { return BreakStmtBits.IsResumable; }
+  void setResumableSpecified() { BreakStmtBits.IsResumable = true; }
+
   SourceLocation getBreakLoc() const { return BreakLoc; }
   void setBreakLoc(SourceLocation L) { BreakLoc = L; }
 
+  SourceLocation getResumableLoc() const { return ResumableLoc; }
+  void setResumableLoc(SourceLocation L) { ResumableLoc = L; }
+
   SourceLocation getLocStart() const LLVM_READONLY { return BreakLoc; }
-  SourceLocation getLocEnd() const LLVM_READONLY { return BreakLoc; }
+  SourceLocation getLocEnd() const LLVM_READONLY {
+    return isResumableSpecified() ? ResumableLoc : BreakLoc;
+  }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == BreakStmtClass;
Index: include/clang/Basic/DiagnosticSemaKinds.td
===================================================================
--- include/clang/Basic/DiagnosticSemaKinds.td
+++ include/clang/Basic/DiagnosticSemaKinds.td
@@ -686,6 +686,8 @@
 def note_main_remove_noreturn : Note<"remove '_Noreturn'">;
 def err_constexpr_main : Error<
   "'main' is not allowed to be declared constexpr">;
+def err_resumable_main : Error<
+  "'main' is not allowed to be declared resumable">;
 def err_deleted_main : Error<"'main' is not allowed to be deleted">;
 def err_mainlike_template_decl : Error<"%0 cannot be a template">;
 def err_main_returns_nonint : Error<"'main' must return 'int'">;
@@ -2394,6 +2396,48 @@
 def note_private_extern : Note<
   "use __attribute__((visibility(\"hidden\"))) attribute instead">;
 
+// C++ Resumable functions
+def err_resumable_ctor_dtor : Error<
+  "%select{constructor|destructor}0 cannot be marked resumable">;
+def err_invalid_resumable : Error<
+  "%select{function parameter|typedef|non-static data member|global variable}0 "
+  "cannot be resumable">;
+def err_resumable_tag : Error<
+  "%select{class|struct|interface|union|enum}0 cannot be marked resumable">;
+def err_resumable_no_declarators : Error<
+  "resumable can only be used in variable and function declarations">;
+def err_invalid_resumable_var_decl : Error<
+  "resumable variable declaration must be a definition">;
+def err_resumable_redecl_mismatch : Error<
+  "%select{non-resumable declaration of %0 follows resumable declaration"
+  "|resumable declaration of %0 follows non-resumable declaration}1">;
+def err_resumable_virtual : Error<"virtual function cannot be resumable">;
+def err_resumable_local_var_static : Error<
+  "%select{static|thread_local}1 variable not permitted in a resumable "
+  "%select{function|constructor}0">;
+def err_resumable_var_decl_type : Error<
+  "resumable variable cannot be declared with type %0; "
+  "declared type must be 'auto'">;
+def err_resumable_var_decl_constexpr : Error<
+  "resumable variable declaration %0 cannot be constexpr">;
+def err_resumable_var_decl_requires_init : Error<
+  "resumable variable declaration %0 requires an initializer">;
+def err_resumable_func_is_coroutine : Error<
+  "resumable function %0 cannot be a coroutine">;
+def err_resumable_var_decl_init_not_call_expr : Error<
+  "initializer for the resumable variable declaration %0 must be a call to a "
+  "resumable function">;
+def err_resumable_var_decl_init_not_resumable_expr : Error<
+  "initializer for resumable variable declaration %0 calls a non-resumable "
+  "function">;
+def note_function_declared_here : Note<
+  "function declared here">;
+def err_addrof_resumable_fn : Error<
+    "cannot take address of resumable function %0">;
+def note_addrof_ovl_candidate_resumable_fn : Note<
+    "candidate function address cannot be taken because the function is resumable">;
+
+
 // C++ Concepts TS
 def err_concept_wrong_decl_kind : Error<
   "'concept' can only appear on the definition of a function template or variable template">;
@@ -7922,6 +7966,8 @@
   "'continue' statement not in loop statement">;
 def err_break_not_in_loop_or_switch : Error<
   "'break' statement not in loop or switch statement">;
+def err_break_resumable_not_in_resumable_function : Error<
+  "'break resumable' statement not in a resumable function">;
 def warn_loop_ctrl_binds_to_inner : Warning<
   "'%0' is bound to current loop, GCC binds it to the enclosing loop">,
   InGroup<GccCompat>;
@@ -9287,8 +9333,8 @@
   "attributes">;
 def err_multiversion_diff : Error<
   "multiversioned function declaration has a different %select{calling convention"
-  "|return type|constexpr specification|inline specification|storage class|"
-  "linkage}0">;
+  "|return type|constexpr specification|inline specification"
+  "|resumable specification|storage class|linkage}0">;
 def err_multiversion_doesnt_support : Error<
   "multiversioned functions do not yet support %select{function templates|"
   "virtual functions|deduced return types|constructors|destructors|"
Index: include/clang/Basic/LangOptions.def
===================================================================
--- include/clang/Basic/LangOptions.def
+++ include/clang/Basic/LangOptions.def
@@ -140,6 +140,7 @@
 LANGOPT(GNUAsm            , 1, 1, "GNU-style inline assembly")
 LANGOPT(CoroutinesTS      , 1, 0, "C++ coroutines TS")
 LANGOPT(RelaxedTemplateTemplateArgs, 1, 0, "C++17 relaxed matching of template template arguments")
+LANGOPT(ResumableFunctions, 1, 0, "C++ Resumable Functions (N4453)")
 
 LANGOPT(DoubleSquareBracketAttributes, 1, 0, "'[[]]' attributes extension for all language standard modes")
 
Index: include/clang/Basic/TokenKinds.def
===================================================================
--- include/clang/Basic/TokenKinds.def
+++ include/clang/Basic/TokenKinds.def
@@ -379,6 +379,9 @@
 KEYWORD(co_return                   , KEYCOROUTINES)
 KEYWORD(co_yield                    , KEYCOROUTINES)
 
+// C++ resumable function proposal keywords (N4453)
+KEYWORD(resumable, KEYRESUMABLEFUNCS)
+
 // C++ modules TS keywords
 MODULES_KEYWORD(module)
 MODULES_KEYWORD(import)
Index: include/clang/Driver/Options.td
===================================================================
--- include/clang/Driver/Options.td
+++ include/clang/Driver/Options.td
@@ -670,6 +670,11 @@
 def fno_coroutines_ts : Flag <["-"], "fno-coroutines-ts">, Group<f_Group>,
   Flags<[DriverOption]>;
 
+// C++ Resumable Functions (N4453)
+def fresumable_functions : Flag<["-"], "fresumable-functions">, Group<f_Group>,
+  Flags<[DriverOption, CC1Option]>,
+  HelpText<"Enable support for C++ resumable functions">;
+
 def fembed_bitcode_EQ : Joined<["-"], "fembed-bitcode=">,
     Group<f_Group>, Flags<[DriverOption, CC1Option]>, MetaVarName<"<option>">,
     HelpText<"Embed LLVM bitcode (option: off, all, bitcode, marker)">;
Index: include/clang/Sema/DeclSpec.h
===================================================================
--- include/clang/Sema/DeclSpec.h
+++ include/clang/Sema/DeclSpec.h
@@ -364,6 +364,9 @@
   // constexpr-specifier
   unsigned Constexpr_specified : 1;
 
+  // resumable-specifier
+  unsigned Resumable_specified : 1;
+
   union {
     UnionParsedType TypeRep;
     Decl *DeclRep;
@@ -393,7 +396,7 @@
       TQ_unalignedLoc;
   SourceLocation FS_inlineLoc, FS_virtualLoc, FS_explicitLoc, FS_noreturnLoc;
   SourceLocation FS_forceinlineLoc;
-  SourceLocation FriendLoc, ModulePrivateLoc, ConstexprLoc;
+  SourceLocation FriendLoc, ModulePrivateLoc, ConstexprLoc, ResumableLoc;
   SourceLocation TQ_pipeLoc;
 
   WrittenBuiltinSpecs writtenBS;
@@ -419,30 +422,18 @@
   }
 
   DeclSpec(AttributeFactory &attrFactory)
-    : StorageClassSpec(SCS_unspecified),
-      ThreadStorageClassSpec(TSCS_unspecified),
-      SCS_extern_in_linkage_spec(false),
-      TypeSpecWidth(TSW_unspecified),
-      TypeSpecComplex(TSC_unspecified),
-      TypeSpecSign(TSS_unspecified),
-      TypeSpecType(TST_unspecified),
-      TypeAltiVecVector(false),
-      TypeAltiVecPixel(false),
-      TypeAltiVecBool(false),
-      TypeSpecOwned(false),
-      TypeSpecPipe(false),
-      TypeQualifiers(TQ_unspecified),
-      FS_inline_specified(false),
-      FS_forceinline_specified(false),
-      FS_virtual_specified(false),
-      FS_explicit_specified(false),
-      FS_noreturn_specified(false),
-      Friend_specified(false),
-      Constexpr_specified(false),
-      Attrs(attrFactory),
-      writtenBS(),
-      ObjCQualifiers(nullptr) {
-  }
+      : StorageClassSpec(SCS_unspecified),
+        ThreadStorageClassSpec(TSCS_unspecified),
+        SCS_extern_in_linkage_spec(false), TypeSpecWidth(TSW_unspecified),
+        TypeSpecComplex(TSC_unspecified), TypeSpecSign(TSS_unspecified),
+        TypeSpecType(TST_unspecified), TypeAltiVecVector(false),
+        TypeAltiVecPixel(false), TypeAltiVecBool(false), TypeSpecOwned(false),
+        TypeSpecPipe(false), TypeQualifiers(TQ_unspecified),
+        FS_inline_specified(false), FS_forceinline_specified(false),
+        FS_virtual_specified(false), FS_explicit_specified(false),
+        FS_noreturn_specified(false), Friend_specified(false),
+        Constexpr_specified(false), Resumable_specified(false),
+        Attrs(attrFactory), writtenBS(), ObjCQualifiers(nullptr) {}
 
   // storage-class-specifier
   SCS getStorageClassSpec() const { return (SCS)StorageClassSpec; }
@@ -696,6 +687,8 @@
                             unsigned &DiagID);
   bool SetConstexprSpec(SourceLocation Loc, const char *&PrevSpec,
                         unsigned &DiagID);
+  bool SetResumableSpec(SourceLocation Loc, const char *&PrevSpec,
+                        unsigned &DiagID);
 
   bool isFriendSpecified() const { return Friend_specified; }
   SourceLocation getFriendSpecLoc() const { return FriendLoc; }
@@ -706,6 +699,9 @@
   bool isConstexprSpecified() const { return Constexpr_specified; }
   SourceLocation getConstexprSpecLoc() const { return ConstexprLoc; }
 
+  bool isResumableSpecified() const { return Resumable_specified; }
+  SourceLocation getResumableSpecLoc() const { return ResumableLoc; }
+
   void ClearConstexprSpec() {
     Constexpr_specified = false;
     ConstexprLoc = SourceLocation();
Index: include/clang/Sema/ScopeInfo.h
===================================================================
--- include/clang/Sema/ScopeInfo.h
+++ include/clang/Sema/ScopeInfo.h
@@ -163,6 +163,12 @@
   /// (ex co_return, co_await, co_yield)
   SourceLocation FirstCoroutineStmtLoc;
 
+  /// First resumable expression location.
+  /// (ex 'break resumable' or a call to a resumable function)
+  SourceLocation FirstResumableStmtLoc;
+
+  SourceLocation FirstBreakResumableStmtLoc;
+
   /// First 'return' statement in the current function.
   SourceLocation FirstReturnLoc;
 
@@ -464,6 +470,23 @@
     CoroutineSuspends.second = Final;
   }
 
+  void setFirstResumableStmt(SourceLocation Loc) {
+    if (FirstResumableStmtLoc.isInvalid())
+      FirstResumableStmtLoc = Loc;
+  }
+
+  bool hasResumableStmt() const { return FirstResumableStmtLoc.isValid(); }
+
+  void setFirstBreakResumableStmt(SourceLocation Loc) {
+    if (FirstBreakResumableStmtLoc.isInvalid())
+      FirstBreakResumableStmtLoc = Loc;
+    setFirstResumableStmt(Loc);
+  }
+
+  bool hasBreakResumableStmt() const {
+    return FirstBreakResumableStmtLoc.isValid();
+  }
+
   /// Clear out the information in this function scope, making it
   /// suitable for reuse.
   void Clear();
Index: include/clang/Sema/Sema.h
===================================================================
--- include/clang/Sema/Sema.h
+++ include/clang/Sema/Sema.h
@@ -1922,6 +1922,17 @@
   bool CheckConstexprFunctionDecl(const FunctionDecl *FD);
   bool CheckConstexprFunctionBody(const FunctionDecl *FD, Stmt *Body);
 
+  /// Check whether a function declaration satisfies the requirements
+  /// of a constexpr function. If so, return true. If not, produce the
+  /// appropriate diagnostics and return false.
+  bool CheckResumableFunctionDecl(const FunctionDecl *FD);
+  void CheckCompletedResumableFunctionBody(FunctionDecl *FD, Stmt *Body);
+
+  bool CheckResumableVarDecl(VarDecl *VD, Expr *Init);
+
+  void SetCurFunctionImplicitlyResumable(SourceLocation Loc,
+                                         bool IsBreakResumable = false);
+
   void DiagnoseHiddenVirtualMethods(CXXMethodDecl *MD);
   void FindHiddenVirtualMethods(CXXMethodDecl *MD,
                           SmallVectorImpl<CXXMethodDecl*> &OverloadedMethods);
@@ -3785,7 +3796,9 @@
                                    SourceLocation StarLoc,
                                    Expr *DestExp);
   StmtResult ActOnContinueStmt(SourceLocation ContinueLoc, Scope *CurScope);
-  StmtResult ActOnBreakStmt(SourceLocation BreakLoc, Scope *CurScope);
+  StmtResult ActOnBreakStmt(SourceLocation BreakLoc, Scope *CurScope,
+                            bool IsResumable = false,
+                            SourceLocation ResumableLoc = SourceLocation());
 
   void ActOnCapturedRegionStart(SourceLocation Loc, Scope *CurScope,
                                 CapturedRegionKind Kind, unsigned NumParams);
@@ -5302,7 +5315,8 @@
   ExprResult ActOnFinishFullExpr(Expr *Expr, SourceLocation CC,
                                  bool DiscardedValue = false,
                                  bool IsConstexpr = false,
-                                 bool IsLambdaInitCaptureInitializer = false);
+                                 bool IsLambdaInitCaptureInitializer = false,
+                                 bool IsResumable = false);
   StmtResult ActOnFinishFullStmt(Stmt *Stmt);
 
   // Marks SS invalid if it represents an incomplete type.
Index: lib/AST/ASTDumper.cpp
===================================================================
--- lib/AST/ASTDumper.cpp
+++ lib/AST/ASTDumper.cpp
@@ -514,6 +514,7 @@
     void VisitGotoStmt(const GotoStmt *Node);
     void VisitCXXCatchStmt(const CXXCatchStmt *Node);
     void VisitCapturedStmt(const CapturedStmt *Node);
+    void VisitBreakStmt(const BreakStmt *Node);
 
     // OpenMP
     void VisitOMPExecutableDirective(const OMPExecutableDirective *Node);
@@ -1066,10 +1067,12 @@
       OS << " referenced";
     if (D->isInvalidDecl())
       OS << " invalid";
-    if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
+    if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
       if (FD->isConstexpr())
         OS << " constexpr";
-
+      if (FD->isResumableSpecified())
+        OS << " resumable";
+    }
 
     ConstDeclVisitor<ASTDumper>::Visit(D);
 
@@ -1253,6 +1256,9 @@
     OS << " inline";
   if (D->isConstexpr())
     OS << " constexpr";
+  if (D->isResumableSpecified())
+    OS << " resumable";
+
   if (D->hasInit()) {
     switch (D->getInitStyle()) {
     case VarDecl::CInit: OS << " cinit"; break;
@@ -2009,6 +2015,12 @@
   dumpDecl(Node->getCapturedDecl());
 }
 
+void ASTDumper::VisitBreakStmt(const BreakStmt *Node) {
+  VisitStmt(Node);
+  if (Node->isResumableSpecified())
+    OS << " resumable";
+}
+
 //===----------------------------------------------------------------------===//
 //  OpenMP dumping methods.
 //===----------------------------------------------------------------------===//
Index: lib/AST/ASTImporter.cpp
===================================================================
--- lib/AST/ASTImporter.cpp
+++ lib/AST/ASTImporter.cpp
@@ -2457,30 +2457,22 @@
                                            D->isInlineSpecified(),
                                            D->isImplicit());
   } else if (auto *FromConversion = dyn_cast<CXXConversionDecl>(D)) {
-    ToFunction = CXXConversionDecl::Create(Importer.getToContext(), 
-                                           cast<CXXRecordDecl>(DC),
-                                           InnerLocStart,
-                                           NameInfo, T, TInfo,
-                                           D->isInlineSpecified(),
-                                           FromConversion->isExplicit(),
-                                           D->isConstexpr(),
-                                           Importer.Import(D->getLocEnd()));
+    ToFunction = CXXConversionDecl::Create(
+        Importer.getToContext(), cast<CXXRecordDecl>(DC), InnerLocStart,
+        NameInfo, T, TInfo, D->isInlineSpecified(),
+        FromConversion->isExplicit(), D->isConstexpr(), D->isResumable(),
+        Importer.Import(D->getLocEnd()));
   } else if (auto *Method = dyn_cast<CXXMethodDecl>(D)) {
-    ToFunction = CXXMethodDecl::Create(Importer.getToContext(), 
-                                       cast<CXXRecordDecl>(DC),
-                                       InnerLocStart,
-                                       NameInfo, T, TInfo,
-                                       Method->getStorageClass(),
-                                       Method->isInlineSpecified(),
-                                       D->isConstexpr(),
-                                       Importer.Import(D->getLocEnd()));
+    ToFunction = CXXMethodDecl::Create(
+        Importer.getToContext(), cast<CXXRecordDecl>(DC), InnerLocStart,
+        NameInfo, T, TInfo, Method->getStorageClass(),
+        Method->isInlineSpecified(), D->isConstexpr(), D->isResumable(),
+        Importer.Import(D->getLocEnd()));
   } else {
-    ToFunction = FunctionDecl::Create(Importer.getToContext(), DC,
-                                      InnerLocStart,
-                                      NameInfo, T, TInfo, D->getStorageClass(),
-                                      D->isInlineSpecified(),
-                                      D->hasWrittenPrototype(),
-                                      D->isConstexpr());
+    ToFunction = FunctionDecl::Create(
+        Importer.getToContext(), DC, InnerLocStart, NameInfo, T, TInfo,
+        D->getStorageClass(), D->isInlineSpecified(), D->hasWrittenPrototype(),
+        D->isConstexpr(), D->isResumable());
   }
 
   // Import the qualifier, if any.
Index: lib/AST/Decl.cpp
===================================================================
--- lib/AST/Decl.cpp
+++ lib/AST/Decl.cpp
@@ -4291,17 +4291,15 @@
   return new (C, ID) ImplicitParamDecl(C, QualType(), ImplicitParamKind::Other);
 }
 
-FunctionDecl *FunctionDecl::Create(ASTContext &C, DeclContext *DC,
-                                   SourceLocation StartLoc,
-                                   const DeclarationNameInfo &NameInfo,
-                                   QualType T, TypeSourceInfo *TInfo,
-                                   StorageClass SC,
-                                   bool isInlineSpecified,
-                                   bool hasWrittenPrototype,
-                                   bool isConstexprSpecified) {
-  FunctionDecl *New =
-      new (C, DC) FunctionDecl(Function, C, DC, StartLoc, NameInfo, T, TInfo,
-                               SC, isInlineSpecified, isConstexprSpecified);
+FunctionDecl *
+FunctionDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
+                     const DeclarationNameInfo &NameInfo, QualType T,
+                     TypeSourceInfo *TInfo, StorageClass SC,
+                     bool isInlineSpecified, bool hasWrittenPrototype,
+                     bool isConstexprSpecified, bool isResumableSpecified) {
+  FunctionDecl *New = new (C, DC) FunctionDecl(
+      Function, C, DC, StartLoc, NameInfo, T, TInfo, SC, isInlineSpecified,
+      isConstexprSpecified, isResumableSpecified);
   New->HasWrittenPrototype = hasWrittenPrototype;
   return New;
 }
@@ -4309,7 +4307,7 @@
 FunctionDecl *FunctionDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
   return new (C, ID) FunctionDecl(Function, C, nullptr, SourceLocation(),
                                   DeclarationNameInfo(), QualType(), nullptr,
-                                  SC_None, false, false);
+                                  SC_None, false, false, false);
 }
 
 BlockDecl *BlockDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation L) {
Index: lib/AST/DeclCXX.cpp
===================================================================
--- lib/AST/DeclCXX.cpp
+++ lib/AST/DeclCXX.cpp
@@ -1893,22 +1893,22 @@
   return nullptr;
 }
 
-CXXMethodDecl *
-CXXMethodDecl::Create(ASTContext &C, CXXRecordDecl *RD,
-                      SourceLocation StartLoc,
-                      const DeclarationNameInfo &NameInfo,
-                      QualType T, TypeSourceInfo *TInfo,
-                      StorageClass SC, bool isInline,
-                      bool isConstexpr, SourceLocation EndLocation) {
-  return new (C, RD) CXXMethodDecl(CXXMethod, C, RD, StartLoc, NameInfo,
-                                   T, TInfo, SC, isInline, isConstexpr,
-                                   EndLocation);
+CXXMethodDecl *CXXMethodDecl::Create(ASTContext &C, CXXRecordDecl *RD,
+                                     SourceLocation StartLoc,
+                                     const DeclarationNameInfo &NameInfo,
+                                     QualType T, TypeSourceInfo *TInfo,
+                                     StorageClass SC, bool isInline,
+                                     bool isConstexpr, bool isResumable,
+                                     SourceLocation EndLocation) {
+  return new (C, RD)
+      CXXMethodDecl(CXXMethod, C, RD, StartLoc, NameInfo, T, TInfo, SC,
+                    isInline, isConstexpr, isResumable, EndLocation);
 }
 
 CXXMethodDecl *CXXMethodDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
-  return new (C, ID) CXXMethodDecl(CXXMethod, C, nullptr, SourceLocation(),
-                                   DeclarationNameInfo(), QualType(), nullptr,
-                                   SC_None, false, false, SourceLocation());
+  return new (C, ID) CXXMethodDecl(
+      CXXMethod, C, nullptr, SourceLocation(), DeclarationNameInfo(),
+      QualType(), nullptr, SC_None, false, false, false, SourceLocation());
 }
 
 CXXMethodDecl *CXXMethodDecl::getDevirtualizedMethod(const Expr *Base,
@@ -2421,25 +2421,22 @@
 
 CXXConversionDecl *
 CXXConversionDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
-  return new (C, ID) CXXConversionDecl(C, nullptr, SourceLocation(),
-                                       DeclarationNameInfo(), QualType(),
-                                       nullptr, false, false, false,
-                                       SourceLocation());
+  return new (C, ID) CXXConversionDecl(
+      C, nullptr, SourceLocation(), DeclarationNameInfo(), QualType(), nullptr,
+      false, false, false, false, SourceLocation());
 }
 
-CXXConversionDecl *
-CXXConversionDecl::Create(ASTContext &C, CXXRecordDecl *RD,
-                          SourceLocation StartLoc,
-                          const DeclarationNameInfo &NameInfo,
-                          QualType T, TypeSourceInfo *TInfo,
-                          bool isInline, bool isExplicit,
-                          bool isConstexpr, SourceLocation EndLocation) {
+CXXConversionDecl *CXXConversionDecl::Create(
+    ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
+    const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo,
+    bool isInline, bool isExplicit, bool isConstexpr, bool isResumable,
+    SourceLocation EndLocation) {
   assert(NameInfo.getName().getNameKind()
          == DeclarationName::CXXConversionFunctionName &&
          "Name must refer to a conversion function");
-  return new (C, RD) CXXConversionDecl(C, RD, StartLoc, NameInfo, T, TInfo,
-                                       isInline, isExplicit, isConstexpr,
-                                       EndLocation);
+  return new (C, RD)
+      CXXConversionDecl(C, RD, StartLoc, NameInfo, T, TInfo, isInline,
+                        isExplicit, isConstexpr, isResumable, EndLocation);
 }
 
 bool CXXConversionDecl::isLambdaToBlockPointerConversion() const {
Index: lib/AST/DeclPrinter.cpp
===================================================================
--- lib/AST/DeclPrinter.cpp
+++ lib/AST/DeclPrinter.cpp
@@ -578,6 +578,8 @@
     if (D->isVirtualAsWritten()) Out << "virtual ";
     if (D->isModulePrivate())    Out << "__module_private__ ";
     if (D->isConstexpr() && !D->isExplicitlyDefaulted()) Out << "constexpr ";
+    if (D->isResumable())
+      Out << "resumable ";
     if ((CDecl && CDecl->isExplicitSpecified()) ||
         (ConversionDecl && ConversionDecl->isExplicitSpecified()) ||
         (GuideDecl && GuideDecl->isExplicitSpecified()))
@@ -827,6 +829,9 @@
       Out << "constexpr ";
       T.removeLocalConst();
     }
+
+    if (D->isResumableSpecified())
+      Out << "resumable ";
   }
 
   printDeclType(T, D->getName());
Index: lib/AST/ODRHash.cpp
===================================================================
--- lib/AST/ODRHash.cpp
+++ lib/AST/ODRHash.cpp
@@ -278,6 +278,7 @@
   void VisitVarDecl(const VarDecl *D) {
     Hash.AddBoolean(D->isStaticLocal());
     Hash.AddBoolean(D->isConstexpr());
+    Hash.AddBoolean(D->isResumableSpecified());
     const bool HasInit = D->hasInit();
     Hash.AddBoolean(HasInit);
     if (HasInit) {
Index: lib/Basic/IdentifierTable.cpp
===================================================================
--- lib/Basic/IdentifierTable.cpp
+++ lib/Basic/IdentifierTable.cpp
@@ -98,43 +98,44 @@
 // Constants for TokenKinds.def
 namespace {
 
-  enum {
-    KEYC99 = 0x1,
-    KEYCXX = 0x2,
-    KEYCXX11 = 0x4,
-    KEYGNU = 0x8,
-    KEYMS = 0x10,
-    BOOLSUPPORT = 0x20,
-    KEYALTIVEC = 0x40,
-    KEYNOCXX = 0x80,
-    KEYBORLAND = 0x100,
-    KEYOPENCLC = 0x200,
-    KEYC11 = 0x400,
-    KEYARC = 0x800,
-    KEYNOMS18 = 0x01000,
-    KEYNOOPENCL = 0x02000,
-    WCHARSUPPORT = 0x04000,
-    HALFSUPPORT = 0x08000,
-    CHAR8SUPPORT = 0x10000,
-    KEYCONCEPTS = 0x20000,
-    KEYOBJC2    = 0x40000,
-    KEYZVECTOR  = 0x80000,
-    KEYCOROUTINES = 0x100000,
-    KEYMODULES = 0x200000,
-    KEYCXX2A = 0x400000,
-    KEYOPENCLCXX = 0x800000,
-    KEYALLCXX = KEYCXX | KEYCXX11 | KEYCXX2A,
-    KEYALL = (0xffffff & ~KEYNOMS18 &
-              ~KEYNOOPENCL) // KEYNOMS18 and KEYNOOPENCL are used to exclude.
-  };
-
-  /// How a keyword is treated in the selected standard.
-  enum KeywordStatus {
-    KS_Disabled,    // Disabled
-    KS_Extension,   // Is an extension
-    KS_Enabled,     // Enabled
-    KS_Future       // Is a keyword in future standard
-  };
+enum {
+  KEYC99 = 0x1,
+  KEYCXX = 0x2,
+  KEYCXX11 = 0x4,
+  KEYGNU = 0x8,
+  KEYMS = 0x10,
+  BOOLSUPPORT = 0x20,
+  KEYALTIVEC = 0x40,
+  KEYNOCXX = 0x80,
+  KEYBORLAND = 0x100,
+  KEYOPENCLC = 0x200,
+  KEYC11 = 0x400,
+  KEYARC = 0x800,
+  KEYNOMS18 = 0x01000,
+  KEYNOOPENCL = 0x02000,
+  WCHARSUPPORT = 0x04000,
+  HALFSUPPORT = 0x08000,
+  CHAR8SUPPORT = 0x10000,
+  KEYCONCEPTS = 0x20000,
+  KEYOBJC2 = 0x40000,
+  KEYZVECTOR = 0x80000,
+  KEYCOROUTINES = 0x100000,
+  KEYMODULES = 0x200000,
+  KEYCXX2A = 0x400000,
+  KEYOPENCLCXX = 0x800000,
+  KEYRESUMABLEFUNCS = 0x1000000,
+  KEYALLCXX = KEYCXX | KEYCXX11 | KEYCXX2A,
+  KEYALL = (0xffffff & ~KEYNOMS18 &
+            ~KEYNOOPENCL) // KEYNOMS18 and KEYNOOPENCL are used to exclude.
+};
+
+/// How a keyword is treated in the selected standard.
+enum KeywordStatus {
+  KS_Disabled,  // Disabled
+  KS_Extension, // Is an extension
+  KS_Enabled,   // Enabled
+  KS_Future     // Is a keyword in future standard
+};
 
 } // namespace
 
@@ -167,6 +168,8 @@
   if (LangOpts.ConceptsTS && (Flags & KEYCONCEPTS)) return KS_Enabled;
   if (LangOpts.CoroutinesTS && (Flags & KEYCOROUTINES)) return KS_Enabled;
   if (LangOpts.ModulesTS && (Flags & KEYMODULES)) return KS_Enabled;
+  if (LangOpts.ResumableFunctions && (Flags & KEYRESUMABLEFUNCS))
+    return KS_Enabled;
   if (LangOpts.CPlusPlus && (Flags & KEYALLCXX)) return KS_Future;
   return KS_Disabled;
 }
Index: lib/Driver/ToolChains/Clang.cpp
===================================================================
--- lib/Driver/ToolChains/Clang.cpp
+++ lib/Driver/ToolChains/Clang.cpp
@@ -4165,6 +4165,9 @@
     CmdArgs.push_back("-fcoroutines-ts");
   }
 
+  if (Args.hasArg(options::OPT_fresumable_functions) && types::isCXX(InputType))
+    CmdArgs.push_back("-fresumable-functions");
+
   Args.AddLastArg(CmdArgs, options::OPT_fdouble_square_bracket_attributes,
                   options::OPT_fno_double_square_bracket_attributes);
 
Index: lib/Frontend/CompilerInvocation.cpp
===================================================================
--- lib/Frontend/CompilerInvocation.cpp
+++ lib/Frontend/CompilerInvocation.cpp
@@ -2363,6 +2363,7 @@
     && Opts.OpenCLVersion == 200);
   Opts.BlocksRuntimeOptional = Args.hasArg(OPT_fblocks_runtime_optional);
   Opts.CoroutinesTS = Args.hasArg(OPT_fcoroutines_ts);
+  Opts.ResumableFunctions = Args.hasArg(OPT_fresumable_functions);
 
   // Enable [[]] attributes in C++11 by default.
   Opts.DoubleSquareBracketAttributes =
Index: lib/Frontend/InitPreprocessor.cpp
===================================================================
--- lib/Frontend/InitPreprocessor.cpp
+++ lib/Frontend/InitPreprocessor.cpp
@@ -560,6 +560,10 @@
   if (LangOpts.CoroutinesTS)
     Builder.defineMacro("__cpp_coroutines", "201703L");
 
+  // C++ Resumable Functions proposal (N4453)
+  if (LangOpts.ResumableFunctions)
+    Builder.defineMacro("__cpp_resumable_functions", "1");
+
   // Potential future breaking changes.
   if (LangOpts.Char8)
     Builder.defineMacro("__cpp_char8_t", "201803");
Index: lib/Parse/ParseDecl.cpp
===================================================================
--- lib/Parse/ParseDecl.cpp
+++ lib/Parse/ParseDecl.cpp
@@ -3515,6 +3515,11 @@
       isInvalid = DS.SetConstexprSpec(Loc, PrevSpec, DiagID);
       break;
 
+    // Resumable functions
+    case tok::kw_resumable:
+      isInvalid = DS.SetResumableSpec(Loc, PrevSpec, DiagID);
+      break;
+
     // type-specifier
     case tok::kw_short:
       isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_short, Loc, PrevSpec,
@@ -4901,6 +4906,9 @@
   case tok::annot_decltype:
   case tok::kw_constexpr:
 
+    // Resumable Functions
+  case tok::kw_resumable:
+
     // C11 _Atomic
   case tok::kw__Atomic:
     return true;
Index: lib/Parse/ParseDeclCXX.cpp
===================================================================
--- lib/Parse/ParseDeclCXX.cpp
+++ lib/Parse/ParseDeclCXX.cpp
@@ -1277,6 +1277,7 @@
   case tok::kw_mutable:         // struct foo {...} mutable   x;
   case tok::kw_thread_local:    // struct foo {...} thread_local x;
   case tok::kw_constexpr:       // struct foo {...} constexpr x;
+  case tok::kw_resumable:       // struct foo {...} resumable x;
     // As shown above, type qualifiers and storage class specifiers absolutely
     // can occur after class specifiers according to the grammar.  However,
     // almost no one actually writes code like this.  If we see one of these,
Index: lib/Parse/ParseStmt.cpp
===================================================================
--- lib/Parse/ParseStmt.cpp
+++ lib/Parse/ParseStmt.cpp
@@ -1875,12 +1875,20 @@
 /// ParseBreakStatement
 ///       jump-statement:
 ///         'break' ';'
+///         'break' 'resumable' ';'
 ///
 /// Note: this lets the caller parse the end ';'.
 ///
 StmtResult Parser::ParseBreakStatement() {
   SourceLocation BreakLoc = ConsumeToken();  // eat the 'break'.
-  return Actions.ActOnBreakStmt(BreakLoc, getCurScope());
+  SourceLocation ResumableLoc;
+  bool IsResumable = false;
+  if (Tok.is(tok::kw_resumable)) {
+    ResumableLoc = ConsumeToken();
+    IsResumable = true;
+  }
+  return Actions.ActOnBreakStmt(BreakLoc, getCurScope(), IsResumable,
+                                ResumableLoc);
 }
 
 /// ParseReturnStatement
Index: lib/Parse/ParseTentative.cpp
===================================================================
--- lib/Parse/ParseTentative.cpp
+++ lib/Parse/ParseTentative.cpp
@@ -1332,6 +1332,9 @@
   case tok::kw_virtual:
   case tok::kw_explicit:
 
+    // Resumable function support
+  case tok::kw_resumable:
+
     // Modules
   case tok::kw___module_private__:
 
Index: lib/Sema/CMakeLists.txt
===================================================================
--- lib/Sema/CMakeLists.txt
+++ lib/Sema/CMakeLists.txt
@@ -45,6 +45,7 @@
   SemaOpenMP.cpp
   SemaOverload.cpp
   SemaPseudoObject.cpp
+  SemaResumable.cpp
   SemaStmt.cpp
   SemaStmtAsm.cpp
   SemaStmtAttr.cpp
Index: lib/Sema/DeclSpec.cpp
===================================================================
--- lib/Sema/DeclSpec.cpp
+++ lib/Sema/DeclSpec.cpp
@@ -975,6 +975,20 @@
   return false;
 }
 
+bool DeclSpec::SetResumableSpec(SourceLocation Loc, const char *&PrevSpec,
+                                unsigned &DiagID) {
+  // 'constexpr constexpr' is ok, but warn as this is likely not what the user
+  // intended.
+  if (Resumable_specified) {
+    DiagID = diag::warn_duplicate_declspec;
+    PrevSpec = "resumable";
+    return true;
+  }
+  Resumable_specified = true;
+  ResumableLoc = Loc;
+  return false;
+}
+
 void DeclSpec::SaveWrittenBuiltinSpecs() {
   writtenBS.Sign = getTypeSpecSign();
   writtenBS.Width = getTypeSpecWidth();
Index: lib/Sema/ScopeInfo.cpp
===================================================================
--- lib/Sema/ScopeInfo.cpp
+++ lib/Sema/ScopeInfo.cpp
@@ -48,6 +48,9 @@
   CoroutineSuspends.first = nullptr;
   CoroutineSuspends.second = nullptr;
 
+  // Resumable function state
+  FirstBreakResumableStmtLoc = SourceLocation();
+
   SwitchStack.clear();
   Returns.clear();
   ErrorTrap.reset();
Index: lib/Sema/SemaCoroutine.cpp
===================================================================
--- lib/Sema/SemaCoroutine.cpp
+++ lib/Sema/SemaCoroutine.cpp
@@ -903,11 +903,31 @@
 void Sema::CheckCompletedCoroutineBody(FunctionDecl *FD, Stmt *&Body) {
   FunctionScopeInfo *Fn = getCurFunction();
   assert(Fn && Fn->isCoroutine() && "not a coroutine");
+
+  // Ensure explicitly resumable functions are not allowed to be coroutines
+  if (FD && FD->isResumableSpecified()) {
+    Diag(FD->getLocation(), diag::err_resumable_func_is_coroutine) << FD;
+    Diag(Fn->FirstCoroutineStmtLoc, diag::note_declared_coroutine_here)
+        << Fn->getFirstCoroutineStmtKeyword();
+    FD->setInvalidDecl(true);
+    return;
+  }
+
   if (!Body) {
     assert(FD->isInvalidDecl() &&
            "a null body is only allowed for invalid declarations");
     return;
   }
+
+  if (!Fn->hasBreakResumableStmt()) {
+    assert(FD && "cannot be null");
+    Diag(FD->getLocation(), diag::err_resumable_func_is_coroutine) << FD;
+    Diag(Fn->FirstCoroutineStmtLoc, diag::note_declared_coroutine_here)
+        << Fn->getFirstCoroutineStmtKeyword();
+    FD->setInvalidDecl(true);
+    return;
+  }
+
   // We have a function that uses coroutine keywords, but we failed to build
   // the promise type.
   if (!Fn->CoroutinePromise)
Index: lib/Sema/SemaDecl.cpp
===================================================================
--- lib/Sema/SemaDecl.cpp
+++ lib/Sema/SemaDecl.cpp
@@ -51,6 +51,13 @@
 using namespace clang;
 using namespace sema;
 
+enum InvalidResumableKind {
+  IRK_ParmVar,
+  IRK_Typedef,
+  IRK_NonStaticMember,
+  IRK_GlobalVar
+};
+
 Sema::DeclGroupPtrTy Sema::ConvertDeclToDeclGroup(Decl *Ptr, Decl *OwnedType) {
   if (OwnedType) {
     Decl *Group[2] = { OwnedType, Ptr };
@@ -4262,6 +4269,18 @@
     return TagD;
   }
 
+  if (DS.isResumableSpecified()) {
+    // resumable can only be applied to declarations
+    // and definitions of functions and variables.
+    if (Tag)
+      Diag(DS.getResumableSpecLoc(), diag::err_resumable_tag)
+          << GetDiagnosticTypeSpecifierID(DS.getTypeSpecType());
+    else
+      Diag(DS.getResumableSpecLoc(), diag::err_resumable_no_declarators);
+    // Don't emit warnings after this error.
+    return TagD;
+  }
+
   DiagnoseFunctionSpecifiers(DS);
 
   if (DS.isFriendSpecified()) {
@@ -5725,6 +5744,9 @@
   if (D.getDeclSpec().isConstexprSpecified())
     Diag(D.getDeclSpec().getConstexprSpecLoc(), diag::err_invalid_constexpr)
       << 1;
+  if (D.getDeclSpec().isResumableSpecified())
+    Diag(D.getDeclSpec().getResumableSpecLoc(), diag::err_invalid_resumable)
+        << IRK_Typedef;
 
   if (D.getName().Kind != UnqualifiedIdKind::IK_Identifier) {
     if (D.getName().Kind == UnqualifiedIdKind::IK_DeductionGuideName)
@@ -6595,6 +6617,16 @@
       if (NewVD->isStaticDataMember() && getLangOpts().CPlusPlus17)
         NewVD->setImplicitlyInline();
     }
+
+    if (D.getDeclSpec().isResumableSpecified()) {
+      NewVD->setResumableSpecified(true);
+      if (D.getDeclSpec().isConstexprSpecified()) {
+        Diag(D.getDeclSpec().getConstexprSpecLoc(),
+             diag::err_resumable_var_decl_constexpr)
+            << NewVD;
+        NewVD->isInvalidDecl();
+      }
+    }
   }
 
   if (D.getDeclSpec().isInlineSpecified()) {
@@ -7297,6 +7329,13 @@
 
   QualType T = NewVD->getType();
 
+  if (NewVD->isResumableSpecified() && !T->getAs<AutoType>()) {
+    Diag(NewVD->getLocation(), diag::err_resumable_var_decl_type)
+        << T << NewVD->getTypeSpecStartLoc();
+    NewVD->setInvalidDecl(true);
+    return;
+  }
+
   // Defer checking an 'auto' type until its initializer is attached.
   if (T->isUndeducedType())
     return;
@@ -7922,6 +7961,7 @@
 
   bool isExplicit = D.getDeclSpec().isExplicitSpecified();
   bool isConstexpr = D.getDeclSpec().isConstexprSpecified();
+  bool isResumable = D.getDeclSpec().isResumableSpecified();
 
   // Check that the return type is not an abstract class type.
   // For record types, this is done by the AbstractClassUsageDiagnoser once
@@ -7973,11 +8013,10 @@
 
       // Create a FunctionDecl to satisfy the function definition parsing
       // code path.
-      return FunctionDecl::Create(SemaRef.Context, DC,
-                                  D.getLocStart(),
-                                  D.getIdentifierLoc(), Name, R, TInfo,
-                                  SC, isInline,
-                                  /*hasPrototype=*/true, isConstexpr);
+      return FunctionDecl::Create(
+          SemaRef.Context, DC, D.getLocStart(), D.getIdentifierLoc(), Name, R,
+          TInfo, SC, isInline,
+          /*hasPrototype=*/true, isConstexpr, isResumable);
     }
 
   } else if (Name.getNameKind() == DeclarationName::CXXConversionFunctionName) {
@@ -7990,9 +8029,9 @@
     SemaRef.CheckConversionDeclarator(D, R, SC);
     IsVirtualOkay = true;
     return CXXConversionDecl::Create(SemaRef.Context, cast<CXXRecordDecl>(DC),
-                                     D.getLocStart(), NameInfo,
-                                     R, TInfo, isInline, isExplicit,
-                                     isConstexpr, SourceLocation());
+                                     D.getLocStart(), NameInfo, R, TInfo,
+                                     isInline, isExplicit, isConstexpr,
+                                     isResumable, SourceLocation());
 
   } else if (Name.getNameKind() == DeclarationName::CXXDeductionGuideName) {
     SemaRef.CheckDeductionGuideDeclarator(D, R, SC);
@@ -8014,11 +8053,9 @@
     }
 
     // This is a C++ method declaration.
-    CXXMethodDecl *Ret = CXXMethodDecl::Create(SemaRef.Context,
-                                               cast<CXXRecordDecl>(DC),
-                                               D.getLocStart(), NameInfo, R,
-                                               TInfo, SC, isInline,
-                                               isConstexpr, SourceLocation());
+    CXXMethodDecl *Ret = CXXMethodDecl::Create(
+        SemaRef.Context, cast<CXXRecordDecl>(DC), D.getLocStart(), NameInfo, R,
+        TInfo, SC, isInline, isConstexpr, isResumable, SourceLocation());
     IsVirtualOkay = !Ret->isStatic();
     return Ret;
   } else {
@@ -8030,10 +8067,9 @@
     // Determine whether the function was written with a
     // prototype. This true when:
     //   - we're in C++ (where every function has a prototype),
-    return FunctionDecl::Create(SemaRef.Context, DC,
-                                D.getLocStart(),
-                                NameInfo, R, TInfo, SC, isInline,
-                                true/*HasPrototype*/, isConstexpr);
+    return FunctionDecl::Create(SemaRef.Context, DC, D.getLocStart(), NameInfo,
+                                R, TInfo, SC, isInline, true /*HasPrototype*/,
+                                isConstexpr, isResumable);
   }
 }
 
@@ -8303,6 +8339,8 @@
     bool isVirtual = D.getDeclSpec().isVirtualSpecified();
     bool isExplicit = D.getDeclSpec().isExplicitSpecified();
     bool isConstexpr = D.getDeclSpec().isConstexprSpecified();
+    bool isResumable = D.getDeclSpec().isResumableSpecified();
+
     isFriend = D.getDeclSpec().isFriendSpecified();
     if (isFriend && !isInline && D.isFunctionDefinition()) {
       // C++ [class.friend]p5
@@ -8514,6 +8552,15 @@
         Diag(D.getDeclSpec().getConstexprSpecLoc(), diag::err_constexpr_dtor);
     }
 
+    if (isResumable) {
+      NewFD->setImplicitlyInline();
+
+      if (isa<CXXConstructorDecl>(NewFD) || isa<CXXDestructorDecl>(NewFD))
+        Diag(D.getDeclSpec().getResumableSpecLoc(),
+             diag::err_resumable_ctor_dtor)
+            << isa<CXXDestructorDecl>(NewFD);
+    }
+
     // If __module_private__ was specified, mark the function accordingly.
     if (D.getDeclSpec().isModulePrivateSpecified()) {
       if (isFunctionTemplateSpecialization) {
@@ -9258,8 +9305,9 @@
     ReturnType = 1,
     ConstexprSpec = 2,
     InlineSpec = 3,
-    StorageClass = 4,
-    Linkage = 5
+    ResumableSpec = 4,
+    StorageClass = 5,
+    Linkage = 6
   };
 
   // For now, disallow all other attributes.  These should be opt-in, but
@@ -9340,6 +9388,10 @@
       return S.Diag(NewFD->getLocation(), diag::err_multiversion_diff)
              << InlineSpec;
 
+    if (OldFD->isResumable() != NewFD->isResumable())
+      return S.Diag(NewFD->getLocation(), diag::err_multiversion_diff)
+             << ResumableSpec;
+
     if (OldFD->getStorageClass() != NewFD->getStorageClass())
       return S.Diag(NewFD->getLocation(), diag::err_multiversion_diff)
              << StorageClass;
@@ -9919,6 +9971,11 @@
       << FixItHint::CreateRemoval(DS.getConstexprSpecLoc());
     FD->setConstexpr(false);
   }
+  if (FD->isResumableSpecified()) {
+    Diag(DS.getResumableSpecLoc(), diag::err_resumable_main)
+        << FixItHint::CreateRemoval(DS.getResumableSpecLoc());
+    FD->setResumableSpecified(false);
+  }
 
   if (getLangOpts().OpenCL) {
     Diag(FD->getLocation(), diag::err_opencl_no_main)
@@ -10618,6 +10675,27 @@
     return;
   }
 
+  bool CorrectTyposEarly =
+      VDecl->getType()->isUndeducedType() || VDecl->isResumableSpecified();
+  if (CorrectTyposEarly) {
+    // Attempt typo correction early so that the type of the init expression can
+    // be deduced based on the chosen correction if the original init contains a
+    // TypoExpr.
+    ExprResult Res = CorrectDelayedTyposInExpr(Init, VDecl);
+    if (!Res.isUsable()) {
+      RealDecl->setInvalidDecl();
+      return;
+    }
+    Init = Res.get();
+  }
+
+  if (VDecl->isResumableSpecified()) {
+    if (CheckResumableVarDecl(VDecl, Init)) {
+      RealDecl->setInvalidDecl();
+      return;
+    }
+  }
+
   // C++11 [decl.spec.auto]p6. Deduce the type which 'auto' stands in for.
   if (VDecl->getType()->isUndeducedType()) {
     // Attempt typo correction early so that the type of the init expression can
@@ -10630,6 +10708,8 @@
     }
     Init = Res.get();
 
+    // FIXME(EricWF): Correctly deduce the resumable object type if we have a
+    // resumable expression.
     if (DeduceVariableDeclarationType(VDecl, DirectInit, Init))
       return;
   }
@@ -10894,8 +10974,9 @@
     // type. We separately check that every constexpr variable is of literal
     // type.
     } else if (VDecl->isConstexpr()) {
+      // FIXME(EricWF): Do something here
 
-    // Require constness.
+      // Require constness.
     } else if (!DclT.isConstQualified()) {
       Diag(VDecl->getLocation(), diag::err_in_class_initializer_non_const)
         << Init->getSourceRange();
@@ -11065,6 +11146,13 @@
       return;
     }
 
+    if (Var->isResumableSpecified()) {
+      Diag(Var->getLocation(), diag::err_resumable_var_decl_requires_init)
+          << Var;
+      Var->setInvalidDecl();
+      return;
+    }
+
     if (Type->isUndeducedType() &&
         DeduceVariableDeclarationType(Var, false, nullptr))
       return;
@@ -11965,6 +12053,8 @@
   if (DS.isConstexprSpecified())
     Diag(DS.getConstexprSpecLoc(), diag::err_invalid_constexpr)
       << 0;
+  if (DS.isResumableSpecified())
+    Diag(DS.getResumableSpecLoc(), diag::err_invalid_resumable) << IRK_ParmVar;
 
   DiagnoseFunctionSpecifiers(DS);
 
@@ -12889,6 +12979,12 @@
          !CheckConstexprFunctionBody(FD, Body)))
       FD->setInvalidDecl();
 
+    if (!IsInstantiation && FD && FD->isResumable() && !FD->isInvalidDecl() &&
+        !CheckResumableFunctionDecl(FD))
+      FD->setInvalidDecl();
+    if (FD && FD->isResumable() && !FD->isInvalidDecl())
+      CheckCompletedResumableFunctionBody(FD, Body);
+
     if (FD && FD->hasAttr<NakedAttr>()) {
       for (const Stmt *S : Body->children()) {
         // Allow local register variables without initializer as they don't
Index: lib/Sema/SemaDeclCXX.cpp
===================================================================
--- lib/Sema/SemaDeclCXX.cpp
+++ lib/Sema/SemaDeclCXX.cpp
@@ -45,6 +45,7 @@
 #include <set>
 
 using namespace clang;
+using namespace clang::sema;
 
 //===----------------------------------------------------------------------===//
 // CheckDefaultArgumentVisitor
@@ -644,6 +645,11 @@
       << New << New->isConstexpr();
     Diag(Old->getLocation(), diag::note_previous_declaration);
     Invalid = true;
+  } else if (New->isResumable() != Old->isResumable()) {
+    Diag(New->getLocation(), diag::err_resumable_redecl_mismatch)
+        << New << New->isResumable();
+    Diag(Old->getLocation(), diag::note_previous_declaration);
+    Invalid = true;
   } else if (!Old->getMostRecentDecl()->isInlined() && New->isInlined() &&
              Old->isDefined(Def) &&
              // If a friend function is inlined but does not have 'inline'
@@ -11681,10 +11687,10 @@
   DeclarationName Name = Context.DeclarationNames.getCXXOperatorName(OO_Equal);
   SourceLocation ClassLoc = ClassDecl->getLocation();
   DeclarationNameInfo NameInfo(Name, ClassLoc);
-  CXXMethodDecl *CopyAssignment =
-      CXXMethodDecl::Create(Context, ClassDecl, ClassLoc, NameInfo, QualType(),
-                            /*TInfo=*/nullptr, /*StorageClass=*/SC_None,
-                            /*isInline=*/true, Constexpr, SourceLocation());
+  CXXMethodDecl *CopyAssignment = CXXMethodDecl::Create(
+      Context, ClassDecl, ClassLoc, NameInfo, QualType(),
+      /*TInfo=*/nullptr, /*StorageClass=*/SC_None,
+      /*isInline=*/true, Constexpr, /*isResumable=*/false, SourceLocation());
   CopyAssignment->setAccess(AS_public);
   CopyAssignment->setDefaulted();
   CopyAssignment->setImplicit();
@@ -12002,10 +12008,10 @@
   DeclarationName Name = Context.DeclarationNames.getCXXOperatorName(OO_Equal);
   SourceLocation ClassLoc = ClassDecl->getLocation();
   DeclarationNameInfo NameInfo(Name, ClassLoc);
-  CXXMethodDecl *MoveAssignment =
-      CXXMethodDecl::Create(Context, ClassDecl, ClassLoc, NameInfo, QualType(),
-                            /*TInfo=*/nullptr, /*StorageClass=*/SC_None,
-                            /*isInline=*/true, Constexpr, SourceLocation());
+  CXXMethodDecl *MoveAssignment = CXXMethodDecl::Create(
+      Context, ClassDecl, ClassLoc, NameInfo, QualType(),
+      /*TInfo=*/nullptr, /*StorageClass=*/SC_None,
+      /*isInline=*/true, Constexpr, /*isResumable=*/false, SourceLocation());
   MoveAssignment->setAccess(AS_public);
   MoveAssignment->setDefaulted();
   MoveAssignment->setImplicit();
Index: lib/Sema/SemaExpr.cpp
===================================================================
--- lib/Sema/SemaExpr.cpp
+++ lib/Sema/SemaExpr.cpp
@@ -5432,6 +5432,9 @@
     return ExprError();
   }
 
+  if (FDecl && FDecl->isResumable())
+    SetCurFunctionImplicitlyResumable(Fn->getExprLoc());
+
   // Interrupt handlers don't save off the VFP regs automatically on ARM,
   // so there's some risk when calling out to non-interrupt handler functions
   // that the callee might not preserve them. This is easy to diagnose here,
Index: lib/Sema/SemaExprCXX.cpp
===================================================================
--- lib/Sema/SemaExprCXX.cpp
+++ lib/Sema/SemaExprCXX.cpp
@@ -7685,9 +7685,9 @@
 }
 
 ExprResult Sema::ActOnFinishFullExpr(Expr *FE, SourceLocation CC,
-                                     bool DiscardedValue,
-                                     bool IsConstexpr,
-                                     bool IsLambdaInitCaptureInitializer) {
+                                     bool DiscardedValue, bool IsConstexpr,
+                                     bool IsLambdaInitCaptureInitializer,
+                                     bool IsResumable) {
   ExprResult FullExpr = FE;
 
   if (!FullExpr.get())
Index: lib/Sema/SemaLambda.cpp
===================================================================
--- lib/Sema/SemaLambda.cpp
+++ lib/Sema/SemaLambda.cpp
@@ -406,16 +406,13 @@
     = IntroducerRange.getBegin().getRawEncoding();
   MethodNameLoc.CXXOperatorName.EndOpNameLoc
     = IntroducerRange.getEnd().getRawEncoding();
-  CXXMethodDecl *Method
-    = CXXMethodDecl::Create(Context, Class, EndLoc,
-                            DeclarationNameInfo(MethodName, 
-                                                IntroducerRange.getBegin(),
-                                                MethodNameLoc),
-                            MethodType, MethodTypeInfo,
-                            SC_None,
-                            /*isInline=*/true,
-                            IsConstexprSpecified,
-                            EndLoc);
+  CXXMethodDecl *Method = CXXMethodDecl::Create(
+      Context, Class, EndLoc,
+      DeclarationNameInfo(MethodName, IntroducerRange.getBegin(),
+                          MethodNameLoc),
+      MethodType, MethodTypeInfo, SC_None,
+      /*isInline=*/true, IsConstexprSpecified,
+      /*isResumable=*/false, EndLoc);
   Method->setAccess(AS_public);
   
   // Temporarily set the lexical declaration context to the current
@@ -1287,15 +1284,12 @@
     CallOpConvNameTL.setParam(I, From);
   }
 
-  CXXConversionDecl *Conversion 
-    = CXXConversionDecl::Create(S.Context, Class, Loc, 
-                                DeclarationNameInfo(ConversionName, 
-                                  Loc, ConvNameLoc),
-                                ConvTy, 
-                                ConvTSI,
-                                /*isInline=*/true, /*isExplicit=*/false,
-                                /*isConstexpr=*/S.getLangOpts().CPlusPlus17, 
-                                CallOperator->getBody()->getLocEnd());
+  CXXConversionDecl *Conversion = CXXConversionDecl::Create(
+      S.Context, Class, Loc,
+      DeclarationNameInfo(ConversionName, Loc, ConvNameLoc), ConvTy, ConvTSI,
+      /*isInline=*/true, /*isExplicit=*/false,
+      /*isConstexpr=*/S.getLangOpts().CPlusPlus17,
+      /*IsResumable=*/false, CallOperator->getBody()->getLocEnd());
   Conversion->setAccess(AS_public);
   Conversion->setImplicit(true);
 
@@ -1330,14 +1324,12 @@
   // trailing return type of the invoker would require a visitor to rebuild
   // the trailing return type and adjusting all back DeclRefExpr's to refer
   // to the new static invoker parameters - not the call operator's.
-  CXXMethodDecl *Invoke
-    = CXXMethodDecl::Create(S.Context, Class, Loc, 
-                            DeclarationNameInfo(InvokerName, Loc), 
-                            InvokerFunctionTy,
-                            CallOperator->getTypeSourceInfo(), 
-                            SC_Static, /*IsInline=*/true,
-                            /*IsConstexpr=*/false, 
-                            CallOperator->getBody()->getLocEnd());
+  CXXMethodDecl *Invoke = CXXMethodDecl::Create(
+      S.Context, Class, Loc, DeclarationNameInfo(InvokerName, Loc),
+      InvokerFunctionTy, CallOperator->getTypeSourceInfo(), SC_Static,
+      /*IsInline=*/true,
+      /*IsConstexpr=*/false, /*IsResumable*/ false,
+      CallOperator->getBody()->getLocEnd());
   for (unsigned I = 0, N = CallOperator->getNumParams(); I != N; ++I)
     InvokerParams[I]->setOwningFunction(Invoke);
   Invoke->setParams(InvokerParams);
@@ -1379,14 +1371,12 @@
         S.Context.getCanonicalType(BlockPtrTy));
   DeclarationNameLoc NameLoc;
   NameLoc.NamedType.TInfo = S.Context.getTrivialTypeSourceInfo(BlockPtrTy, Loc);
-  CXXConversionDecl *Conversion 
-    = CXXConversionDecl::Create(S.Context, Class, Loc, 
-                                DeclarationNameInfo(Name, Loc, NameLoc),
-                                ConvTy, 
-                                S.Context.getTrivialTypeSourceInfo(ConvTy, Loc),
-                                /*isInline=*/true, /*isExplicit=*/false,
-                                /*isConstexpr=*/false, 
-                                CallOperator->getBody()->getLocEnd());
+  CXXConversionDecl *Conversion = CXXConversionDecl::Create(
+      S.Context, Class, Loc, DeclarationNameInfo(Name, Loc, NameLoc), ConvTy,
+      S.Context.getTrivialTypeSourceInfo(ConvTy, Loc),
+      /*isInline=*/true, /*isExplicit=*/false,
+      /*isConstexpr=*/false, /*isResumable*/ false,
+      CallOperator->getBody()->getLocEnd());
   Conversion->setAccess(AS_public);
   Conversion->setImplicit(true);
   Class->addDecl(Conversion);
Index: lib/Sema/SemaOverload.cpp
===================================================================
--- lib/Sema/SemaOverload.cpp
+++ lib/Sema/SemaOverload.cpp
@@ -11,7 +11,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "clang/Sema/Overload.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/CXXInheritance.h"
 #include "clang/AST/DeclObjC.h"
@@ -25,6 +24,8 @@
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Sema/Initialization.h"
 #include "clang/Sema/Lookup.h"
+#include "clang/Sema/Overload.h"
+#include "clang/Sema/ScopeInfo.h"
 #include "clang/Sema/SemaInternal.h"
 #include "clang/Sema/Template.h"
 #include "clang/Sema/TemplateDeduction.h"
@@ -9445,6 +9446,16 @@
     return false;
   }
 
+  if (FD->isResumable()) {
+    if (Complain) {
+      if (InOverloadResolution)
+        S.Diag(FD->getLocStart(), diag::note_addrof_ovl_candidate_resumable_fn);
+      else
+        S.Diag(Loc, diag::err_addrof_resumable_fn) << FD;
+    }
+    return false;
+  }
+
   auto I = llvm::find_if(FD->parameters(), [](const ParmVarDecl *P) {
     return P->hasAttr<PassObjectSizeAttr>();
   });
@@ -12907,6 +12918,9 @@
   ExprValueKind VK = Expr::getValueKindForType(ResultType);
   ResultType = ResultType.getNonLValueExprType(Context);
 
+  if (Method->isResumable())
+    SetCurFunctionImplicitlyResumable(LParenLoc);
+
   assert(Method && "Member call to something that isn't a method?");
   CXXMemberCallExpr *TheCall =
     new (Context) CXXMemberCallExpr(Context, MemExprE, Args,
@@ -13264,6 +13278,9 @@
 
   if (IsError) return true;
 
+  if (Method->isResumable())
+    SetCurFunctionImplicitlyResumable(LParenLoc);
+
   DiagnoseSentinelCalls(Method, LParenLoc, Args);
 
   if (CheckFunctionCall(Method, TheCall, Proto))
Index: lib/Sema/SemaResumable.cpp
===================================================================
--- /dev/null
+++ lib/Sema/SemaResumable.cpp
@@ -0,0 +1,114 @@
+//===--- SemaResumable.cpp - Semantic Analysis for Resumable Functions ----===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+//  This file implements semantic analysis for C++ Resumable Functions
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang/AST/ASTLambda.h"
+#include "clang/AST/Decl.h"
+#include "clang/AST/ExprCXX.h"
+#include "clang/AST/StmtCXX.h"
+#include "clang/Lex/Preprocessor.h"
+#include "clang/Sema/Initialization.h"
+#include "clang/Sema/Overload.h"
+#include "clang/Sema/ScopeInfo.h"
+#include "clang/Sema/Sema.h"
+#include "clang/Sema/SemaInternal.h"
+
+using namespace clang;
+using namespace sema;
+
+void Sema::CheckCompletedResumableFunctionBody(FunctionDecl *FD, Stmt *Body) {
+  if (!Body) {
+    assert(FD && FD->isInvalidDecl() && "No body for valid decl?");
+    return;
+  }
+  assert(FD && FD->isResumable() &&
+         "No function decl or non-resumable function decl?");
+  // FIXME(EricWF): Do something with this
+}
+
+void Sema::SetCurFunctionImplicitlyResumable(SourceLocation Loc,
+                                             bool IsBreakResumable) {
+  // Record the location of the resumable function call.
+  if (FunctionScopeInfo *FnScope = getCurFunction()) {
+    if (IsBreakResumable)
+      FnScope->setFirstBreakResumableStmt(Loc);
+    else
+      FnScope->setFirstResumableStmt(Loc);
+  }
+
+  // Find the callee, and mark that callee as implicitly resumable.
+  if (FunctionDecl *FD = getCurFunctionDecl()) {
+    // FIXME(EricWF): Diagnose cases where the function we're marking implicitly
+    // resumable isn't inline.
+    if (!FD->isResumableSpecified())
+      FD->setImplicitlyResumable(true);
+  } else if (LambdaScopeInfo *Lam = getCurLambda()) {
+    if (CXXMethodDecl *MD = Lam->CallOperator)
+      MD->setImplicitlyResumable(true);
+    else
+      llvm_unreachable("lambda does not yet have body?");
+  } else {
+    // Nothing to do. We should be at the global scope.
+  }
+}
+
+bool Sema::CheckResumableFunctionDecl(const FunctionDecl *FD) {
+  assert(FD->isResumable() && "Checking non-resumable function");
+  if (const auto *Method = dyn_cast<CXXMethodDecl>(FD)) {
+    if (Method->isVirtual()) {
+      Method = Method->getCanonicalDecl();
+      Diag(Method->getLocation(), diag::err_resumable_virtual);
+
+      // If it's not obvious why this function is virtual, find an overridden
+      // function which uses the 'virtual' keyword.
+      const CXXMethodDecl *WrittenVirtual = Method;
+      while (!WrittenVirtual->isVirtualAsWritten())
+        WrittenVirtual = *WrittenVirtual->begin_overridden_methods();
+      if (WrittenVirtual != Method)
+        Diag(WrittenVirtual->getLocation(),
+             diag::note_overridden_virtual_function);
+      return false;
+    }
+  }
+
+  return true;
+}
+
+bool Sema::CheckResumableVarDecl(VarDecl *VD, Expr *Init) {
+  assert(VD && Init && "cannot be null");
+  if (auto *CE = dyn_cast<CallExpr>(Init)) {
+    Decl *Callee = CE->getCalleeDecl();
+    assert(Callee && "No callee for function call?");
+    if (auto *FD = dyn_cast<FunctionDecl>(Callee)) {
+      if (!FD->isResumable()) {
+        Diag(Init->getExprLoc(),
+             diag::err_resumable_var_decl_init_not_resumable_expr)
+            << VD << Init->getSourceRange();
+        Diag(FD->getLocation(), diag::note_function_declared_here);
+        return true;
+      }
+    } else {
+      // FIXME(EricWF): Handle these cases.
+      llvm::errs() << "Unhandled Resumable var decl init case\n";
+      Callee->dumpColor();
+      assert(false);
+    }
+  } else {
+    // FIXME(EricWF): Handle these cases.
+    llvm::errs() << "Unhandled Resumable var decl init case\n";
+    Init->dumpColor();
+    Diag(Init->getExprLoc(), diag::err_resumable_var_decl_init_not_call_expr)
+        << VD << Init->getSourceRange();
+    return true;
+  }
+  return false;
+}
Index: lib/Sema/SemaStmt.cpp
===================================================================
--- lib/Sema/SemaStmt.cpp
+++ lib/Sema/SemaStmt.cpp
@@ -2836,19 +2836,26 @@
   return new (Context) ContinueStmt(ContinueLoc);
 }
 
-StmtResult
-Sema::ActOnBreakStmt(SourceLocation BreakLoc, Scope *CurScope) {
-  Scope *S = CurScope->getBreakParent();
-  if (!S) {
+StmtResult Sema::ActOnBreakStmt(SourceLocation BreakLoc, Scope *CurScope,
+                                bool IsResumable, SourceLocation ResumableLoc) {
+  Scope *BreakScope = CurScope->getBreakParent();
+  if (!BreakScope && !IsResumable) {
     // C99 6.8.6.3p1: A break shall appear only in or as a switch/loop body.
     return StmtError(Diag(BreakLoc, diag::err_break_not_in_loop_or_switch));
   }
-  if (S->isOpenMPLoopScope())
+
+  if (IsResumable)
+    SetCurFunctionImplicitlyResumable(ResumableLoc, /*IsBreakResumable*/ true);
+
+  if (BreakScope && BreakScope->isOpenMPLoopScope())
     return StmtError(Diag(BreakLoc, diag::err_omp_loop_cannot_use_stmt)
                      << "break");
-  CheckJumpOutOfSEHFinally(*this, BreakLoc, *S);
 
-  return new (Context) BreakStmt(BreakLoc);
+  // FIXME(EricWF): Is this the correct scope to check?
+  CheckJumpOutOfSEHFinally(*this, BreakLoc,
+                           *(BreakScope ? BreakScope : CurScope));
+
+  return new (Context) BreakStmt(BreakLoc, IsResumable, ResumableLoc);
 }
 
 /// Determine whether the given expression is a candidate for
Index: lib/Sema/SemaTemplateInstantiateDecl.cpp
===================================================================
--- lib/Sema/SemaTemplateInstantiateDecl.cpp
+++ lib/Sema/SemaTemplateInstantiateDecl.cpp
@@ -1954,18 +1954,17 @@
                                        false);
     Method->setRangeEnd(Destructor->getLocEnd());
   } else if (CXXConversionDecl *Conversion = dyn_cast<CXXConversionDecl>(D)) {
-    Method = CXXConversionDecl::Create(SemaRef.Context, Record,
-                                       StartLoc, NameInfo, T, TInfo,
-                                       Conversion->isInlineSpecified(),
-                                       Conversion->isExplicit(),
-                                       Conversion->isConstexpr(),
-                                       Conversion->getLocEnd());
+    Method = CXXConversionDecl::Create(
+        SemaRef.Context, Record, StartLoc, NameInfo, T, TInfo,
+        Conversion->isInlineSpecified(), Conversion->isExplicit(),
+        Conversion->isConstexpr(), Conversion->isResumable(),
+        Conversion->getLocEnd());
   } else {
     StorageClass SC = D->isStatic() ? SC_Static : SC_None;
-    Method = CXXMethodDecl::Create(SemaRef.Context, Record,
-                                   StartLoc, NameInfo, T, TInfo,
-                                   SC, D->isInlineSpecified(),
-                                   D->isConstexpr(), D->getLocEnd());
+    Method = CXXMethodDecl::Create(SemaRef.Context, Record, StartLoc, NameInfo,
+                                   T, TInfo, SC, D->isInlineSpecified(),
+                                   D->isConstexpr(), D->isResumable(),
+                                   D->getLocEnd());
   }
 
   if (D->isInlined())
Index: lib/Serialization/ASTReaderDecl.cpp
===================================================================
--- lib/Serialization/ASTReaderDecl.cpp
+++ lib/Serialization/ASTReaderDecl.cpp
@@ -842,6 +842,8 @@
   FD->IsExplicitlyDefaulted = Record.readInt();
   FD->HasImplicitReturnZero = Record.readInt();
   FD->IsConstexpr = Record.readInt();
+  FD->IsResumableSpecified = Record.readInt();
+  FD->IsImplicitlyResumable = Record.readInt();
   FD->UsesSEHTry = Record.readInt();
   FD->HasSkippedBody = Record.readInt();
   FD->IsMultiVersion = Record.readInt();
@@ -1333,6 +1335,7 @@
     VD->NonParmVarDeclBits.IsInline = Record.readInt();
     VD->NonParmVarDeclBits.IsInlineSpecified = Record.readInt();
     VD->NonParmVarDeclBits.IsConstexpr = Record.readInt();
+    VD->NonParmVarDeclBits.IsResumable = Record.readInt();
     VD->NonParmVarDeclBits.IsInitCapture = Record.readInt();
     VD->NonParmVarDeclBits.PreviousDeclInSameBlockScope = Record.readInt();
     VD->NonParmVarDeclBits.ImplicitParamKind = Record.readInt();
Index: lib/Serialization/ASTReaderStmt.cpp
===================================================================
--- lib/Serialization/ASTReaderStmt.cpp
+++ lib/Serialization/ASTReaderStmt.cpp
@@ -296,6 +296,9 @@
 void ASTStmtReader::VisitBreakStmt(BreakStmt *S) {
   VisitStmt(S);
   S->setBreakLoc(ReadSourceLocation());
+  S->setResumableLoc(ReadSourceLocation());
+  if (Record.readInt())
+    S->setResumableSpecified();
 }
 
 void ASTStmtReader::VisitReturnStmt(ReturnStmt *S) {
Index: lib/Serialization/ASTWriterDecl.cpp
===================================================================
--- lib/Serialization/ASTWriterDecl.cpp
+++ lib/Serialization/ASTWriterDecl.cpp
@@ -539,6 +539,8 @@
   Record.push_back(D->IsExplicitlyDefaulted);
   Record.push_back(D->HasImplicitReturnZero);
   Record.push_back(D->IsConstexpr);
+  Record.push_back(D->IsResumableSpecified);
+  Record.push_back(D->IsImplicitlyResumable);
   Record.push_back(D->UsesSEHTry);
   Record.push_back(D->HasSkippedBody);
   Record.push_back(D->IsMultiVersion);
@@ -925,6 +927,7 @@
     Record.push_back(D->isInline());
     Record.push_back(D->isInlineSpecified());
     Record.push_back(D->isConstexpr());
+    Record.push_back(D->isResumableSpecified());
     Record.push_back(D->isInitCapture());
     Record.push_back(D->isPreviousDeclInSameBlockScope());
     if (const auto *IPD = dyn_cast<ImplicitParamDecl>(D))
Index: lib/Serialization/ASTWriterStmt.cpp
===================================================================
--- lib/Serialization/ASTWriterStmt.cpp
+++ lib/Serialization/ASTWriterStmt.cpp
@@ -210,6 +210,8 @@
 void ASTStmtWriter::VisitBreakStmt(BreakStmt *S) {
   VisitStmt(S);
   Record.AddSourceLocation(S->getBreakLoc());
+  Record.AddSourceLocation(S->getResumableLoc());
+  Record.push_back(S->isResumableSpecified());
   Code = serialization::STMT_BREAK;
 }
 
Index: test/Parser/resumable-decl.cpp
===================================================================
--- /dev/null
+++ test/Parser/resumable-decl.cpp
@@ -0,0 +1,11 @@
+// RUN: %clang_cc1 -verify -fsyntax-only -std=c++11 -pedantic-errors \
+// RUN:   -triple x86_64-linux-gnu -fresumable-functions %s
+
+resumable int t1(); // OK
+
+// expected-error@+1 {{'main' is not allowed to be declared resumable}}
+resumable int main() {}
+
+void t2() {
+  break resumable;
+}
Index: test/SemaCXX/resumable-functions.cpp
===================================================================
--- /dev/null
+++ test/SemaCXX/resumable-functions.cpp
@@ -0,0 +1,116 @@
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify -fresumable-functions %s
+
+struct TestVirtual {
+  virtual resumable void foo();
+  resumable void bar(); // OK
+};
+
+namespace TestBreakResumableScope {
+
+void break_resumable() {
+  break resumable; // OK
+}
+
+} // end namespace TestBreakResumableScope
+
+namespace TestRedecl {
+
+resumable void p1(); // expected-note {{previous declaration is here}}
+void p1();           // expected-error {{non-resumable declaration of 'p1' follows resumable declaration}}
+
+void p2();           // expected-note {{previous declaration is here}}
+resumable void p2(); // expected-error {{resumable declaration of 'p2' follows non-resumable declaration}}
+
+} // end namespace TestRedecl
+
+struct TestDtorCtor {
+  // FIXME(EricWF): Should constructors be resumable?
+  resumable TestDtorCtor();  // expected-error{{constructor cannot be marked resumable}}
+  resumable ~TestDtorCtor(); // expected-error{{destructor cannot be marked resumable}}
+};
+
+namespace TestTagDecl {
+
+resumable class C1 {};  // expected-error {{class cannot be marked resumable}}
+resumable struct S1 {}; // expected-error {{struct cannot be marked resumable}}
+resumable union U1 {};  // expected-error {{union cannot be marked resumable}}
+resumable enum E1 {};   // expected-error {{enum cannot be marked resumable}}
+template <typename T>
+resumable class TC1 {}; // expected-error {{class cannot be marked resumable}}
+template <typename T>
+resumable struct TS1 {}; // expected-error {{struct cannot be marked resumable}}
+template <typename T>
+resumable union TU1 {}; // expected-error {{union cannot be marked resumable}}
+class C2 {
+} resumable; // expected-error {{class cannot be marked resumable}}
+struct S2 {
+} resumable; // expected-error {{struct cannot be marked resumable}}
+union U2 {
+} resumable;          // expected-error {{union cannot be marked resumable}}
+enum E2 {} resumable; // expected-error {{enum cannot be marked resumable}}
+
+resumable int; // expected-error {{resumable can only be used in variable and function declarations}}
+
+} // end namespace TestTagDecl
+
+namespace TestResumableVarDecl {
+int foo(); // expected-note {{function declared here}}
+resumable int bar();
+
+// expected-error@+1 {{initializer for resumable variable declaration 'x' calls a non-resumable function}}
+resumable auto x = foo();
+resumable auto y = bar(); // OK
+
+int implicitly_resumable() {
+  return bar();
+}
+resumable auto z = implicitly_resumable();
+
+int foo() {
+  // expected-error@+1 {{resumable variable declaration 'x' requires an initializer}}
+  resumable auto x;
+}
+
+} // namespace TestResumableVarDecl
+
+namespace TestAddrOfResumable {
+
+resumable void foo();
+void bar() { foo(); }
+void baz() { break resumable; }
+
+auto x = &foo; // expected-error {{cannot take address of resumable function 'foo'}}
+auto y = &bar; // expected-error {{cannot take address of resumable function 'bar'}}
+auto z = &baz; // expected-error {{cannot take address of resumable function 'baz'}}
+
+} // namespace TestAddrOfResumable
+
+namespace TestImplicitlyResumable {
+
+struct Class {
+  resumable int foo();
+  int bar() {
+    break resumable;
+    return 1;
+  }
+  int baz() { return bar(); }
+
+  int operator()() { return baz(); }
+  int operator()(int x) { return x; } // expected-note {{declared here}}
+};
+
+int foo() { return Class{}.foo(); }
+
+auto lam = []() { break resumable; return 42; };
+auto lam2 = []() { return 42; }; // expected-note {{function declared here}}
+
+resumable auto t1 = Class{}.foo();
+resumable auto t2 = Class{}.bar();
+resumable auto t3 = Class{}.baz();
+resumable auto t4 = foo();
+resumable auto t5 = Class{}();
+resumable auto t6 = Class{}(42); // expected-error {{initializer for resumable variable declaration 't6' calls a non-resumable function}}
+resumable auto t7 = lam();
+resumable auto t8 = lam2(); // expected-error {{initializer for resumable variable declaration 't8' calls a non-resumable function}}
+
+} // namespace TestImplicitlyResumable