diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedCatchAllExceptionHandler.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedCatchAllExceptionHandler.java
index f98f3a85..a472c27f 100644
--- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedCatchAllExceptionHandler.java
+++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedCatchAllExceptionHandler.java
@@ -32,13 +32,15 @@
 package org.jf.dexlib2.dexbacked;
 
 import org.jf.dexlib2.DexFileReader;
+import org.jf.dexlib2.dexbacked.util.InstructionOffsetMap;
 import org.jf.dexlib2.immutable.ImmutableExceptionHandler;
 
 import javax.annotation.Nonnull;
 
 public class DexBackedCatchAllExceptionHandler extends ImmutableExceptionHandler {
-    public DexBackedCatchAllExceptionHandler(@Nonnull DexFileReader dexFileReader) {
+    public DexBackedCatchAllExceptionHandler(@Nonnull DexFileReader dexFileReader,
+                                             @Nonnull InstructionOffsetMap instructionOffsetMap) {
         super(null,
-              dexFileReader.readSmallUleb128());
+              instructionOffsetMap.getInstructionIndexAtOffsetExact(dexFileReader.readSmallUleb128()));
     }
 }
diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedExceptionHandler.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedExceptionHandler.java
index 2bc340e5..67ad855b 100644
--- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedExceptionHandler.java
+++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedExceptionHandler.java
@@ -32,13 +32,16 @@
 package org.jf.dexlib2.dexbacked;
 
 import org.jf.dexlib2.DexFileReader;
+import org.jf.dexlib2.dexbacked.util.InstructionOffsetMap;
 import org.jf.dexlib2.immutable.ImmutableExceptionHandler;
 
 import javax.annotation.Nonnull;
 
 public class DexBackedExceptionHandler extends ImmutableExceptionHandler {
-    public DexBackedExceptionHandler(@Nonnull DexFileReader dexFileReader) {
+    public DexBackedExceptionHandler(@Nonnull DexFileReader dexFileReader,
+                                     @Nonnull InstructionOffsetMap instructionOffsetMap) {
+        // TODO: verify dalvik doesn't accept an exception handler that points in the middle of an instruction
         super(dexFileReader.getType(dexFileReader.readSmallUleb128()),
-              dexFileReader.readSmallUleb128());
+              instructionOffsetMap.getInstructionIndexAtOffsetExact(dexFileReader.readSmallUleb128()));
     }
 }
diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedMethodImplementation.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedMethodImplementation.java
index 084d348e..0180a556 100644
--- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedMethodImplementation.java
+++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedMethodImplementation.java
@@ -31,37 +31,109 @@
 
 package org.jf.dexlib2.dexbacked;
 
+import com.google.common.collect.ImmutableList;
 import org.jf.dexlib2.DexFile;
+import org.jf.dexlib2.DexFileReader;
+import org.jf.dexlib2.dexbacked.instruction.DexBackedInstruction;
+import org.jf.dexlib2.dexbacked.util.FixedSizeList;
+import org.jf.dexlib2.dexbacked.util.InstructionOffsetMap;
 import org.jf.dexlib2.iface.MethodImplementation;
 import org.jf.dexlib2.iface.TryBlock;
 import org.jf.dexlib2.iface.instruction.Instruction;
+import org.jf.util.AlignmentUtils;
 
 import javax.annotation.Nonnull;
