diff --git a/build/Android.gtest.mk b/build/Android.gtest.mk
index 2ddd09e..34a0f7a 100644
--- a/build/Android.gtest.mk
+++ b/build/Android.gtest.mk
@@ -64,6 +64,7 @@
 	compiler/image_test.cc \
 	compiler/jni/jni_compiler_test.cc \
 	compiler/oat_test.cc \
+	compiler/optimizing/codegen_test.cc \
 	compiler/optimizing/dominator_test.cc \
 	compiler/optimizing/pretty_printer_test.cc \
 	compiler/output_stream_test.cc \
diff --git a/compiler/Android.mk b/compiler/Android.mk
index 8f840cc..7a78b3a 100644
--- a/compiler/Android.mk
+++ b/compiler/Android.mk
@@ -69,6 +69,9 @@
 	jni/quick/calling_convention.cc \
 	jni/quick/jni_compiler.cc \
 	optimizing/builder.cc \
+	optimizing/code_generator.cc \
+	optimizing/code_generator_arm.cc \
+	optimizing/code_generator_x86.cc \
 	optimizing/nodes.cc \
 	trampolines/trampoline_compiler.cc \
 	utils/arena_allocator.cc \
diff --git a/compiler/optimizing/builder.cc b/compiler/optimizing/builder.cc
index e6db7bc..f78e56b 100644
--- a/compiler/optimizing/builder.cc
+++ b/compiler/optimizing/builder.cc
@@ -29,6 +29,8 @@
   entry_block_->AddInstruction(new (arena_) HGoto());
   exit_block_ = new (arena_) HBasicBlock(graph_);
   exit_block_->AddInstruction(new (arena_) HExit());
+  graph_->set_entry_block(entry_block_);
+  graph_->set_exit_block(exit_block_);
 
   // To avoid splitting blocks, we compute ahead of time the instructions that
   // start a new block, and create these blocks.
