diff --git a/src/reader/spirv/function.cc b/src/reader/spirv/function.cc
index 50c947a..d6a25bd 100644
--- a/src/reader/spirv/function.cc
+++ b/src/reader/spirv/function.cc
@@ -1556,7 +1556,9 @@
     auto outer_kind = entering_constructs[1]->kind;
     if (outer_kind != Construct::kContinue) {
       return Fail() << "internal error: bad construct nesting. Only Continue "
-                       "construct can be outer construct on same block";
+                       "construct can be outer construct on same block.  Got "
+                       "outer kind "
+                    << int(outer_kind) << " inner kind " << int(inner_kind);
     }
     if (inner_kind == Construct::kContinue) {
       return Fail() << "internal error: unsupported construct nesting: "
@@ -1588,10 +1590,28 @@
         return Fail() << "internal error: nested function construct";
 
       case Construct::kLoop:
-        return Fail() << "unhandled: loop construct";
+        if (!EmitLoopStart(construct)) {
+          return false;
+        }
+        if (!EmitStatementsInBasicBlock(block_info, &emitted)) {
+          return false;
+        }
+        break;
 
       case Construct::kContinue:
-        return Fail() << "unhandled: continue construct";
+        if (block_info.is_single_block_loop) {
+          if (!EmitLoopStart(construct)) {
+            return false;
+          }
+          if (!EmitStatementsInBasicBlock(block_info, &emitted)) {
+            return false;
+          }
+        } else {
+          if (!EmitContinuingStart(construct)) {
+            return false;
+          }
+        }
+        break;
 
       case Construct::kIfSelection:
         if (!EmitStatementsInBasicBlock(block_info, &emitted)) {
@@ -1709,6 +1729,30 @@
   return success();
 }
 
+bool FunctionEmitter::EmitLoopStart(const Construct* construct) {
+  auto* loop = AddStatement(std::make_unique<ast::LoopStatement>())->AsLoop();
+  PushNewStatementBlock(
+      construct, construct->end_id,
+      [loop](StatementBlock* s) { loop->set_body(std::move(s->statements)); });
+  return success();
+}
+
+bool FunctionEmitter::EmitContinuingStart(const Construct* construct) {
+  // A continue construct has the same depth as its associated loop
+  // construct. Start a continue construct.
+  auto* loop_candidate = LastStatement();
+  if (!loop_candidate->IsLoop()) {
+    return Fail() << "internal error: starting continue construct, "
+                     "expected loop on top of stack";
+  }
+  auto* loop = loop_candidate->AsLoop();
+  PushNewStatementBlock(construct, construct->end_id,
+                        [loop](StatementBlock* s) {
+                          loop->set_continuing(std::move(s->statements));
+                        });
+  return success();
+}
+
 bool FunctionEmitter::EmitNormalTerminator(const BlockInfo&) {
   // TODO(dneto): emit fallthrough, break, continue, return, kill
   return true;
diff --git a/src/reader/spirv/function.h b/src/reader/spirv/function.h
index a7fec4c..f53dbef 100644
--- a/src/reader/spirv/function.h
+++ b/src/reader/spirv/function.h
@@ -297,6 +297,20 @@
   /// @returns false if emission failed.
   bool EmitIfStart(const BlockInfo& block_info);
 
+  /// Emits a LoopStatement, and pushes a new StatementBlock to accumulate
+  /// the remaining instructions in the current block and subsequent blocks
+  /// in the loop.
+  /// @param construct the loop construct
+  /// @returns false if emission failed.
+  bool EmitLoopStart(const Construct* construct);
+
+  /// Emits a ContinuingStatement, and pushes a new StatementBlock to accumulate
+  /// the remaining instructions in the current block and subsequent blocks
+  /// in the continue construct.
+  /// @param construct the continue construct
+  /// @returns false if emission failed.
+  bool EmitContinuingStart(const Construct* construct);
+
   /// Emits the non-control-flow parts of a basic block, but only once.
   /// The |already_emitted| parameter indicates whether the code has already
   /// been emitted, and is used to signal that this invocation actually emitted
diff --git a/src/reader/spirv/function_cfg_test.cc b/src/reader/spirv/function_cfg_test.cc
index e10b3b0..1460556 100644
--- a/src/reader/spirv/function_cfg_test.cc
+++ b/src/reader/spirv/function_cfg_test.cc
@@ -7226,6 +7226,406 @@
 )"));
 }
 