+import java.util.ArrayList;
 import java.util.List;
 
 public class DexBackedMethodImplementation implements MethodImplementation {
     @Nonnull public final DexFile dexFile;
+    private final int codeOffset;
+
+    public final int registerCount;
+    @Nonnull public final ImmutableList<? extends Instruction> instructions;
+    @Nonnull private final InstructionOffsetMap instructionOffsetMap;
+
+    // code_item offsets
+    private static final int TRIES_SIZE_OFFSET = 6;
+    private static final int INSTRUCTIONS_SIZE_OFFSET = 12;
+    private static final int INSTRUCTIONS_START_OFFSET = 16;
+
+    private static final int TRY_ITEM_SIZE = 8;
 
     public DexBackedMethodImplementation(@Nonnull DexFile dexFile,
                                          int codeOffset) {
         this.dexFile = dexFile;
+        this.codeOffset = codeOffset;
+        this.registerCount = dexFile.readUshort(codeOffset);
+
+        instructions = buildInstructionList();
+        instructionOffsetMap = buildInstructionOffsetMap();
     }
 
-
-    @Override
-    public int getRegisterCount() {
-        return 0;
-    }
-
-    @Nonnull
-    @Override
-    public List<? extends Instruction> getInstructions() {
-        return null;
-    }
+    @Override public int getRegisterCount() { return registerCount; }
+    @Nonnull @Override public ImmutableList<? extends Instruction> getInstructions() { return instructions; }
 
     @Nonnull
     @Override
     public List<? extends TryBlock> getTryBlocks() {
-        return null;
+        final int triesSize = dexFile.readUshort(codeOffset + TRIES_SIZE_OFFSET);
+        if (triesSize > 0) {
+            int instructionsSize = dexFile.readSmallUint(codeOffset + INSTRUCTIONS_SIZE_OFFSET);
+            final int triesStartOffset = AlignmentUtils.alignOffset(
+                    codeOffset + INSTRUCTIONS_START_OFFSET + (instructionsSize*2), 4);
+            final int handlersStartOffset = triesStartOffset + triesSize*TRY_ITEM_SIZE;
+
+            return new FixedSizeList<TryBlock>() {
+                @Override
+                public TryBlock readItem(int index) {
+                    return new DexBackedTryBlock(dexFile,
+                            triesStartOffset + index*TRY_ITEM_SIZE,
+                            handlersStartOffset,
+                            instructionOffsetMap);
+                }
+
+                @Override
+                public int size() {
+                    return triesSize;
+                }
+            };
+        }
+        return ImmutableList.of();
+    }
+
+    private ImmutableList<? extends Instruction> buildInstructionList() {
+        // instructionsSize is the number of 16-bit code units in the instruction list, not the number of instructions
+        int instructionsSize = dexFile.readSmallUint(codeOffset + INSTRUCTIONS_SIZE_OFFSET);
+
+        // we can use instructionsSize as an upper bound on the number of instructions there will be
+        ArrayList<Instruction> instructions = new ArrayList<Instruction>(instructionsSize);
+        int instructionsStartOffset = codeOffset + INSTRUCTIONS_START_OFFSET;
+        DexFileReader reader = dexFile.readerAt(instructionsStartOffset);
+        int endOffset = instructionsStartOffset + (instructionsSize*2);
+
+        while (reader.getOffset() < endOffset) {
+            instructions.add(DexBackedInstruction.readFrom(reader));
+        }
+
+        return ImmutableList.copyOf(instructions);
+    }
+
+    /**
+     * Builds an InstructionOffsetMap that maps an instruction offset to its index.
+     *
+     * This must be called after the instructions field has been set
+     *
+     * @return An InstructionOffsetMap object
+     */
+    private InstructionOffsetMap buildInstructionOffsetMap() {
+        int[] offsets = new int[instructions.size()];
+        int currentOffset = 0;
+        for (int i=0; i<offsets.length; i++) {
+            offsets[i] = currentOffset;
+            // TODO: need to handle variable size instructions
+            currentOffset += instructions.get(i).getOpcode().format.size;
+        }
+        return new InstructionOffsetMap(offsets);
     }
 }
diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedTryBlock.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedTryBlock.java
index 2c966ca1..96e7a2ce 100644
--- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedTryBlock.java
+++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedTryBlock.java
@@ -33,6 +33,7 @@ package org.jf.dexlib2.dexbacked;
 
 import org.jf.dexlib2.DexFile;
 import org.jf.dexlib2.DexFileReader;
+import org.jf.dexlib2.dexbacked.util.InstructionOffsetMap;
 import org.jf.dexlib2.iface.ExceptionHandler;
 import org.jf.dexlib2.iface.TryBlock;
 import org.jf.dexlib2.dexbacked.util.VariableSizeList;
