diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 3426625..3d2e507 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -330,6 +330,7 @@
     reader/spirv/fail_stream_test.cc
     reader/spirv/function_decl_test.cc
     reader/spirv/function_var_test.cc
+    reader/spirv/function_memory_test.cc
     reader/spirv/namer_test.cc
     reader/spirv/parser_impl_convert_member_decoration_test.cc
     reader/spirv/parser_impl_convert_type_test.cc
diff --git a/src/reader/spirv/function.cc b/src/reader/spirv/function.cc
index 97626f8..b92c64f 100644
--- a/src/reader/spirv/function.cc
+++ b/src/reader/spirv/function.cc
@@ -20,9 +20,8 @@
 #include "source/opt/function.h"
 #include "source/opt/instruction.h"
 #include "source/opt/module.h"
-#include "src/ast/bool_literal.h"
-#include "src/ast/float_literal.h"
-#include "src/ast/int_literal.h"
+#include "src/ast/assignment_statement.h"
+#include "src/ast/identifier_expression.h"
 #include "src/ast/scalar_constructor_expression.h"
 #include "src/ast/uint_literal.h"
 #include "src/ast/variable.h"
@@ -61,9 +60,7 @@
     return false;
   }
 
-  // Start populating the body.
-
-  if (!EmitFunctionVariables()) {
+  if (!EmitBody()) {
     return false;
   }
 
@@ -134,6 +131,16 @@
   return parser_impl_.ConvertType(var_store_type_id);
 }
 
+bool FunctionEmitter::EmitBody() {
+  if (!EmitFunctionVariables()) {
+    return false;
+  }
+  if (!EmitFunctionBodyStatements()) {
+    return false;
+  }
+  return success();
+}
+
 bool FunctionEmitter::EmitFunctionVariables() {
   if (failed()) {
     return false;
@@ -171,10 +178,66 @@
   if (spirv_constant) {
     return parser_impl_.MakeConstantExpression(id);
   }
+  const auto* inst = def_use_mgr_->GetDef(id);
+  if (inst == nullptr) {
+    Fail() << "ID " << id << " does not have a defining SPIR-V instruction";
+    return nullptr;
+  }
+  switch (inst->opcode()) {
+    case SpvOpVariable:
+      // This is not a declaration, but a use of an identifier.
+      return std::make_unique<ast::IdentifierExpression>(namer_.Name(id));
+    default:
+      break;
+  }
   Fail() << "unhandled expression for ID " << id;
   return nullptr;
 }
 
+bool FunctionEmitter::EmitFunctionBodyStatements() {
+  // TODO(dneto): For now, emit only regular statements in the entry block.
+  // We'll use assignments as markers in the tests, to be able to tell where
+  // code is placed in control flow. First prove that we can emit assignments.
+  return EmitStatementsInBasicBlock(*function_.entry());
+}
+
+bool FunctionEmitter::EmitStatementsInBasicBlock(
+    const spvtools::opt::BasicBlock& bb) {
+  const auto* terminator = bb.terminator();
+  const auto* merge = bb.GetMergeInst();  // Might be nullptr
+  // Emit regular statements.
+  for (auto& inst : bb) {
+    if (&inst == terminator || &inst == merge || inst.opcode() == SpvOpLabel ||
+        inst.opcode() == SpvOpVariable) {
+      continue;
+    }
+    if (!EmitStatement(inst)) {
+      return false;
+    }
+  }
+  // TODO(dneto): Handle the terminator
+  return true;
+}
+
+bool FunctionEmitter::EmitStatement(const spvtools::opt::Instruction& inst) {
+  switch (inst.opcode()) {
+    case SpvOpStore: {
+      // TODO(dneto): Order of evaluation?
+      auto lhs = MakeExpression(inst.GetSingleWordInOperand(0));
+      auto rhs = MakeExpression(inst.GetSingleWordInOperand(1));
+      ast_body_.emplace_back(std::make_unique<ast::AssignmentStatement>(
+          std::move(lhs), std::move(rhs)));
+      return success();
+    }
+    case SpvOpFunctionCall:
+      // TODO(dneto): Fill this out.  Make this pass, for existing tests
+      return success();
+    default:
+      break;
+  }
+  return Fail() << "unhandled instruction with opcode " << inst.opcode();
+}
+
 }  // namespace spirv
 }  // namespace reader
 }  // namespace tint
diff --git a/src/reader/spirv/function.h b/src/reader/spirv/function.h
index 2b7e58d..dd4c85a 100644
--- a/src/reader/spirv/function.h
+++ b/src/reader/spirv/function.h
@@ -18,8 +18,10 @@
 #include <memory>
 #include <vector>
 
+#include "source/opt/basic_block.h"
 #include "source/opt/constants.h"
 #include "source/opt/function.h"
+#include "source/opt/instruction.h"
 #include "source/opt/ir_context.h"
 #include "source/opt/type_manager.h"
 #include "src/ast/expression.h"
@@ -65,10 +67,29 @@
   /// @returns true if emission has not yet failed.
   bool EmitFunctionDeclaration();
 
+  /// Emits the function body, populating |ast_body_|
+  /// @returns false if emission failed.
+  bool EmitBody();
+
   /// Emits declarations of function variables.
   /// @returns false if emission failed.
   bool EmitFunctionVariables();
 