+TEST_F(SpvParserTest, EmitBody_Loop_SingleBlock_TrueBackedge) {
+  // TODO(dneto): emit conditional break
+  auto* p = parser(test::Assemble(CommonTypes() + R"(
+     %100 = OpFunction %void None %voidfn
+
+     %10 = OpLabel
+     OpStore %var %uint_0
+     OpBranch %20
+
+     %20 = OpLabel
+     OpStore %var %uint_1
+     OpLoopMerge %99 %20 None
+     OpBranchConditional %cond %20 %99
+
+     %99 = OpLabel
+     OpStore %var %999
+     OpReturn
+
+     OpFunctionEnd
+  )"));
+  ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
+  FunctionEmitter fe(p, *spirv_function(100));
+  EXPECT_TRUE(fe.EmitBody()) << p->error();
+
+  EXPECT_THAT(ToString(fe.ast_body()), Eq(R"(Assignment{
+  Identifier{var}
+  ScalarConstructor{0}
+}
+Loop{
+  Assignment{
+    Identifier{var}
+    ScalarConstructor{1}
+  }
+}
+Assignment{
+  Identifier{var}
+  ScalarConstructor{999}
+}
+)"));
+}
+
+TEST_F(SpvParserTest, DISABLED_EmitBody_Loop_SingleBlock_FalseBackedge) {
+  // TODO(dneto): emit conditional break
+  auto* p = parser(test::Assemble(CommonTypes() + R"(
+     %100 = OpFunction %void None %voidfn
+
+     %10 = OpLabel
+     OpStore %var %uint_0
+     OpBranch %20
+
+     %20 = OpLabel
+     OpStore %var %uint_1
+     OpLoopMerge %99 %20 None
+     OpBranchConditional %cond %99 %20
+
+     %99 = OpLabel
+     OpStore %var %999
+     OpReturn
+
+     OpFunctionEnd
+  )"));
+  ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
+  FunctionEmitter fe(p, *spirv_function(100));
+  EXPECT_TRUE(fe.EmitBody()) << p->error();
+
+  EXPECT_THAT(ToString(fe.ast_body()), Eq(R"(Assignment{
+  Identifier{var}
+  ScalarConstructor{0}
+}
+Loop{
+  Assignment{
+    Identifier{var}
+    ScalarConstructor{1}
+  }
+}
+Assignment{
+  Identifier{var}
+  ScalarConstructor{999}
+}
+)"));
+}
+
+TEST_F(SpvParserTest, EmitBody_Loop_SingleBlock_BothBackedge) {
+  auto* p = parser(test::Assemble(CommonTypes() + R"(
+     %100 = OpFunction %void None %voidfn
+
+     %10 = OpLabel
+     OpStore %var %uint_0
+     OpBranch %20
+
+     %20 = OpLabel
+     OpStore %var %uint_1
+     OpLoopMerge %99 %20 None
+     OpBranchConditional %cond %20 %20
+
+     %99 = OpLabel
+     OpStore %var %999
+     OpReturn
+
+     OpFunctionEnd
+  )"));
+  ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
+  FunctionEmitter fe(p, *spirv_function(100));
+  EXPECT_TRUE(fe.EmitBody()) << p->error();
+
+  EXPECT_THAT(ToString(fe.ast_body()), Eq(R"(Assignment{
+  Identifier{var}
+  ScalarConstructor{0}
+}
+Loop{
+  Assignment{
+    Identifier{var}
+    ScalarConstructor{1}
+  }
+}
+Assignment{
+  Identifier{var}
+  ScalarConstructor{999}
+}
+)"));
+}
+
+TEST_F(SpvParserTest, EmitBody_Loop_SingleBlock_UnconditionalBackege) {
+  auto* p = parser(test::Assemble(CommonTypes() + R"(
+     %100 = OpFunction %void None %voidfn
+
+     %10 = OpLabel
+     OpStore %var %uint_0
+     OpBranch %20
+
+     %20 = OpLabel
+     OpStore %var %uint_1
+     OpLoopMerge %99 %20 None
+     OpBranch %20
+
+     %99 = OpLabel
+     OpStore %var %999
+     OpReturn
+
+     OpFunctionEnd
+  )"));
+  ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
+  FunctionEmitter fe(p, *spirv_function(100));
+  EXPECT_TRUE(fe.EmitBody()) << p->error();
+
+  EXPECT_THAT(ToString(fe.ast_body()), Eq(R"(Assignment{
+  Identifier{var}
+  ScalarConstructor{0}
+}
+Loop{
+  Assignment{
+    Identifier{var}
+    ScalarConstructor{1}
+  }
+}
+Assignment{
+  Identifier{var}
+  ScalarConstructor{999}
+}
+)"));
+}
+
+TEST_F(SpvParserTest, EmitBody_Loop_Unconditional_Body_SingleBlockContinue) {
+  auto* p = parser(test::Assemble(CommonTypes() + R"(
+     %100 = OpFunction %void None %voidfn
+
+     %10 = OpLabel
+     OpStore %var %uint_0
+     OpBranch %20
+
+     %20 = OpLabel
+     OpStore %var %uint_1
+     OpLoopMerge %99 %50 None
+     OpBranch %30
+
+     %30 = OpLabel
+     OpStore %var %uint_2
+     OpBranch %50
+
+     %50 = OpLabel
+     OpStore %var %uint_3
+     OpBranch %20
+
+     %99 = OpLabel
+     OpStore %var %999
+     OpReturn
+
+     OpFunctionEnd
+  )"));
+  ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
+  FunctionEmitter fe(p, *spirv_function(100));
+  EXPECT_TRUE(fe.EmitBody()) << p->error();
+
+  EXPECT_THAT(ToString(fe.ast_body()), Eq(R"(Assignment{
+  Identifier{var}
+  ScalarConstructor{0}
+}
+Loop{
+  Assignment{
+    Identifier{var}
+    ScalarConstructor{1}
+  }
+  Assignment{
+    Identifier{var}
+    ScalarConstructor{2}
+  }
+  continuing {
+    Assignment{
+      Identifier{var}
+      ScalarConstructor{3}
+    }
+  }
+}
+Assignment{
+  Identifier{var}
+  ScalarConstructor{999}
+}
+)")) << ToString(fe.ast_body());
+}
+
+TEST_F(SpvParserTest, EmitBody_Loop_Unconditional_Body_MultiBlockContinue) {
+  auto* p = parser(test::Assemble(CommonTypes() + R"(
+     %100 = OpFunction %void None %voidfn
+
+     %10 = OpLabel
+     OpStore %var %uint_0
+     OpBranch %20
+
+     %20 = OpLabel
+     OpStore %var %uint_1
+     OpLoopMerge %99 %50 None
+     OpBranch %30
+
+     %30 = OpLabel
+     OpStore %var %uint_2
+     OpBranch %50
+
+     %50 = OpLabel
+     OpStore %var %uint_3
+     OpBranch %60
+
+     %60 = OpLabel
+     OpStore %var %uint_4
+     OpBranch %20
+
+     %99 = OpLabel
+     OpStore %var %999
+     OpReturn
+
+     OpFunctionEnd
+  )"));
+  ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
+  FunctionEmitter fe(p, *spirv_function(100));
+  EXPECT_TRUE(fe.EmitBody()) << p->error();
+
+  EXPECT_THAT(ToString(fe.ast_body()), Eq(R"(Assignment{
+  Identifier{var}
+  ScalarConstructor{0}
+}
+Loop{
+  Assignment{
+    Identifier{var}
+    ScalarConstructor{1}
+  }
+  Assignment{
+    Identifier{var}
+    ScalarConstructor{2}
+  }
+  continuing {
+    Assignment{
+      Identifier{var}
+      ScalarConstructor{3}
+    }
+    Assignment{
+      Identifier{var}
+      ScalarConstructor{4}
+    }
+  }
+}
+Assignment{
+  Identifier{var}
+  ScalarConstructor{999}
+}
+)")) << ToString(fe.ast_body());
+}
+
+TEST_F(SpvParserTest, EmitBody_Loop_Unconditional_Body_ContinueNestIf) {
+  auto* p = parser(test::Assemble(CommonTypes() + R"(
+     %100 = OpFunction %void None %voidfn
+
+     %10 = OpLabel
+     OpStore %var %uint_0
+     OpBranch %20
+
+     %20 = OpLabel
+     OpStore %var %uint_1
+     OpLoopMerge %99 %50 None
+     OpBranch %30
+
+     %30 = OpLabel
+     OpStore %var %uint_2
+     OpBranch %50
+
+     %50 = OpLabel ; continue target; also if-header
+     OpStore %var %uint_3
+     OpSelectionMerge %80 None
+     OpBranchConditional %cond2 %60 %80
+
+     %60 = OpLabel
+     OpStore %var %uint_4
+     OpBranch %80
+
+     %80 = OpLabel
+     OpStore %var %uint_5
+     OpBranch %20
+
+     %99 = OpLabel
+     OpStore %var %999
+     OpReturn
+
+     OpFunctionEnd
+  )"));
+  ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
+  FunctionEmitter fe(p, *spirv_function(100));
+  EXPECT_TRUE(fe.EmitBody()) << p->error();
+
+  EXPECT_THAT(ToString(fe.ast_body()), Eq(R"(Assignment{
+  Identifier{var}
+  ScalarConstructor{0}
+}
+Loop{
+  Assignment{
+    Identifier{var}
+    ScalarConstructor{1}
+  }
+  Assignment{
+    Identifier{var}
+    ScalarConstructor{2}
+  }
+  continuing {
+    Assignment{
+      Identifier{var}
+      ScalarConstructor{3}
+    }
+    If{
+      (
+        ScalarConstructor{true}
+      )
+      {
+        Assignment{
+          Identifier{var}
+          ScalarConstructor{4}
+        }
+      }
+    }
+    Else{
+      {
+      }
+    }
+    Assignment{
+      Identifier{var}
+      ScalarConstructor{5}
+    }
+  }
+}
+Assignment{
+  Identifier{var}
+  ScalarConstructor{999}
+}
+)")) << ToString(fe.ast_body());
+}
+
+TEST_F(SpvParserTest, DISABLED_EmitBody_Loop_Never) {
+  // Test case where both branches exit. e.g both go to merge.
+}
+
+TEST_F(SpvParserTest, DISABLED_EmitBody_Loop_HeaderBreakAndContinue) {
+  // Header block branches to merge, and to an outer continue.
+}
+
+TEST_F(SpvParserTest, DISABLED_EmitBody_Loop_TrueToBody) {
+  // TODO(dneto): Needs break-unless
+}
+
+TEST_F(SpvParserTest, DISABLED_EmitBody_Loop_FalseToBody) {
+  // TODO(dneto): Needs break-if
+}
+
+TEST_F(SpvParserTest, DISABLED_EmitBody_Loop_NestedIfContinue) {
+  // TODO(dneto): Needs "continue" terminator support
+}
+
+TEST_F(SpvParserTest, DISABLED_EmitBody_Loop_BodyAlwaysBreaks) {
+  // TODO(dneto): Needs "continue" terminator support
+}
+
+TEST_F(SpvParserTest, DISABLED_EmitBody_Loop_BodyConditionallyBreaks) {
+  // TODO(dneto): Needs "break" support
+}
+
 }  // namespace
 }  // namespace spirv
 }  // namespace reader