diff --git a/compiler/optimizing/code_generator.cc b/compiler/optimizing/code_generator.cc
new file mode 100644
index 0000000..01fc23b
--- /dev/null
+++ b/compiler/optimizing/code_generator.cc
@@ -0,0 +1,79 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * 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 "code_generator.h"
+
+#include "code_generator_arm.h"
+#include "code_generator_x86.h"
+#include "utils/assembler.h"
+#include "utils/arm/assembler_arm.h"
+#include "utils/mips/assembler_mips.h"
+#include "utils/x86/assembler_x86.h"
+
+namespace art {
+
+void CodeGenerator::Compile(CodeAllocator* allocator) {
+  GenerateFrameEntry();
+  const GrowableArray<HBasicBlock*>* blocks = graph()->blocks();
+  for (size_t i = 0; i < blocks->Size(); i++) {
+    CompileBlock(blocks->Get(i));
+  }
+  size_t code_size = assembler_->CodeSize();
+  uint8_t* buffer = allocator->Allocate(code_size);
+  MemoryRegion code(buffer, code_size);
+  assembler_->FinalizeInstructions(code);
+}
+
+void CodeGenerator::CompileBlock(HBasicBlock* block) {
+  Bind(GetLabelOf(block));
+  for (HInstructionIterator it(block); !it.Done(); it.Advance()) {
+    it.Current()->Accept(this);
+  }
+}
+
+bool CodeGenerator::GoesToNextBlock(HGoto* goto_instruction) const {
+  HBasicBlock* successor = goto_instruction->GetSuccessor();
+  // We currently iterate over the block in insertion order.
+  return goto_instruction->block()->block_id() + 1 == successor->block_id();
+}
+
+Label* CodeGenerator::GetLabelOf(HBasicBlock* block) const {
+  return block_labels_.GetRawStorage() + block->block_id();
+}
+
+bool CodeGenerator::CompileGraph(HGraph* graph,
+                                 InstructionSet instruction_set,
+                                 CodeAllocator* allocator) {
+  switch (instruction_set) {
+    case kArm:
+    case kThumb2: {
+      arm::ArmAssembler assembler;
+      arm::CodeGeneratorARM(&assembler, graph).Compile(allocator);
+      return true;
+    }
+    case kMips:
+      return false;
+    case kX86: {
+      x86::X86Assembler assembler;
+      x86::CodeGeneratorX86(&assembler, graph).Compile(allocator);
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+
+}  // namespace art
diff --git a/compiler/optimizing/code_generator.h b/compiler/optimizing/code_generator.h
new file mode 100644
index 0000000..2a5ae7d
--- /dev/null
+++ b/compiler/optimizing/code_generator.h
@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#ifndef ART_COMPILER_OPTIMIZING_CODE_GENERATOR_H_
+#define ART_COMPILER_OPTIMIZING_CODE_GENERATOR_H_
+
+#include "instruction_set.h"
+#include "memory_region.h"
+#include "nodes.h"
+#include "utils/assembler.h"
+
+namespace art {
+
+class CodeAllocator {
+ public:
+  CodeAllocator() { }
+  virtual ~CodeAllocator() { }
+
+  virtual uint8_t* Allocate(size_t size) = 0;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(CodeAllocator);
+};
+
+class CodeGenerator : public HGraphVisitor {
+ public:
+  // Compiles the graph to executable instructions. Returns whether the compilation
+  // succeeded.
+  static bool CompileGraph(
+      HGraph* graph, InstructionSet instruction_set, CodeAllocator* allocator);
+
+  Assembler* assembler() const { return assembler_; }
+
+  // Visit functions for instruction classes.
+#define DECLARE_VISIT_INSTRUCTION(name)     \
+  virtual void Visit##name(H##name* instr) = 0;
+
+  FOR_EACH_INSTRUCTION(DECLARE_VISIT_INSTRUCTION)
+
+#undef DECLARE_VISIT_INSTRUCTION
+
+ protected:
+  CodeGenerator(Assembler* assembler, HGraph* graph)
+      : HGraphVisitor(graph), assembler_(assembler), block_labels_(graph->arena(), 0) {
+    block_labels_.SetSize(graph->blocks()->Size());
+  }
+
+  Label* GetLabelOf(HBasicBlock* block) const;
+  bool GoesToNextBlock(HGoto* got) const;
+
+ private:
+  virtual void GenerateFrameEntry() = 0;
+  virtual void GenerateFrameExit() = 0;
+  virtual void Bind(Label* label) = 0;
+
+  void Compile(CodeAllocator* allocator);
+  void CompileBlock(HBasicBlock* block);
+
+  Assembler* const assembler_;
+
+  // Labels for each block that will be compiled.
+  GrowableArray<Label> block_labels_;
+
+  DISALLOW_COPY_AND_ASSIGN(CodeGenerator);
+};
+
+}  // namespace art
+
+#endif  // ART_COMPILER_OPTIMIZING_CODE_GENERATOR_H_
diff --git a/compiler/optimizing/code_generator_arm.cc b/compiler/optimizing/code_generator_arm.cc
new file mode 100644
index 0000000..99bbaa0
--- /dev/null
+++ b/compiler/optimizing/code_generator_arm.cc
@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * 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 "code_generator_arm.h"
+#include "utils/assembler.h"
+#include "utils/arm/assembler_arm.h"
+
+#define __ reinterpret_cast<ArmAssembler*>(assembler())->
+
+namespace art {
+namespace arm {
+
+void CodeGeneratorARM::GenerateFrameEntry() {
+  RegList registers = (1 << LR) | (1 << FP);
+  __ PushList(registers);
+}
+
+void CodeGeneratorARM::GenerateFrameExit() {
+  RegList registers = (1 << PC) | (1 << FP);
+  __ PopList(registers);
+}
+
+void CodeGeneratorARM::Bind(Label* label) {
+  __ Bind(label);
+}
+
+void CodeGeneratorARM::VisitGoto(HGoto* got) {
+  HBasicBlock* successor = got->GetSuccessor();
+  if (graph()->exit_block() == successor) {
+    GenerateFrameExit();
+  } else if (!GoesToNextBlock(got)) {
+    __ b(GetLabelOf(successor));
+  }
+}
+
+void CodeGeneratorARM::VisitExit(HExit* exit) {
+  if (kIsDebugBuild) {
+    __ Comment("Unreachable");
+    __ bkpt(0);
+  }
+}
+
+void CodeGeneratorARM::VisitIf(HIf* if_instr) {
+  LOG(FATAL) << "UNIMPLEMENTED";
+}
+
+void CodeGeneratorARM::VisitReturnVoid(HReturnVoid* ret) {
+  GenerateFrameExit();
+}
+
+}  // namespace arm
+}  // namespace art
diff --git a/compiler/optimizing/code_generator_arm.h b/compiler/optimizing/code_generator_arm.h
new file mode 100644
index 0000000..27a83b8
--- /dev/null
+++ b/compiler/optimizing/code_generator_arm.h
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#ifndef ART_COMPILER_OPTIMIZING_CODE_GENERATOR_ARM_H_
+#define ART_COMPILER_OPTIMIZING_CODE_GENERATOR_ARM_H_
+
+#include "code_generator.h"
+#include "nodes.h"
+
+namespace art {
+
+class Assembler;
+class Label;
+
+namespace arm {
+
+class CodeGeneratorARM : public CodeGenerator {
+ public:
+  CodeGeneratorARM(Assembler* assembler, HGraph* graph)
+      : CodeGenerator(assembler, graph) { }
+
+  // Visit functions for instruction classes.
+#define DECLARE_VISIT_INSTRUCTION(name)     \
+  virtual void Visit##name(H##name* instr);
+
+  FOR_EACH_INSTRUCTION(DECLARE_VISIT_INSTRUCTION)
+
+#undef DECLARE_VISIT_INSTRUCTION
+
+ private:
+  virtual void GenerateFrameEntry();
+  virtual void GenerateFrameExit();
+  virtual void Bind(Label* label);
+
+  DISALLOW_COPY_AND_ASSIGN(CodeGeneratorARM);
+};
+
+}  // namespace arm
+}  // namespace art
+
+#endif  // ART_COMPILER_OPTIMIZING_CODE_GENERATOR_ARM_H_
diff --git a/compiler/optimizing/code_generator_x86.cc b/compiler/optimizing/code_generator_x86.cc
new file mode 100644
index 0000000..1facfd7
--- /dev/null
+++ b/compiler/optimizing/code_generator_x86.cc
@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * 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 "code_generator_x86.h"
+#include "utils/assembler.h"
+#include "utils/x86/assembler_x86.h"
+
+#define __ reinterpret_cast<X86Assembler*>(assembler())->
+
+namespace art {
+namespace x86 {
+
+void CodeGeneratorX86::GenerateFrameEntry() {
+  __ pushl(EBP);
+  __ movl(EBP, ESP);
+}
+
+void CodeGeneratorX86::GenerateFrameExit() {
+  __ movl(ESP, EBP);
+  __ popl(EBP);
+}
+
+void CodeGeneratorX86::Bind(Label* label) {
+  __ Bind(label);
+}
+
+void CodeGeneratorX86::VisitGoto(HGoto* got) {
+  HBasicBlock* successor = got->GetSuccessor();
+  if (graph()->exit_block() == successor) {
+    GenerateFrameExit();
+  } else if (!GoesToNextBlock(got)) {
+    __ jmp(GetLabelOf(successor));
+  }
+}
+
+void CodeGeneratorX86::VisitExit(HExit* exit) {
+  if (kIsDebugBuild) {
+    __ Comment("Unreachable");
+    __ int3();
+  }
+}
+
+void CodeGeneratorX86::VisitIf(HIf* if_instr) {
+  LOG(FATAL) << "UNIMPLEMENTED";
+}
+
+void CodeGeneratorX86::VisitReturnVoid(HReturnVoid* ret) {
+  GenerateFrameExit();
+  __ ret();
+}
+
+}  // namespace x86
+}  // namespace art
diff --git a/compiler/optimizing/code_generator_x86.h b/compiler/optimizing/code_generator_x86.h
new file mode 100644
index 0000000..7dae2ab
--- /dev/null
+++ b/compiler/optimizing/code_generator_x86.h
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#ifndef ART_COMPILER_OPTIMIZING_CODE_GENERATOR_X86_H_
+#define ART_COMPILER_OPTIMIZING_CODE_GENERATOR_X86_H_
+
+#include "code_generator.h"
+#include "nodes.h"
+
+namespace art {
+
+class Assembler;
+class Label;
+
+namespace x86 {
+
+class CodeGeneratorX86 : public CodeGenerator {
+ public:
+  CodeGeneratorX86(Assembler* assembler, HGraph* graph)
+      : CodeGenerator(assembler, graph) { }
+
+  // Visit functions for instruction classes.
+#define DECLARE_VISIT_INSTRUCTION(name)     \
+  virtual void Visit##name(H##name* instr);
+
+  FOR_EACH_INSTRUCTION(DECLARE_VISIT_INSTRUCTION)
+
+#undef DECLARE_VISIT_INSTRUCTION
+
+ private:
+  virtual void GenerateFrameEntry();
+  virtual void GenerateFrameExit();
+  virtual void Bind(Label* label);
+
+  DISALLOW_COPY_AND_ASSIGN(CodeGeneratorX86);
+};
+
+}  // namespace x86
+}  // namespace art
+
+#endif  // ART_COMPILER_OPTIMIZING_CODE_GENERATOR_X86_H_
diff --git a/compiler/optimizing/codegen_test.cc b/compiler/optimizing/codegen_test.cc
new file mode 100644
index 0000000..dc4999b
--- /dev/null
+++ b/compiler/optimizing/codegen_test.cc
@@ -0,0 +1,124 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * 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 "builder.h"
+#include "code_generator.h"
+#include "common_compiler_test.h"
+#include "dex_instruction.h"
+#include "instruction_set.h"
+#include "nodes.h"
+
+#include "gtest/gtest.h"
+
+namespace art {
+
+class ExecutableMemoryAllocator : public CodeAllocator {
+ public:
+  ExecutableMemoryAllocator() { }
+
+  virtual uint8_t* Allocate(size_t size) {
+    memory_.reset(new uint8_t[size]);
+    CommonCompilerTest::MakeExecutable(memory_.get(), size);
+    return memory_.get();
+  }
+
+  uint8_t* memory() const { return memory_.get(); }
+
+ private:
+  UniquePtr<uint8_t[]> memory_;
+
+  DISALLOW_COPY_AND_ASSIGN(ExecutableMemoryAllocator);
+};
+
+static void TestCode(const uint16_t* data, int length) {
+  ArenaPool pool;
+  ArenaAllocator arena(&pool);
+  HGraphBuilder builder(&arena);
+  HGraph* graph = builder.BuildGraph(data, data + length);
+  ASSERT_NE(graph, nullptr);
+  ExecutableMemoryAllocator allocator;
+  CHECK(CodeGenerator::CompileGraph(graph, kX86, &allocator));
+  typedef void (*fptr)();
+#if defined(__i386__)
+  reinterpret_cast<fptr>(allocator.memory())();
+#endif
+  CHECK(CodeGenerator::CompileGraph(graph, kArm, &allocator));
+#if defined(__arm__)
+  reinterpret_cast<fptr>(allocator.memory())();
+#endif
+}
+
+TEST(CodegenTest, ReturnVoid) {
+  const uint16_t data[] = { Instruction::RETURN_VOID };
+  TestCode(data, sizeof(data) / sizeof(uint16_t));
+}
+
+TEST(PrettyPrinterTest, CFG1) {
+  const uint16_t data[] = {
+    Instruction::GOTO | 0x100,
+    Instruction::RETURN_VOID
+  };
+
+  TestCode(data, sizeof(data) / sizeof(uint16_t));
+}
+
+TEST(PrettyPrinterTest, CFG2) {
+  const uint16_t data[] = {
+    Instruction::GOTO | 0x100,
+    Instruction::GOTO | 0x100,
+    Instruction::RETURN_VOID
+  };
+
+  TestCode(data, sizeof(data) / sizeof(uint16_t));
+}
+
+TEST(PrettyPrinterTest, CFG3) {
+  const uint16_t data1[] = {
+    Instruction::GOTO | 0x200,
+    Instruction::RETURN_VOID,
+    Instruction::GOTO | 0xFF00
+  };
+
+  TestCode(data1, sizeof(data1) / sizeof(uint16_t));
+
+  const uint16_t data2[] = {
+    Instruction::GOTO_16, 3,
+    Instruction::RETURN_VOID,
+    Instruction::GOTO_16, 0xFFFF
+  };
+
+  TestCode(data2, sizeof(data2) / sizeof(uint16_t));
+
+  const uint16_t data3[] = {
+    Instruction::GOTO_32, 4, 0,
+    Instruction::RETURN_VOID,
+    Instruction::GOTO_32, 0xFFFF, 0xFFFF
+  };
+
+  TestCode(data3, sizeof(data3) / sizeof(uint16_t));
+}
+
+TEST(PrettyPrinterTest, CFG4) {
+  const uint16_t data[] = {
+    Instruction::RETURN_VOID,
+    Instruction::GOTO | 0x100,
+    Instruction::GOTO | 0xFE00
+  };
+
+  TestCode(data, sizeof(data) / sizeof(uint16_t));
+}
+
+}  // namespace art
diff --git a/compiler/optimizing/nodes.cc b/compiler/optimizing/nodes.cc
index 9ec8e89..aefb089 100644
--- a/compiler/optimizing/nodes.cc
+++ b/compiler/optimizing/nodes.cc
@@ -26,7 +26,7 @@
 
 void HGraph::FindBackEdges(ArenaBitVector* visited) const {
   ArenaBitVector visiting(arena_, blocks_.Size(), false);
-  VisitBlockForBackEdges(GetEntryBlock(), visited, &visiting);
+  VisitBlockForBackEdges(entry_block_, visited, &visiting);
 }
 
 void HGraph::RemoveDeadBlocks(const ArenaBitVector& visited) const {
@@ -75,10 +75,9 @@
   //     have been processed.
   GrowableArray<size_t> visits(arena_, blocks_.Size());
   visits.SetSize(blocks_.Size());
-  HBasicBlock* entry = GetEntryBlock();
-  dominator_order_.Add(entry);
-  for (size_t i = 0; i < entry->successors()->Size(); i++) {
-    VisitBlockForDominatorTree(entry->successors()->Get(i), entry, &visits);
+  dominator_order_.Add(entry_block_);
+  for (size_t i = 0; i < entry_block_->successors()->Size(); i++) {
+    VisitBlockForDominatorTree(entry_block_->successors()->Get(i), entry_block_, &visits);
   }
 }
 
@@ -122,6 +121,7 @@
 }
 
 void HBasicBlock::AddInstruction(HInstruction* instruction) {
+  instruction->set_block(this);
   if (first_instruction_ == nullptr) {
     DCHECK(last_instruction_ == nullptr);
     first_instruction_ = last_instruction_ = instruction;
diff --git a/compiler/optimizing/nodes.h b/compiler/optimizing/nodes.h
index 3d5d531..46fe95e 100644
--- a/compiler/optimizing/nodes.h
+++ b/compiler/optimizing/nodes.h
@@ -43,6 +43,13 @@
   ArenaAllocator* arena() const { return arena_; }
   const GrowableArray<HBasicBlock*>* blocks() const { return &blocks_; }
 
+  HBasicBlock* entry_block() const { return entry_block_; }
+  HBasicBlock* exit_block() const { return exit_block_; }
+
+  void set_entry_block(HBasicBlock* block) { entry_block_ = block; }
+  void set_exit_block(HBasicBlock* block) { exit_block_ = block; }
+
+
   void AddBlock(HBasicBlock* block);
   void BuildDominatorTree();
 
@@ -57,8 +64,6 @@
                               ArenaBitVector* visiting) const;
   void RemoveDeadBlocks(const ArenaBitVector& visited) const;
 
-  HBasicBlock* GetEntryBlock() const { return blocks_.Get(0); }
-
   ArenaAllocator* const arena_;
 
   // List of blocks in insertion order.
@@ -67,6 +72,9 @@
   // List of blocks to perform a pre-order dominator tree traversal.
   GrowableArray<HBasicBlock*> dominator_order_;
 
+  HBasicBlock* entry_block_;
+  HBasicBlock* exit_block_;
+
   DISALLOW_COPY_AND_ASSIGN(HGraph);
 };
 
@@ -174,12 +182,15 @@
 
 class HInstruction : public ArenaObject {
  public:
-  HInstruction() : previous_(nullptr), next_(nullptr) { }
+  HInstruction() : previous_(nullptr), next_(nullptr), block_(nullptr) { }
   virtual ~HInstruction() { }
 
   HInstruction* next() const { return next_; }
   HInstruction* previous() const { return previous_; }
 
+  HBasicBlock* block() const { return block_; }
+  void set_block(HBasicBlock* block) { block_ = block; }
+
   virtual intptr_t InputCount() const  = 0;
   virtual HInstruction* InputAt(intptr_t i) const = 0;
 
@@ -189,6 +200,7 @@
  private:
   HInstruction* previous_;
   HInstruction* next_;
+  HBasicBlock* block_;
 
   friend class HBasicBlock;
 
@@ -304,6 +316,10 @@
  public:
   HGoto() { }
 
+  HBasicBlock* GetSuccessor() const {
+    return block()->successors()->Get(0);
+  }
+
   DECLARE_INSTRUCTION(Goto)
 
  private:
@@ -333,6 +349,8 @@
 
   void VisitInsertionOrder();
 
+  HGraph* graph() const { return graph_; }
+
   // Visit functions for instruction classes.
 #define DECLARE_VISIT_INSTRUCTION(name)                                        \
   virtual void Visit##name(H##name* instr) { VisitInstruction(instr); }
diff --git a/compiler/utils/assembler.h b/compiler/utils/assembler.h
index c9be4ed..5e7b2fa 100644
--- a/compiler/utils/assembler.h
+++ b/compiler/utils/assembler.h
@@ -324,6 +324,9 @@
     buffer_.FinalizeInstructions(region);
   }
 
+  // TODO: Implement with disassembler.
+  virtual void Comment(const char* format, ...) { }
+
   // Emit code that will create an activation on the stack
   virtual void BuildFrame(size_t frame_size, ManagedRegister method_reg,
                           const std::vector<ManagedRegister>& callee_save_regs,