+  /// Emits statements in the body.
+  /// @returns false if emission failed.
+  bool EmitFunctionBodyStatements();
+
+  /// Emits a basic block
+  /// @param bb internal representation of the basic block
+  /// @returns false if emission failed.
+  bool EmitStatementsInBasicBlock(const spvtools::opt::BasicBlock& bb);
+
+  /// Emits a normal instruction: not a terminator, label, or variable
+  /// declaration.
+  /// @param inst the instruction
+  /// @returns false if emission failed.
+  bool EmitStatement(const spvtools::opt::Instruction& inst);
+
   /// Makes an expression
   /// @param id the SPIR-V ID of the value
   /// @returns true if emission has not yet failed.
diff --git a/src/reader/spirv/function_memory_test.cc b/src/reader/spirv/function_memory_test.cc
new file mode 100644
index 0000000..6f43419
--- /dev/null
+++ b/src/reader/spirv/function_memory_test.cc
@@ -0,0 +1,154 @@
+// Copyright 2020 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/reader/spirv/function.h"
+
+#include <string>
+#include <vector>
+
+#include "gmock/gmock.h"
+#include "src/reader/spirv/parser_impl.h"
+#include "src/reader/spirv/parser_impl_test_helper.h"
+#include "src/reader/spirv/spirv_tools_helpers_test.h"
+
+namespace tint {
+namespace reader {
+namespace spirv {
+namespace {
+
+using ::testing::HasSubstr;
+
+TEST_F(SpvParserTest, EmitFunctionVariables_StoreBoolConst) {
+  auto p = parser(test::Assemble(R"(
+     %void = OpTypeVoid
+     %voidfn = OpTypeFunction %void
+     %ty = OpTypeBool
+     %true = OpConstantTrue %ty
+     %false = OpConstantFalse %ty
+     %null = OpConstantNull %ty
+     %ptr_ty = OpTypePointer Function %ty
+     %100 = OpFunction %void None %voidfn
+     %entry = OpLabel
+     %1 = OpVariable %ptr_ty Function
+     OpStore %1 %true
+     OpStore %1 %false
+     OpStore %1 %null
+     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()), HasSubstr(R"(Assignment{
+  Identifier{x_1}
+  ScalarConstructor{true}
+}
+Assignment{
+  Identifier{x_1}
+  ScalarConstructor{false}
+}
+Assignment{
+  Identifier{x_1}
+  ScalarConstructor{false}
+})"));
+}
+
+TEST_F(SpvParserTest, EmitFunctionVariables_StoreUintConst) {
+  auto p = parser(test::Assemble(R"(
+     %void = OpTypeVoid
+     %voidfn = OpTypeFunction %void
+     %ty = OpTypeInt 32 0
+     %val = OpConstant %ty 42
+     %null = OpConstantNull %ty
+     %ptr_ty = OpTypePointer Function %ty
+     %100 = OpFunction %void None %voidfn
+     %entry = OpLabel
+     %1 = OpVariable %ptr_ty Function
+     OpStore %1 %val
+     OpStore %1 %null
+     OpReturn
+  )"));
+  ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
+  FunctionEmitter fe(p, *spirv_function(100));
+  EXPECT_TRUE(fe.EmitBody());
+  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(Assignment{
+  Identifier{x_1}
+  ScalarConstructor{42}
+}
+Assignment{
+  Identifier{x_1}
+  ScalarConstructor{0}
+})"));
+}
+
+TEST_F(SpvParserTest, EmitFunctionVariables_StoreIntConst) {
+  auto p = parser(test::Assemble(R"(
+     %void = OpTypeVoid
+     %voidfn = OpTypeFunction %void
+     %ty = OpTypeInt 32 1
+     %val = OpConstant %ty 42
+     %null = OpConstantNull %ty
+     %ptr_ty = OpTypePointer Function %ty
+     %100 = OpFunction %void None %voidfn
+     %entry = OpLabel
+     %1 = OpVariable %ptr_ty Function
+     OpStore %1 %val
+     OpStore %1 %null
+     OpReturn
+  )"));
+  ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
+  FunctionEmitter fe(p, *spirv_function(100));
+  EXPECT_TRUE(fe.EmitBody());
+  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(Assignment{
+  Identifier{x_1}
+  ScalarConstructor{42}
+}
+Assignment{
+  Identifier{x_1}
+  ScalarConstructor{0}
+})"));
+}
+
+TEST_F(SpvParserTest, EmitFunctionVariables_StoreFloatConst) {
+  auto p = parser(test::Assemble(R"(
+     %void = OpTypeVoid
+     %voidfn = OpTypeFunction %void
+     %ty = OpTypeFloat 32
+     %val = OpConstant %ty 42
+     %null = OpConstantNull %ty
+     %ptr_ty = OpTypePointer Function %ty
+     %100 = OpFunction %void None %voidfn
+     %entry = OpLabel
+     %1 = OpVariable %ptr_ty Function
+     OpStore %1 %val
+     OpStore %1 %null
+     OpReturn
+  )"));
+  ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
+  FunctionEmitter fe(p, *spirv_function(100));
+  EXPECT_TRUE(fe.EmitBody());
+  EXPECT_THAT(ToString(fe.ast_body()), HasSubstr(R"(Assignment{
+  Identifier{x_1}
+  ScalarConstructor{42.000000}
+}
+Assignment{
+  Identifier{x_1}
+  ScalarConstructor{0.000000}
+})"));
+}
+
+}  // namespace
+}  // namespace spirv
+}  // namespace reader
+}  // namespace tint