@@ -42,19 +43,38 @@ import java.util.List;
 
 public class DexBackedTryBlock implements TryBlock {
     public final DexFile dexFile;
+    private final InstructionOffsetMap instructionOffsetMap;
 
     public final int startIndex;
     public final int instructionCount;
 
     private final int exceptionHandlersOffset;
 
+    private static final int START_ADDRESS_OFFSET = 0;
+    private static final int CODE_UNIT_COUNT_OFFSET = 4;
+    private static final int HANDLER_OFFSET_OFFSET = 6;
+
     public DexBackedTryBlock(DexFile dexFile,
-                             int offset,
-                             int handlersStartOffset) {
+                             int tryItemOffset,
+                             int handlersStartOffset,
+                             InstructionOffsetMap instructionOffsetMap) {
         this.dexFile = dexFile;
-        this.startIndex = dexFile.readSmallUint(offset);
-        this.instructionCount = dexFile.readUshort(offset+4);
-        this.exceptionHandlersOffset = handlersStartOffset + dexFile.readUshort(6);
+        this.instructionOffsetMap = instructionOffsetMap;
+
+        int startOffset = dexFile.readSmallUint(tryItemOffset + START_ADDRESS_OFFSET);
+        // map the code unit offset to the instruction index
+        this.startIndex = instructionOffsetMap.getInstructionIndexAtOffsetExact(startOffset);
+
+        int codeUnitCount = dexFile.readUshort(tryItemOffset + CODE_UNIT_COUNT_OFFSET);
+        // TODO: check if dalivk accepts insns_size = 0
+        if (codeUnitCount == 0) {
+            this.instructionCount = 0;
+        } else {
+            int lastIndex = instructionOffsetMap.getInstructionIndexAtOffset(startOffset + codeUnitCount - 1);
+            this.instructionCount = lastIndex - startIndex + 1;
+        }
+
+        this.exceptionHandlersOffset = handlersStartOffset + dexFile.readUshort(tryItemOffset + HANDLER_OFFSET_OFFSET);
     }
 
     @Override public int getStartIndex() { return startIndex; }
@@ -72,7 +92,7 @@ public class DexBackedTryBlock implements TryBlock {
                 @Nonnull
                 @Override
                 protected ExceptionHandler readItem(DexFileReader dexFileReader, int index) {
-                    return new DexBackedExceptionHandler(dexFileReader);
+                    return new DexBackedExceptionHandler(dexFileReader, instructionOffsetMap);
                 }
                 @Override public int size() { return encodedSize; }
             };
@@ -84,9 +104,9 @@ public class DexBackedTryBlock implements TryBlock {
                 @Override
                 protected ExceptionHandler readItem(DexFileReader dexFileReader, int index) {
                     if (index == sizeWithCatchAll-1) {
-                        return new DexBackedCatchAllExceptionHandler(dexFileReader);
+                        return new DexBackedCatchAllExceptionHandler(dexFileReader, instructionOffsetMap);
                     } else {
-                        return new DexBackedExceptionHandler(dexFileReader);
+                        return new DexBackedExceptionHandler(dexFileReader, instructionOffsetMap);
                     }
                 }
                 @Override public int size() { return sizeWithCatchAll; }
diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/util/InstructionOffsetMap.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/util/InstructionOffsetMap.java
new file mode 100644
index 00000000..d69af88d
--- /dev/null
+++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/util/InstructionOffsetMap.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright 2012, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.dexlib2.dexbacked.util;
+
+import org.jf.util.ExceptionWithContext;
+
+import java.util.Arrays;
+
+public class InstructionOffsetMap {
+    private final int[] instructionOffsets;
+
+    public InstructionOffsetMap(int[] instructionOffsets) {
+        this.instructionOffsets = instructionOffsets;
+    }
+
+    public int getInstructionIndexAtOffsetExact(int offset) {
+        int index = Arrays.binarySearch(instructionOffsets, offset);
+        if (index < 0) {
+            throw new ExceptionWithContext("No instruction at offset %d", offset);
+        }
+        return index;
+    }
+
+    public int getInstructionIndexAtOffset(int offset) {
+        int index = Arrays.binarySearch(instructionOffsets, offset);
+        if (index < 0) {
+            // This would fail if index was -1 (i.e. insertion point of 0). Luckily, we can ignore this case, because
+            // offset will always be non-negative, and the offset of the first instruction will always be 0.
+            return (~index) - 1;
+        }
+        return index;
+    }
+}