diff --git a/vm/compiler/Compiler.h b/vm/compiler/Compiler.h
index 7209701..9bcee12 100644
--- a/vm/compiler/Compiler.h
+++ b/vm/compiler/Compiler.h
@@ -95,5 +95,6 @@
 void *dvmCompileTrace(JitTraceDescription *trace);
 void dvmCompilerDumpStats(void);
 void dvmCompilerDrainQueue(void);
+void dvmJitUnchainAll(void);
 
 #endif /* _DALVIK_VM_COMPILER */
diff --git a/vm/compiler/CompilerIR.h b/vm/compiler/CompilerIR.h
index 6ffdf44..67cb637 100644
--- a/vm/compiler/CompilerIR.h
+++ b/vm/compiler/CompilerIR.h
@@ -28,6 +28,13 @@
     EXCEPTION_HANDLING,
 } BBType;
 
+typedef struct ChainCellCounts {
+    union {
+        u1 count[CHAINING_CELL_LAST];
+        u4 dummyForAlignment;
+    } u;
+} ChainCellCounts;
+
 typedef struct LIR {
     int offset;
     struct LIR *next;
diff --git a/vm/compiler/codegen/armv5te/Assemble.c b/vm/compiler/codegen/armv5te/Assemble.c
index 14355cb..baa6ced 100644
--- a/vm/compiler/codegen/armv5te/Assemble.c
+++ b/vm/compiler/codegen/armv5te/Assemble.c
@@ -216,9 +216,9 @@
 #define PADDING_MOV_R0_R0               0x1C00
 
 /* Write the numbers in the literal pool to the codegen stream */
-static void writeDataContent(CompilationUnit *cUnit)
+static void installDataContent(CompilationUnit *cUnit)
 {
-    int *dataPtr = (int *) (cUnit->codeBuffer + cUnit->dataOffset);
+    int *dataPtr = (int *) (cUnit->baseAddr + cUnit->dataOffset);
     Armv5teLIR *dataLIR = (Armv5teLIR *) cUnit->wordList;
     while (dataLIR) {
         *dataPtr++ = dataLIR->operands[0];
@@ -226,6 +226,17 @@
     }
 }
 
+/* Returns the size of a Jit trace description */
+static int jitTraceDescriptionSize(const JitTraceDescription *desc)
+{
+    int runCount;
+    for (runCount = 0; ; runCount++) {
+        if (desc->trace[runCount].frag.runEnd)
+           break;
+    }
+    return sizeof(JitCodeDesc) + ((runCount+1) * sizeof(JitTraceRun));
+}
+
 /* Return TRUE if error happens */
 static bool assembleInstructions(CompilationUnit *cUnit, intptr_t startAddr)
 {
@@ -383,19 +394,58 @@
 }
 
 /*
+ * Translation layout in the code cache.  Note that the codeAddress pointer
+ * in JitTable will point directly to the code body (field codeAddress).  The
+ * chain cell offset codeAddress - 2, and (if present) executionCount is at
+ * codeAddress - 6.
+ *
+ *      +----------------------------+
+ *      | Execution count            |  -> [Optional] 4 bytes
+ *      +----------------------------+
+ *   +--| Offset to chain cell counts|  -> 2 bytes
+ *   |  +----------------------------+
+ *   |  | Code body                  |  -> Start address for translation
+ *   |  |                            |     variable in 2-byte chunks
+ *   |  .                            .     (JitTable's codeAddress points here)
+ *   |  .                            .
+ *   |  |                            |
+ *   |  +----------------------------+
+ *   |  | Chaining Cells             |  -> 8 bytes each, must be 4 byte aligned
+ *   |  .                            .
+ *   |  .                            .
+ *   |  |                            |
+ *   |  +----------------------------+
+ *   +->| Chaining cell counts       |  -> 4 bytes, chain cell counts by type
+ *      +----------------------------+
+ *      | Trace description          |  -> variable sized
+ *      .                            .
+ *      |                            |
+ *      +----------------------------+
+ *      | Literal pool               |  -> 4-byte aligned, variable size
+ *      .                            .
+ *      .                            .
+ *      |                            |
+ *      +----------------------------+
+ *
  * Go over each instruction in the list and calculate the offset from the top
  * before sending them off to the assembler. If out-of-range branch distance is
  * seen rearrange the instructions a bit to correct it.
  */
+#define CHAIN_CELL_OFFSET_SIZE 2
 void dvmCompilerAssembleLIR(CompilationUnit *cUnit)
 {
     LIR *lir;
     Armv5teLIR *armLIR;
     int offset;
     int i;
+    ChainCellCounts chainCellCounts;
+    u2 chainCellOffset;
+    int descSize = jitTraceDescriptionSize(cUnit->traceDesc);
 
 retry:
-    for (armLIR = (Armv5teLIR *) cUnit->firstLIRInsn, offset = 0;
+    /* Beginning offset needs to allow space for chain cell offset */
+    for (armLIR = (Armv5teLIR *) cUnit->firstLIRInsn,
+         offset = CHAIN_CELL_OFFSET_SIZE;
          armLIR;
          armLIR = NEXT_LIR(armLIR)) {
         armLIR->generic.offset = offset;
@@ -413,8 +463,15 @@
     }
 
     /* Const values have to be word aligned */
-    offset = ((offset + 3) >> 2) << 2;
+    offset = (offset + 3) & ~3;
 
+    /* Add space for chain cell counts & trace description */
+    chainCellOffset = offset;
+    offset += sizeof(chainCellCounts) + descSize;
+
+    assert((offset & 0x3) == 0);  /* Should still be word aligned */
+
+    /* Set up offsets for literals */
     cUnit->dataOffset = offset;
 
     for (lir = cUnit->wordList; lir; lir = lir->next) {
@@ -424,12 +481,14 @@
 
     cUnit->totalSize = offset;
 
-    if (gDvmJit.codeCacheByteUsed + offset > CODE_CACHE_SIZE) {
+    if (gDvmJit.codeCacheByteUsed + cUnit->totalSize > CODE_CACHE_SIZE) {
         gDvmJit.codeCacheFull = true;
         cUnit->baseAddr = NULL;
         return;
     }
-    cUnit->codeBuffer = dvmCompilerNew(offset, true);
+
+    /* Allocate enough space for the code block */
+    cUnit->codeBuffer = dvmCompilerNew(chainCellOffset, true);
     if (cUnit->codeBuffer == NULL) {
         LOGE("Code buffer allocation failure\n");
         cUnit->baseAddr = NULL;
@@ -442,19 +501,36 @@
     if (needRetry)
         goto retry;
 
-    writeDataContent(cUnit);
-
     cUnit->baseAddr = (char *) gDvmJit.codeCache + gDvmJit.codeCacheByteUsed;
     gDvmJit.codeCacheByteUsed += offset;
 
+    /* Install the chain cell offset */
+    *((char*)cUnit->baseAddr) = chainCellOffset;
 
-    /* Install the compilation */
-    memcpy(cUnit->baseAddr, cUnit->codeBuffer, offset);
+    /* Install the code block */
+    memcpy((char*)cUnit->baseAddr + 2, cUnit->codeBuffer, chainCellOffset - 2);
     gDvmJit.numCompilations++;
 
+    /* Install the chaining cell counts */
+    for (i=0; i< CHAINING_CELL_LAST; i++) {
+        chainCellCounts.u.count[i] = cUnit->numChainingCells[i];
+    }
+    memcpy((char*)cUnit->baseAddr + chainCellOffset, &chainCellCounts,
+           sizeof(chainCellCounts));
+
+    /* Install the trace description */
+    memcpy((char*)cUnit->baseAddr + chainCellOffset + sizeof(chainCellCounts),
+           cUnit->traceDesc, descSize);
+
+    /* Write the literals directly into the code cache */
+    installDataContent(cUnit);
+
     /* Flush dcache and invalidate the icache to maintain coherence */
-    cacheflush((intptr_t) cUnit->baseAddr,
-               (intptr_t) (cUnit->baseAddr + offset), 0);
+    cacheflush((long)cUnit->baseAddr,
+               (long)(cUnit->baseAddr + offset), 0);
+
+    /* Adjust baseAddr to point to executable code */
+    cUnit->baseAddr = (char*)cUnit->baseAddr + CHAIN_CELL_OFFSET_SIZE;
 }
 
 /*
@@ -466,7 +542,8 @@
  * Where HH is 10 for the 1st inst, and 11 for the second and
  * the "o" field is each instruction's 11-bit contribution to the
  * 22-bit branch offset.
- * TUNING: use a single-instruction variant if it reaches.
+ * If the target is nearby, use a single-instruction bl.
+ * If one or more threads is suspended, don't chain.
  */
 void* dvmJitChain(void* tgtAddr, u4* branchAddr)
 {
@@ -476,24 +553,117 @@
     u4 thumb2;
     u4 newInst;
 
-    assert((branchOffset >= -(1<<22)) && (branchOffset <= ((1<<22)-2)));
+    if (gDvm.sumThreadSuspendCount == 0) {
+        assert((branchOffset >= -(1<<22)) && (branchOffset <= ((1<<22)-2)));
 
-    gDvmJit.translationChains++;
+        gDvmJit.translationChains++;
 
-    COMPILER_TRACE_CHAINING(
-        LOGD("Jit Runtime: chaining 0x%x to 0x%x\n",
-             (int) branchAddr, (int) tgtAddr & -2));
-    if ((branchOffset < -2048) | (branchOffset > 2046)) {
-        thumb1 =  (0xf000 | ((branchOffset>>12) & 0x7ff));
-        thumb2 =  (0xf800 | ((branchOffset>> 1) & 0x7ff));
-    } else {
-        thumb1 =  (0xe000 | ((branchOffset>> 1) & 0x7ff));
-        thumb2 =  0x4300;  /* nop -> or r0, r0 */
+        COMPILER_TRACE_CHAINING(
+            LOGD("Jit Runtime: chaining 0x%x to 0x%x\n",
+                 (int) branchAddr, (int) tgtAddr & -2));
+        if ((branchOffset < -2048) | (branchOffset > 2046)) {
+            thumb1 =  (0xf000 | ((branchOffset>>12) & 0x7ff));
+            thumb2 =  (0xf800 | ((branchOffset>> 1) & 0x7ff));
+        } else {
+            thumb1 =  (0xe000 | ((branchOffset>> 1) & 0x7ff));
+            thumb2 =  0x4300;  /* nop -> or r0, r0 */
+        }
+
+        newInst = thumb2<<16 | thumb1;
+        *branchAddr = newInst;
+        cacheflush((long)branchAddr, (long)branchAddr + 4, 0);
     }
 
-    newInst = thumb2<<16 | thumb1;
-    *branchAddr = newInst;
-    cacheflush((intptr_t) branchAddr, (intptr_t) branchAddr + 4, 0);
-
     return tgtAddr;
 }
+
+/*
+ * Unchain a trace given the starting address of the translation
+ * in the code cache.  Refer to the diagram in dvmCompilerAssembleLIR.
+ * Returns the address following the last cell unchained.  Note that
+ * the incoming codeAddr is a thumb code address, and therefore has
+ * the low bit set.
+ */
+u4* dvmJitUnchain(void* codeAddr)
+{
+    u2* pChainCellOffset = (u2*)((char*)codeAddr - 3);
+    u2 chainCellOffset = *pChainCellOffset;
+    ChainCellCounts *pChainCellCounts =
+          (ChainCellCounts*)((char*)codeAddr + chainCellOffset -3);
+    int cellCount;
+    u4* pChainCells;
+    u4* pStart;
+    u4 thumb1;
+    u4 thumb2;
+    u4 newInst;
+    int i,j;
+
+    /* Get total count of chain cells */
+    for (i = 0, cellCount = 0; i < CHAINING_CELL_LAST; i++) {
+        cellCount += pChainCellCounts->u.count[i];
+    }
+
+    /* Locate the beginning of the chain cell region */
+    pStart = pChainCells = (u4*)((char*)pChainCellCounts - (cellCount * 8));
+
+    /* The cells are sorted in order - walk through them and reset */
+    for (i = 0; i < CHAINING_CELL_LAST; i++) {
+        for (j = 0; j < pChainCellCounts->u.count[i]; j++) {
+            int targetOffset;
+            switch(i) {
+                case CHAINING_CELL_GENERIC:
+                    targetOffset = offsetof(InterpState,
+                          jitToInterpEntries.dvmJitToInterpNormal);
+                    break;
+                case CHAINING_CELL_POST_INVOKE:
+                case CHAINING_CELL_INVOKE:
+                    targetOffset = offsetof(InterpState,
+                          jitToInterpEntries.dvmJitToTraceSelect);
+                    break;
+                default:
+                    dvmAbort();
+            }
+            /*
+             * Arm code sequence for a chaining cell is:
+             *     ldr  r0, rGLUE, #<word offset>
+             *     blx  r0
+             */
+            COMPILER_TRACE_CHAINING(
+                LOGD("Jit Runtime: unchaining 0x%x", (int)pChainCells));
+            targetOffset = targetOffset >> 2;  /* convert to word offset */
+            thumb1 = 0x6800 | (targetOffset << 6) | (rGLUE << 3) | (r0 << 0);
+            thumb2 = 0x4780 | (r0 << 3);
+            newInst = thumb2<<16 | thumb1;
+            *pChainCells = newInst;
+            pChainCells += 2;  /* Advance by 2 words */
+        }
+    }
+    return pChainCells;
+}
+
+/* Unchain all translation in the cache. */
+void dvmJitUnchainAll()
+{
+    u4* lowAddress = NULL;
+    u4* highAddress = NULL;
+    unsigned int i;
+    if (gDvmJit.pJitEntryTable != NULL) {
+        COMPILER_TRACE_CHAINING(LOGD("Jit Runtime: unchaining all"));
+        dvmLockMutex(&gDvmJit.tableLock);
+        for (i = 0; i < gDvmJit.maxTableEntries; i++) {
+            if (gDvmJit.pJitEntryTable[i].dPC &&
+                   gDvmJit.pJitEntryTable[i].codeAddress) {
+                u4* lastAddress;
+                lastAddress =
+                      dvmJitUnchain(gDvmJit.pJitEntryTable[i].codeAddress);
+                if (lowAddress == NULL ||
+                      (u4*)gDvmJit.pJitEntryTable[i].codeAddress < lowAddress)
+                    lowAddress = lastAddress;
+                if (lastAddress > highAddress)
+                    highAddress = lastAddress;
+            }
+        }
+        cacheflush((long)lowAddress, (long)highAddress, 0);
+        dvmUnlockMutex(&gDvmJit.tableLock);
+    }
+}