diff --git a/pkg/analysis_server/test/services/completion/dart/arglist_contributor_test.dart b/pkg/analysis_server/test/services/completion/dart/arglist_contributor_test.dart
index 7ed981d..fc2016f 100644
--- a/pkg/analysis_server/test/services/completion/dart/arglist_contributor_test.dart
+++ b/pkg/analysis_server/test/services/completion/dart/arglist_contributor_test.dart
@@ -882,16 +882,15 @@
     check();
 
     // This constructor invocation.
-    // TODO(scheglov) implement
-//     addTestSource2('''
-// $languageVersionLine
-// class A {
-//   A$parameters;
-//   A.named() : this$arguments;
-// }
-// ''');
-//     await computeSuggestions();
-//     check();
+    addTestSource2('''
+$languageVersionLine
+class A {
+  A$parameters;
+  A.named() : this$arguments;
+}
+''');
+    await computeSuggestions();
+    check();
 
     // Invalid: getter invocation.
     // Parameters not used. Check not used.
diff --git a/pkg/analyzer_plugin/lib/src/utilities/completion/completion_target.dart b/pkg/analyzer_plugin/lib/src/utilities/completion/completion_target.dart
index 77ea08e..24e9359 100644
--- a/pkg/analyzer_plugin/lib/src/utilities/completion/completion_target.dart
+++ b/pkg/analyzer_plugin/lib/src/utilities/completion/completion_target.dart
@@ -286,6 +286,8 @@
         executable = invocation.constructorName.staticElement;
       } else if (invocation is MethodInvocation) {
         executable = invocation.methodName.staticElement;
+      } else if (invocation is RedirectingConstructorInvocation) {
+        executable = invocation.staticElement;
       } else if (invocation is SuperConstructorInvocation) {
         executable = invocation.staticElement;
       }
diff --git a/runtime/vm/compiler/assembler/assembler_arm64_test.cc b/runtime/vm/compiler/assembler/assembler_arm64_test.cc
index a54fe57..f934e32 100644
--- a/runtime/vm/compiler/assembler/assembler_arm64_test.cc
+++ b/runtime/vm/compiler/assembler/assembler_arm64_test.cc
@@ -15,6 +15,13 @@
 namespace compiler {
 #define __ assembler->
 
+#if defined(PRODUCT)
+#define EXPECT_DISASSEMBLY(expected)
+#else
+#define EXPECT_DISASSEMBLY(expected)                                           \
+  EXPECT_STREQ(expected, test->RelativeDisassembly())
+#endif
+
 ASSEMBLER_TEST_GENERATE(Simple, assembler) {
   __ add(R0, ZR, Operand(ZR));
   __ add(R0, R0, Operand(42));
@@ -1108,6 +1115,123 @@
 #undef FOR_EACH_LSR_32_TESTS_LIST
 #undef FOR_EACH_ASR_32_TESTS_LIST
 
+ASSEMBLER_TEST_GENERATE(LslImmediate, assembler) {
+  __ LslImmediate(R0, R0, 1);
+  __ LslImmediate(R0, R0, 2);
+  __ LslImmediate(R0, R0, 3);
+  __ LslImmediate(R0, R0, 4);
+  __ LslImmediate(R0, R0, 60);
+  __ LslImmediate(R0, R0, 61);
+  __ LslImmediate(R0, R0, 62);
+  __ LslImmediate(R0, R0, 63);
+  __ LslImmediate(R0, R0, 1, kFourBytes);
+  __ LslImmediate(R0, R0, 2, kFourBytes);
+  __ LslImmediate(R0, R0, 3, kFourBytes);
+  __ LslImmediate(R0, R0, 4, kFourBytes);
+  __ LslImmediate(R0, R0, 28, kFourBytes);
+  __ LslImmediate(R0, R0, 29, kFourBytes);
+  __ LslImmediate(R0, R0, 30, kFourBytes);
+  __ LslImmediate(R0, R0, 31, kFourBytes);
+}
+
+ASSEMBLER_TEST_RUN(LslImmediate, test) {
+  EXPECT_DISASSEMBLY(
+      "lsl r0, r0, #1\n"
+      "lsl r0, r0, #2\n"
+      "lsl r0, r0, #3\n"
+      "lsl r0, r0, #4\n"
+      "lsl r0, r0, #60\n"
+      "lsl r0, r0, #61\n"
+      "lsl r0, r0, #62\n"
+      "lsl r0, r0, #63\n"
+      "lslw r0, r0, #1\n"
+      "lslw r0, r0, #2\n"
+      "lslw r0, r0, #3\n"
+      "lslw r0, r0, #4\n"
+      "lslw r0, r0, #28\n"
+      "lslw r0, r0, #29\n"
+      "lslw r0, r0, #30\n"
+      "lslw r0, r0, #31\n");
+}
+
+ASSEMBLER_TEST_GENERATE(LsrImmediate, assembler) {
+  __ LsrImmediate(R0, R0, 1);
+  __ LsrImmediate(R0, R0, 2);
+  __ LsrImmediate(R0, R0, 3);
+  __ LsrImmediate(R0, R0, 4);
+  __ LsrImmediate(R0, R0, 60);
+  __ LsrImmediate(R0, R0, 61);
+  __ LsrImmediate(R0, R0, 62);
+  __ LsrImmediate(R0, R0, 63);
+  __ LsrImmediate(R0, R0, 1, kFourBytes);
+  __ LsrImmediate(R0, R0, 2, kFourBytes);
+  __ LsrImmediate(R0, R0, 3, kFourBytes);
+  __ LsrImmediate(R0, R0, 4, kFourBytes);
+  __ LsrImmediate(R0, R0, 28, kFourBytes);
+  __ LsrImmediate(R0, R0, 29, kFourBytes);
+  __ LsrImmediate(R0, R0, 30, kFourBytes);
+  __ LsrImmediate(R0, R0, 31, kFourBytes);
+}
+
+ASSEMBLER_TEST_RUN(LsrImmediate, test) {
+  EXPECT_DISASSEMBLY(
+      "lsr r0, r0, #1\n"
+      "lsr r0, r0, #2\n"
+      "lsr r0, r0, #3\n"
+      "lsr r0, r0, #4\n"
+      "lsr r0, r0, #60\n"
+      "lsr r0, r0, #61\n"
+      "lsr r0, r0, #62\n"
+      "lsr r0, r0, #63\n"
+      "lsrw r0, r0, #1\n"
+      "lsrw r0, r0, #2\n"
+      "lsrw r0, r0, #3\n"
+      "lsrw r0, r0, #4\n"
+      "lsrw r0, r0, #28\n"
+      "lsrw r0, r0, #29\n"
+      "lsrw r0, r0, #30\n"
+      "lsrw r0, r0, #31\n");
+}
+
+ASSEMBLER_TEST_GENERATE(AsrImmediate, assembler) {
+  __ AsrImmediate(R0, R0, 1);
+  __ AsrImmediate(R0, R0, 2);
+  __ AsrImmediate(R0, R0, 3);
+  __ AsrImmediate(R0, R0, 4);
+  __ AsrImmediate(R0, R0, 60);
+  __ AsrImmediate(R0, R0, 61);
+  __ AsrImmediate(R0, R0, 62);
+  __ AsrImmediate(R0, R0, 63);
+  __ AsrImmediate(R0, R0, 1, kFourBytes);
+  __ AsrImmediate(R0, R0, 2, kFourBytes);
+  __ AsrImmediate(R0, R0, 3, kFourBytes);
+  __ AsrImmediate(R0, R0, 4, kFourBytes);
+  __ AsrImmediate(R0, R0, 28, kFourBytes);
+  __ AsrImmediate(R0, R0, 29, kFourBytes);
+  __ AsrImmediate(R0, R0, 30, kFourBytes);
+  __ AsrImmediate(R0, R0, 31, kFourBytes);
+}
+
+ASSEMBLER_TEST_RUN(AsrImmediate, test) {
+  EXPECT_DISASSEMBLY(
+      "asr r0, r0, #1\n"
+      "asr r0, r0, #2\n"
+      "asr r0, r0, #3\n"
+      "asr r0, r0, #4\n"
+      "asr r0, r0, #60\n"
+      "asr r0, r0, #61\n"
+      "asr r0, r0, #62\n"
+      "asr r0, r0, #63\n"
+      "asrw r0, r0, #1\n"
+      "asrw r0, r0, #2\n"
+      "asrw r0, r0, #3\n"
+      "asrw r0, r0, #4\n"
+      "asrw r0, r0, #28\n"
+      "asrw r0, r0, #29\n"
+      "asrw r0, r0, #30\n"
+      "asrw r0, r0, #31\n");
+}
+
 ASSEMBLER_TEST_GENERATE(AndShiftRegs, assembler) {
   __ movz(R1, Immediate(42), 0);
   __ movz(R2, Immediate(21), 0);
diff --git a/runtime/vm/compiler/assembler/assembler_ia32_test.cc b/runtime/vm/compiler/assembler/assembler_ia32_test.cc
index 4f98613..43c4818 100644
--- a/runtime/vm/compiler/assembler/assembler_ia32_test.cc
+++ b/runtime/vm/compiler/assembler/assembler_ia32_test.cc
@@ -15,7 +15,7 @@
 #define EXPECT_DISASSEMBLY(expected)
 #else
 #define EXPECT_DISASSEMBLY(expected)                                           \
-  EXPECT_STREQ(expected, test->BlankedDisassembly())
+  EXPECT_STREQ(expected, test->RelativeDisassembly())
 #endif
 
 namespace dart {
@@ -119,12 +119,12 @@
       "mov eax,[esp-0x4]\n"
       "mov eax,[ebp-0x4]\n"
       "mov eax,[eax-0x4]\n"
-      "mov eax,[esp+0x...]\n"
-      "mov eax,[ebp+0x...]\n"
-      "mov eax,[eax+0x...]\n"
-      "mov eax,[esp-0x...]\n"
-      "mov eax,[ebp-0x...]\n"
-      "mov eax,[eax-0x...]\n"
+      "mov eax,[esp+0x400]\n"
+      "mov eax,[ebp+0x400]\n"
+      "mov eax,[eax+0x400]\n"
+      "mov eax,[esp-0x400]\n"
+      "mov eax,[ebp-0x400]\n"
+      "mov eax,[eax-0x400]\n"
       "mov eax,[eax]\n"
       "mov eax,[eax+0x1]\n"
       "mov eax,[eax+0x2]\n"
@@ -133,8 +133,8 @@
       "mov eax,[eax+0x1]\n"
       "mov eax,[ebp*2+0x4]\n"
       "mov eax,[eax*2+0x4]\n"
-      "mov eax,[ebp*2+0x...]\n"
-      "mov eax,[eax*2+0x...]\n"
+      "mov eax,[ebp*2+0x400]\n"
+      "mov eax,[eax*2+0x400]\n"
       "mov eax,[eax+ebp*2]\n"
       "mov eax,[eax+eax*2]\n"
       "mov eax,[ebp+ebp*2+0]\n"
@@ -147,12 +147,12 @@
       "mov eax,[ebp+eax*2+0x4]\n"
       "mov eax,[esp+ebp*2+0x4]\n"
       "mov eax,[esp+eax*2+0x4]\n"
-      "mov eax,[eax+ebp*2+0x...]\n"
-      "mov eax,[eax+eax*2+0x...]\n"
-      "mov eax,[ebp+ebp*2+0x...]\n"
-      "mov eax,[ebp+eax*2+0x...]\n"
-      "mov eax,[esp+ebp*2+0x...]\n"
-      "mov eax,[esp+eax*2+0x...]\n");
+      "mov eax,[eax+ebp*2+0x400]\n"
+      "mov eax,[eax+eax*2+0x400]\n"
+      "mov eax,[ebp+ebp*2+0x400]\n"
+      "mov eax,[ebp+eax*2+0x400]\n"
+      "mov eax,[esp+ebp*2+0x400]\n"
+      "mov eax,[esp+eax*2+0x400]\n");
 }
 
 ASSEMBLER_TEST_GENERATE(JumpAroundCrash, assembler) {
@@ -180,23 +180,23 @@
   typedef void (*JumpAroundCrashCode)();
   reinterpret_cast<JumpAroundCrashCode>(test->entry())();
   EXPECT_DISASSEMBLY(
-      "jo 0x........\n"
-      "jno 0x........\n"
-      "jc 0x........\n"
-      "jnc 0x........\n"
-      "jz 0x........\n"
-      "jnz 0x........\n"
-      "jna 0x........\n"
-      "ja 0x........\n"
-      "js 0x........\n"
-      "jns 0x........\n"
-      "jpe 0x........\n"
-      "jpo 0x........\n"
-      "jl 0x........\n"
-      "jge 0x........\n"
-      "jle 0x........\n"
-      "jg 0x........\n"
-      "jmp 0x........\n"
+      "jo +108\n"
+      "jno +102\n"
+      "jc +96\n"
+      "jnc +90\n"
+      "jz +84\n"
+      "jnz +78\n"
+      "jna +72\n"
+      "ja +66\n"
+      "js +60\n"
+      "jns +54\n"
+      "jpe +48\n"
+      "jpo +42\n"
+      "jl +36\n"
+      "jge +30\n"
+      "jle +24\n"
+      "jg +18\n"
+      "jmp +12\n"
       "mov eax,0\n"
       "mov [eax],eax\n"
       "ret\n");
@@ -225,23 +225,23 @@
   typedef void (*NearJumpAroundCrashCode)();
   reinterpret_cast<NearJumpAroundCrashCode>(test->entry())();
   EXPECT_DISASSEMBLY(
-      "jo 0x........\n"
-      "jno 0x........\n"
-      "jc 0x........\n"
-      "jnc 0x........\n"
-      "jz 0x........\n"
-      "jnz 0x........\n"
-      "jna 0x........\n"
-      "ja 0x........\n"
-      "js 0x........\n"
-      "jns 0x........\n"
-      "jpe 0x........\n"
-      "jpo 0x........\n"
-      "jl 0x........\n"
-      "jge 0x........\n"
-      "jle 0x........\n"
-      "jg 0x........\n"
-      "jmp 0x........\n"
+      "jo +41\n"
+      "jno +39\n"
+      "jc +37\n"
+      "jnc +35\n"
+      "jz +33\n"
+      "jnz +31\n"
+      "jna +29\n"
+      "ja +27\n"
+      "js +25\n"
+      "jns +23\n"
+      "jpe +21\n"
+      "jpo +19\n"
+      "jl +17\n"
+      "jge +15\n"
+      "jle +13\n"
+      "jg +11\n"
+      "jmp +9\n"
       "mov eax,0\n"
       "mov [eax],eax\n"
       "ret\n");
@@ -268,7 +268,7 @@
       "add eax,2\n"
       "inc ecx\n"
       "cmp ecx,0x57\n"
-      "jl 0x........\n"
+      "jl -7\n"
       "ret\n");
 }
 
@@ -289,9 +289,9 @@
   EXPECT_EQ(1, reinterpret_cast<CmpbCode>(test->entry())());
   EXPECT_DISASSEMBLY(
       "mov eax,1\n"
-      "push 0x........\n"
+      "push 0xffffff11\n"
       "cmpb [esp],0x11\n"
-      "jz 0x........\n"
+      "jz +7\n"
       "mov eax,0\n"
       "pop ecx\n"
       "ret\n");
@@ -317,7 +317,7 @@
   EXPECT_DISASSEMBLY(
       "mov eax,1\n"
       "mov ecx,0\n"
-      "push 0x........\n"
+      "push 0xffffff11\n"
       "testb [esp],0x10\n"
       "cmovz eax,ecx\n"
       "testb [esp],0x20\n"
@@ -372,7 +372,7 @@
   typedef int (*PopcntCode)();
   EXPECT_EQ(36, reinterpret_cast<PopcntCode>(test->entry())());
   EXPECT_DISASSEMBLY(
-      "mov ecx,0x........\n"
+      "mov ecx,0xffffffff\n"
       "popcnt eax,ecx\n"
       "mov ecx,0xf\n"
       "popcnt ecx,ecx\n"
@@ -396,7 +396,7 @@
   typedef int (*LzcntCode)();
   EXPECT_EQ(44, reinterpret_cast<LzcntCode>(test->entry())());
   EXPECT_DISASSEMBLY(
-      "mov ecx,0x...\n"
+      "mov ecx,0xf00\n"
       "lzcnt eax,ecx\n"
       "mov ecx,0xf0\n"
       "lzcnt ecx,ecx\n"
@@ -536,7 +536,7 @@
       "mov eax,2\n"
       "mov ecx,4\n"
       "imul eax,ecx\n"
-      "imul eax,eax,0x...\n"
+      "imul eax,eax,0x3e8\n"
       "ret\n");
 }
 
@@ -554,8 +554,8 @@
   EXPECT_EQ(0, reinterpret_cast<OverflowSignedMultiply>(test->entry())());
   EXPECT_DISASSEMBLY(
       "mov edx,0\n"
-      "mov eax,0x........\n"
-      "mov ecx,0x........\n"
+      "mov eax,0x0fffffff\n"
+      "mov ecx,0x0fffffff\n"
       "imul eax,ecx\n"
       "imul eax,edx\n"
       "ret\n");
@@ -580,7 +580,7 @@
       "mov ebx,2\n"
       "mov ecx,4\n"
       "imul ebx,ecx\n"
-      "imul ebx,ebx,0x...\n"
+      "imul ebx,ebx,0x3e8\n"
       "mov eax,ebx\n"
       "pop ebx\n"
       "ret\n");
@@ -622,7 +622,7 @@
   EXPECT_EQ(31, call(-1));
   EXPECT_DISASSEMBLY(
       "mov ecx,[esp+0x4]\n"
-      "mov eax,0x...\n"
+      "mov eax,0x29a\n"
       "bsr eax,ecx\n"
       "ret\n");
 }
@@ -644,7 +644,7 @@
   EXPECT_EQ(0xff - 1 + 0xffff, reinterpret_cast<MoveExtend>(test->entry())());
   EXPECT_DISASSEMBLY(
       "push ebx\n"
-      "mov edx,0x........\n"
+      "mov edx,0x1234ffff\n"
       "movzxb eax,edx\n"
       "movsxw ebx,edx\n"
       "movzxw ecx,edx\n"
@@ -676,7 +676,7 @@
             reinterpret_cast<MoveExtendMemory>(test->entry())());
   EXPECT_DISASSEMBLY(
       "push ebx\n"
-      "mov edx,0x........\n"
+      "mov edx,0x1234ffff\n"
       "push edx\n"
       "movzxb eax,[esp]\n"
       "movsxw ebx,[esp]\n"
@@ -724,12 +724,12 @@
   EXPECT_DISASSEMBLY(
       "mov ecx,0x2a\n"
       "xor ecx,ecx\n"
-      "or ecx,0x...\n"
-      "mov eax,0x...\n"
+      "or ecx,0x100\n"
+      "mov eax,0x648\n"
       "or ecx,eax\n"
-      "mov eax,0x....\n"
+      "mov eax,0xfff0\n"
       "and ecx,eax\n"
-      "push 0x....\n"
+      "push 0xf6ff\n"
       "and ecx,[esp]\n"
       "pop eax\n"
       "mov eax,1\n"
@@ -943,121 +943,121 @@
       "mov eax,4\n"
       "and eax,2\n"
       "cmp eax,0\n"
-      "jz 0x........\n"
+      "jz +13\n"
       "mov eax,0\n"
       "mov [eax],eax\n"
       "mov ecx,4\n"
       "and ecx,4\n"
       "cmp ecx,0\n"
-      "jnz 0x........\n"
+      "jnz +13\n"
       "mov eax,0\n"
       "mov [eax],eax\n"
       "mov eax,0\n"
       "or eax,0\n"
       "cmp eax,0\n"
-      "jz 0x........\n"
+      "jz +13\n"
       "mov eax,0\n"
       "mov [eax],eax\n"
       "mov eax,4\n"
       "or eax,0\n"
       "cmp eax,0\n"
-      "jnz 0x........\n"
+      "jnz +13\n"
       "mov eax,0\n"
       "mov [eax],eax\n"
       "mov eax,1\n"
       "shl eax,1\n"
       "cmp eax,2\n"
-      "jz 0x........\n"
+      "jz +13\n"
       "mov eax,0\n"
       "mov [eax],eax\n"
       "mov eax,1\n"
       "shl eax,3\n"
       "cmp eax,8\n"
-      "jz 0x........\n"
+      "jz +13\n"
       "mov eax,0\n"
       "mov [eax],eax\n"
       "mov eax,2\n"
       "shr eax,1\n"
       "cmp eax,1\n"
-      "jz 0x........\n"
+      "jz +13\n"
       "mov eax,0\n"
       "mov [eax],eax\n"
       "mov eax,8\n"
       "shr eax,3\n"
       "cmp eax,1\n"
-      "jz 0x........\n"
+      "jz +13\n"
       "mov eax,0\n"
       "mov [eax],eax\n"
       "mov eax,1\n"
       "mov ecx,3\n"
       "shl eax,cl\n"
       "cmp eax,8\n"
-      "jz 0x........\n"
+      "jz +13\n"
       "mov eax,0\n"
       "mov [eax],eax\n"
       "mov eax,8\n"
       "mov ecx,3\n"
       "shr eax,cl\n"
       "cmp eax,1\n"
-      "jz 0x........\n"
+      "jz +13\n"
       "mov eax,0\n"
       "mov [eax],eax\n"
       "mov eax,1\n"
       "shl eax,31\n"
       "shr eax,3\n"
-      "cmp eax,0x........\n"
-      "jz 0x........\n"
+      "cmp eax,0x10000000\n"
+      "jz +13\n"
       "mov eax,0\n"
       "mov [eax],eax\n"
       "mov eax,1\n"
       "shl eax,31\n"
       "sar eax,3\n"
-      "cmp eax,0x........\n"
-      "jz 0x........\n"
+      "cmp eax,0xf0000000\n"
+      "jz +13\n"
       "mov eax,0\n"
       "mov [eax],eax\n"
       "mov eax,1\n"
       "mov ecx,3\n"
       "shl eax,31\n"
       "sar eax,cl\n"
-      "cmp eax,0x........\n"
-      "jz 0x........\n"
+      "cmp eax,0xf0000000\n"
+      "jz +13\n"
       "mov eax,0\n"
       "mov [eax],eax\n"
       "sub esp,4\n"
-      "mov [esp],-0x........\n"
+      "mov [esp],-0x80000000\n"
       "mov eax,0\n"
       "mov ecx,3\n"
       "sar [esp],cl\n"
       "shrd [esp],eax,cl\n"
-      "cmp [esp],0x........\n"
-      "jz 0x........\n"
+      "cmp [esp],0x1e000000\n"
+      "jz +7\n"
       "int3\n"
       "add esp,4\n"
       "sub esp,4\n"
-      "mov [esp],-0x........\n"
-      "mov eax,0x........\n"
+      "mov [esp],-0x01000000\n"
+      "mov eax,0xffffffff\n"
       "mov ecx,2\n"
       "shl [esp],cl\n"
       "shld [esp],eax,cl\n"
-      "cmp [esp],0x........\n"
-      "jz 0x........\n"
+      "cmp [esp],0xf0000003\n"
+      "jz +7\n"
       "int3\n"
       "add esp,4\n"
-      "mov edx,0x........\n"
+      "mov edx,0x80000000\n"
       "mov eax,0\n"
       "mov ecx,3\n"
       "sar edx,3\n"
       "shrd edx,eax,3\n"
-      "cmp edx,0x........\n"
-      "jz 0x........\n"
+      "cmp edx,0x1e000000\n"
+      "jz +7\n"
       "int3\n"
-      "mov edx,0x........\n"
-      "mov eax,0x........\n"
+      "mov edx,0xff000000\n"
+      "mov eax,0xffffffff\n"
       "shl edx,2\n"
       "shld edx,eax,2\n"
-      "cmp edx,0x........\n"
-      "jz 0x........\n"
+      "cmp edx,0xf0000003\n"
+      "jz +7\n"
       "int3\n"
       "mov eax,0\n"
       "ret\n");
@@ -1125,28 +1125,28 @@
       "mov eax,4\n"
       "mov ecx,2\n"
       "test eax,ecx\n"
-      "jz 0x........\n"
+      "jz +13\n"
       "mov eax,0\n"
       "mov [eax],eax\n"
       "mov edx,4\n"
       "mov ecx,4\n"
       "test edx,ecx\n"
-      "jnz 0x........\n"
+      "jnz +13\n"
       "mov eax,0\n"
       "mov [eax],eax\n"
       "mov eax,0\n"
       "test al,0\n"
-      "jz 0x........\n"
+      "jz +13\n"
       "mov eax,0\n"
       "mov [eax],eax\n"
       "mov ebx,4\n"
       "testb ebx,4\n"
-      "jnz 0x........\n"
+      "jnz +13\n"
       "mov eax,0\n"
       "mov [eax],eax\n"
       "mov ebx,0xff\n"
       "testb ebx,0xff\n"
-      "jnz 0x........\n"
+      "jnz +13\n"
       "mov eax,0\n"
       "mov [eax],eax\n"
       "mov eax,0\n"
@@ -1217,7 +1217,7 @@
   typedef int (*SignedDivide)();
   EXPECT_EQ(-87 / 42, reinterpret_cast<SignedDivide>(test->entry())());
   EXPECT_DISASSEMBLY(
-      "mov eax,0x........\n"
+      "mov eax,0xffffffa9\n"
       "mov edx,0x7b\n"
       "cdq\n"
       "mov ecx,0x2a\n"
@@ -1237,9 +1237,9 @@
   typedef int (*UnsignedDivide)();
   EXPECT_EQ(0x42, reinterpret_cast<UnsignedDivide>(test->entry())());
   EXPECT_DISASSEMBLY(
-      "mov eax,0x........\n"
+      "mov eax,0xffffffbe\n"
       "mov edx,0x41\n"
-      "mov ecx,0x........\n"
+      "mov ecx,0xffffffff\n"
       "div (eax,edx),ecx\n"
       "ret\n");
 }
@@ -1256,8 +1256,8 @@
   typedef int (*Exchange)();
   EXPECT_EQ(987654321 - 123456789, reinterpret_cast<Exchange>(test->entry())());
   EXPECT_DISASSEMBLY(
-      "mov eax,0x........\n"
-      "mov edx,0x........\n"
+      "mov eax,0x075bcd15\n"
+      "mov edx,0x3ade68b1\n"
       "xchg eax,edx\n"
       "sub eax,edx\n"
       "ret\n");
@@ -1358,7 +1358,7 @@
   float res = reinterpret_cast<SingleFPMovesCode>(test->entry())();
   EXPECT_EQ(234.0f, res);
   EXPECT_DISASSEMBLY(
-      "mov eax,0x........\n"
+      "mov eax,0x436a0000\n"
       "movd xmm0,eax\n"
       "movss ecx,xmm0\n"
       "movss edx,xmm1\n"
@@ -1397,7 +1397,7 @@
   EXPECT_DISASSEMBLY(
       "push ebx\n"
       "push ecx\n"
-      "mov ebx,0x........\n"
+      "mov ebx,0x436a0000\n"
       "movd xmm0,ebx\n"
       "movss ecx,xmm0\n"
       "movd ecx,xmm1\n"
@@ -1426,7 +1426,7 @@
   int res = reinterpret_cast<SingleFPUStackMovesCode>(test->entry())();
   EXPECT_EQ(234.0f, (bit_cast<float, int>(res)));
   EXPECT_DISASSEMBLY(
-      "mov eax,0x........\n"
+      "mov eax,0x436a0000\n"
       "push eax\n"
       "fld_s [esp]\n"
       "xor ecx,ecx\n"
@@ -1458,9 +1458,9 @@
   float res = reinterpret_cast<SingleFPOperationsCode>(test->entry())();
   EXPECT_FLOAT_EQ(14.7f, res, 0.001f);
   EXPECT_DISASSEMBLY(
-      "mov eax,0x........\n"
+      "mov eax,0x4144cccd\n"
       "movd xmm0,eax\n"
-      "mov eax,0x........\n"
+      "mov eax,0x4059999a\n"
       "movd xmm1,eax\n"
       "addss xmm0,xmm1\n"
       "mulss xmm0,xmm1\n"
@@ -1498,10 +1498,10 @@
   float res = reinterpret_cast<PackedFPOperationsCode>(test->entry())();
   EXPECT_FLOAT_EQ(14.7f, res, 0.001f);
   EXPECT_DISASSEMBLY(
-      "mov eax,0x........\n"
+      "mov eax,0x4144cccd\n"
       "movd xmm0,eax\n"
       "shufps xmm0,xmm0 [0]\n"
-      "mov eax,0x........\n"
+      "mov eax,0x4059999a\n"
       "movd xmm1,eax\n"
       "shufps xmm1,xmm1 [0]\n"
       "addps xmm0,xmm1\n"
@@ -1577,7 +1577,7 @@
   float res = reinterpret_cast<PackedFPOperations2Code>(test->entry())();
   EXPECT_FLOAT_EQ(0.0f, res, 0.001f);
   EXPECT_DISASSEMBLY(
-      "mov eax,0x........\n"
+      "mov eax,0x40800000\n"
       "movd xmm0,eax\n"
       "shufps xmm0,xmm0 [0]\n"
       "movaps xmm1,xmm0\n"
@@ -1610,10 +1610,10 @@
   uint32_t res = reinterpret_cast<PackedCompareEQCode>(test->entry())();
   EXPECT_EQ(static_cast<uword>(0x0), res);
   EXPECT_DISASSEMBLY(
-      "mov eax,0x........\n"
+      "mov eax,0x40000000\n"
       "movd xmm0,eax\n"
       "shufps xmm0,xmm0 [0]\n"
-      "mov eax,0x........\n"
+      "mov eax,0x40800000\n"
       "movd xmm1,eax\n"
       "shufps xmm1,xmm1 [0]\n"
       "cmpps xmm0,xmm1 [eq]\n"
@@ -1641,10 +1641,10 @@
   uint32_t res = reinterpret_cast<PackedCompareNEQCode>(test->entry())();
   EXPECT_EQ(static_cast<uword>(0xFFFFFFFF), res);
   EXPECT_DISASSEMBLY(
-      "mov eax,0x........\n"
+      "mov eax,0x40000000\n"
       "movd xmm0,eax\n"
       "shufps xmm0,xmm0 [0]\n"
-      "mov eax,0x........\n"
+      "mov eax,0x40800000\n"
       "movd xmm1,eax\n"
       "shufps xmm1,xmm1 [0]\n"
       "cmpps xmm0,xmm1 [neq]\n"
@@ -1672,10 +1672,10 @@
   uint32_t res = reinterpret_cast<PackedCompareLTCode>(test->entry())();
   EXPECT_EQ(static_cast<uword>(0xFFFFFFFF), res);
   EXPECT_DISASSEMBLY(
-      "mov eax,0x........\n"
+      "mov eax,0x40000000\n"
       "movd xmm0,eax\n"
       "shufps xmm0,xmm0 [0]\n"
-      "mov eax,0x........\n"
+      "mov eax,0x40800000\n"
       "movd xmm1,eax\n"
       "shufps xmm1,xmm1 [0]\n"
       "cmpps xmm0,xmm1 [lt]\n"
@@ -1703,10 +1703,10 @@
   uint32_t res = reinterpret_cast<PackedCompareLECode>(test->entry())();
   EXPECT_EQ(static_cast<uword>(0xFFFFFFFF), res);
   EXPECT_DISASSEMBLY(
-      "mov eax,0x........\n"
+      "mov eax,0x40000000\n"
       "movd xmm0,eax\n"
       "shufps xmm0,xmm0 [0]\n"
-      "mov eax,0x........\n"
+      "mov eax,0x40800000\n"
       "movd xmm1,eax\n"
       "shufps xmm1,xmm1 [0]\n"
       "cmpps xmm0,xmm1 [le]\n"
@@ -1734,10 +1734,10 @@
   uint32_t res = reinterpret_cast<PackedCompareNLTCode>(test->entry())();
   EXPECT_EQ(static_cast<uword>(0x0), res);
   EXPECT_DISASSEMBLY(
-      "mov eax,0x........\n"
+      "mov eax,0x40000000\n"
       "movd xmm0,eax\n"
       "shufps xmm0,xmm0 [0]\n"
-      "mov eax,0x........\n"
+      "mov eax,0x40800000\n"
       "movd xmm1,eax\n"
       "shufps xmm1,xmm1 [0]\n"
       "cmpps xmm0,xmm1 [nlt]\n"
@@ -1765,10 +1765,10 @@
   uint32_t res = reinterpret_cast<PackedCompareNLECode>(test->entry())();
   EXPECT_EQ(static_cast<uword>(0x0), res);
   EXPECT_DISASSEMBLY(
-      "mov eax,0x........\n"
+      "mov eax,0x40000000\n"
       "movd xmm0,eax\n"
       "shufps xmm0,xmm0 [0]\n"
-      "mov eax,0x........\n"
+      "mov eax,0x40800000\n"
       "movd xmm1,eax\n"
       "shufps xmm1,xmm1 [0]\n"
       "cmpps xmm0,xmm1 [nle]\n"
@@ -1798,10 +1798,10 @@
   float res = reinterpret_cast<PackedNegateCode>(test->entry())();
   EXPECT_FLOAT_EQ(-12.3f, res, 0.001f);
   EXPECT_DISASSEMBLY(
-      "mov eax,0x........\n"
+      "mov eax,0x4144cccd\n"
       "movd xmm0,eax\n"
       "shufps xmm0,xmm0 [0]\n"
-      "xorps xmm0,[rip+0x.......]\n"
+      "xorps xmm0,[0x.......]\n"
       "shufps xmm0,xmm0 [aa]\n"
       "push eax\n"
       "movss [esp],xmm0\n"
@@ -1829,10 +1829,10 @@
   float res = reinterpret_cast<PackedAbsoluteCode>(test->entry())();
   EXPECT_FLOAT_EQ(15.3f, res, 0.001f);
   EXPECT_DISASSEMBLY(
-      "mov eax,0x........\n"
+      "mov eax,0xc174cccd\n"
       "movd xmm0,eax\n"
       "shufps xmm0,xmm0 [0]\n"
-      "andps xmm0,[rip+0x.......]\n"
+      "andps xmm0,[0x.......]\n"
       "shufps xmm0,xmm0 [aa]\n"
       "push eax\n"
       "movss [esp],xmm0\n"
@@ -1858,10 +1858,10 @@
   float res = reinterpret_cast<PackedSetWZeroCode>(test->entry())();
   EXPECT_FLOAT_EQ(0.0f, res, 0.001f);
   EXPECT_DISASSEMBLY(
-      "mov eax,0x........\n"
+      "mov eax,0x4144cccd\n"
       "movd xmm0,eax\n"
       "shufps xmm0,xmm0 [0]\n"
-      "andps xmm0,[rip+0x.......]\n"
+      "andps xmm0,[0x.......]\n"
       "shufps xmm0,xmm0 [ff]\n"
       "push eax\n"
       "movss [esp],xmm0\n"
@@ -1887,10 +1887,10 @@
   float res = reinterpret_cast<PackedMinCode>(test->entry())();
   EXPECT_FLOAT_EQ(2.0f, res, 0.001f);
   EXPECT_DISASSEMBLY(
-      "mov eax,0x........\n"
+      "mov eax,0x40000000\n"
       "movd xmm0,eax\n"
       "shufps xmm0,xmm0 [0]\n"
-      "mov eax,0x........\n"
+      "mov eax,0x40800000\n"
       "movd xmm1,eax\n"
       "shufps xmm1,xmm1 [0]\n"
       "minps xmm0,xmm1\n"
@@ -1918,10 +1918,10 @@
   float res = reinterpret_cast<PackedMaxCode>(test->entry())();
   EXPECT_FLOAT_EQ(4.0f, res, 0.001f);
   EXPECT_DISASSEMBLY(
-      "mov eax,0x........\n"
+      "mov eax,0x40000000\n"
       "movd xmm0,eax\n"
       "shufps xmm0,xmm0 [0]\n"
-      "mov eax,0x........\n"
+      "mov eax,0x40800000\n"
       "movd xmm1,eax\n"
       "shufps xmm1,xmm1 [0]\n"
       "maxps xmm0,xmm1\n"
@@ -1961,8 +1961,8 @@
   uint32_t res = reinterpret_cast<PackedLogicalOrCode>(test->entry())();
   EXPECT_EQ(0xFFFFFFFF, res);
   EXPECT_DISASSEMBLY(
-      "movups xmm0,[rip+0x.......]\n"
-      "movups xmm1,[rip+0x.......]\n"
+      "movups xmm0,[0x.......]\n"
+      "movups xmm1,[0x.......]\n"
       "orps xmm0,xmm1\n"
       "push eax\n"
       "movss [esp],xmm0\n"
@@ -1999,8 +1999,8 @@
   uint32_t res = reinterpret_cast<PackedLogicalAndCode>(test->entry())();
   EXPECT_EQ(static_cast<uword>(0x0000F000), res);
   EXPECT_DISASSEMBLY(
-      "movups xmm0,[rip+0x.......]\n"
-      "andps xmm0,[rip+0x.......]\n"
+      "movups xmm0,[0x.......]\n"
+      "andps xmm0,[0x.......]\n"
       "push eax\n"
       "movss [esp],xmm0\n"
       "fld_s [esp]\n"
@@ -2030,8 +2030,8 @@
   uint32_t res = reinterpret_cast<PackedLogicalNotCode>(test->entry())();
   EXPECT_EQ(static_cast<uword>(0x0), res);
   EXPECT_DISASSEMBLY(
-      "movups xmm0,[rip+0x.......]\n"
-      "xorps xmm0,[rip+0x.......]\n"
+      "movups xmm0,[0x.......]\n"
+      "xorps xmm0,[0x.......]\n"
       "push eax\n"
       "movss [esp],xmm0\n"
       "fld_s [esp]\n"
@@ -2076,8 +2076,8 @@
   float res = reinterpret_cast<PackedMoveHighLow>(test->entry())();
   EXPECT_FLOAT_EQ(15.0f, res, 0.001f);
   EXPECT_DISASSEMBLY(
-      "movups xmm0,[rip+0x.......]\n"
-      "movups xmm1,[rip+0x.......]\n"
+      "movups xmm0,[0x.......]\n"
+      "movups xmm1,[0x.......]\n"
       "movhlps xmm0,xmm1\n"
       "xorps xmm1,xmm1\n"
       "movaps xmm1,xmm0\n"
@@ -2128,8 +2128,8 @@
   float res = reinterpret_cast<PackedMoveLowHigh>(test->entry())();
   EXPECT_FLOAT_EQ(11.0f, res, 0.001f);
   EXPECT_DISASSEMBLY(
-      "movups xmm0,[rip+0x.......]\n"
-      "movups xmm1,[rip+0x.......]\n"
+      "movups xmm0,[0x.......]\n"
+      "movups xmm1,[0x.......]\n"
       "movlhps xmm0,xmm1\n"
       "xorps xmm1,xmm1\n"
       "movaps xmm1,xmm0\n"
@@ -2179,8 +2179,8 @@
   float res = reinterpret_cast<PackedUnpackLow>(test->entry())();
   EXPECT_FLOAT_EQ(11.0f, res, 0.001f);
   EXPECT_DISASSEMBLY(
-      "movups xmm0,[rip+0x.......]\n"
-      "movups xmm1,[rip+0x.......]\n"
+      "movups xmm0,[0x.......]\n"
+      "movups xmm1,[0x.......]\n"
       "unpcklps xmm0,xmm1\n"
       "movaps xmm1,xmm0\n"
       "shufps xmm0,xmm0 [55]\n"
@@ -2229,8 +2229,8 @@
   float res = reinterpret_cast<PackedUnpackHigh>(test->entry())();
   EXPECT_FLOAT_EQ(7.0f, res, 0.001f);
   EXPECT_DISASSEMBLY(
-      "movups xmm0,[rip+0x.......]\n"
-      "movups xmm1,[rip+0x.......]\n"
+      "movups xmm0,[0x.......]\n"
+      "movups xmm1,[0x.......]\n"
       "unpckhps xmm0,xmm1\n"
       "movaps xmm1,xmm0\n"
       "shufps xmm0,xmm0 [0]\n"
@@ -2279,8 +2279,8 @@
   float res = reinterpret_cast<PackedUnpackLowPair>(test->entry())();
   EXPECT_FLOAT_EQ(6.0f, res, 0.001f);
   EXPECT_DISASSEMBLY(
-      "movups xmm0,[rip+0x.......]\n"
-      "movups xmm1,[rip+0x.......]\n"
+      "movups xmm0,[0x.......]\n"
+      "movups xmm1,[0x.......]\n"
       "unpcklpd xmm0,xmm1\n"
       "movaps xmm1,xmm0\n"
       "shufps xmm0,xmm0 [0]\n"
@@ -2329,8 +2329,8 @@
   float res = reinterpret_cast<PackedUnpackHighPair>(test->entry())();
   EXPECT_FLOAT_EQ(12.0f, res, 0.001f);
   EXPECT_DISASSEMBLY(
-      "movups xmm0,[rip+0x.......]\n"
-      "movups xmm1,[rip+0x.......]\n"
+      "movups xmm0,[0x.......]\n"
+      "movups xmm1,[0x.......]\n"
       "unpckhpd xmm0,xmm1\n"
       "movaps xmm1,xmm0\n"
       "shufps xmm0,xmm0 [55]\n"
@@ -2369,8 +2369,8 @@
   double res = reinterpret_cast<PackedDoubleAdd>(test->entry())();
   EXPECT_FLOAT_EQ(4.0, res, 0.000001f);
   EXPECT_DISASSEMBLY(
-      "movups xmm0,[rip+0x.......]\n"
-      "movups xmm1,[rip+0x.......]\n"
+      "movups xmm0,[0x.......]\n"
+      "movups xmm1,[0x.......]\n"
       "addpd xmm0,xmm1\n"
       "push eax\n"
       "push eax\n"
@@ -2407,8 +2407,8 @@
   double res = reinterpret_cast<PackedDoubleSub>(test->entry())();
   EXPECT_FLOAT_EQ(-2.0, res, 0.000001f);
   EXPECT_DISASSEMBLY(
-      "movups xmm0,[rip+0x.......]\n"
-      "movups xmm1,[rip+0x.......]\n"
+      "movups xmm0,[0x.......]\n"
+      "movups xmm1,[0x.......]\n"
       "subpd xmm0,xmm1\n"
       "push eax\n"
       "push eax\n"
@@ -2440,8 +2440,8 @@
   double res = reinterpret_cast<PackedDoubleNegate>(test->entry())();
   EXPECT_FLOAT_EQ(-1.0, res, 0.000001f);
   EXPECT_DISASSEMBLY(
-      "movups xmm0,[rip+0x.......]\n"
-      "xorpd xmm0,[rip+0x.......]\n"
+      "movups xmm0,[0x.......]\n"
+      "xorpd xmm0,[0x.......]\n"
       "push eax\n"
       "push eax\n"
       "movsd [esp],xmm0\n"
@@ -2472,8 +2472,8 @@
   double res = reinterpret_cast<PackedDoubleAbsolute>(test->entry())();
   EXPECT_FLOAT_EQ(1.0, res, 0.000001f);
   EXPECT_DISASSEMBLY(
-      "movups xmm0,[rip+0x.......]\n"
-      "andpd xmm0,[rip+0x.......]\n"
+      "movups xmm0,[0x.......]\n"
+      "andpd xmm0,[0x.......]\n"
       "push eax\n"
       "push eax\n"
       "movsd [esp],xmm0\n"
@@ -2509,8 +2509,8 @@
   double res = reinterpret_cast<PackedDoubleMul>(test->entry())();
   EXPECT_FLOAT_EQ(9.0, res, 0.000001f);
   EXPECT_DISASSEMBLY(
-      "movups xmm0,[rip+0x.......]\n"
-      "movups xmm1,[rip+0x.......]\n"
+      "movups xmm0,[0x.......]\n"
+      "movups xmm1,[0x.......]\n"
       "mulpd xmm0,xmm1\n"
       "push eax\n"
       "push eax\n"
@@ -2547,8 +2547,8 @@
   double res = reinterpret_cast<PackedDoubleDiv>(test->entry())();
   EXPECT_FLOAT_EQ(3.0, res, 0.000001f);
   EXPECT_DISASSEMBLY(
-      "movups xmm0,[rip+0x.......]\n"
-      "movups xmm1,[rip+0x.......]\n"
+      "movups xmm0,[0x.......]\n"
+      "movups xmm1,[0x.......]\n"
       "divpd xmm0,xmm1\n"
       "push eax\n"
       "push eax\n"
@@ -2580,7 +2580,7 @@
   double res = reinterpret_cast<PackedDoubleSqrt>(test->entry())();
   EXPECT_FLOAT_EQ(4.0, res, 0.000001f);
   EXPECT_DISASSEMBLY(
-      "movups xmm0,[rip+0x.......]\n"
+      "movups xmm0,[0x.......]\n"
       "sqrtpd xmm0,xmm0\n"
       "push eax\n"
       "push eax\n"
@@ -2617,8 +2617,8 @@
   double res = reinterpret_cast<PackedDoubleMin>(test->entry())();
   EXPECT_FLOAT_EQ(3.0, res, 0.000001f);
   EXPECT_DISASSEMBLY(
-      "movups xmm0,[rip+0x.......]\n"
-      "movups xmm1,[rip+0x.......]\n"
+      "movups xmm0,[0x.......]\n"
+      "movups xmm1,[0x.......]\n"
       "minpd xmm0,xmm1\n"
       "push eax\n"
       "push eax\n"
@@ -2655,8 +2655,8 @@
   double res = reinterpret_cast<PackedDoubleMax>(test->entry())();
   EXPECT_FLOAT_EQ(9.0, res, 0.000001f);
   EXPECT_DISASSEMBLY(
-      "movups xmm0,[rip+0x.......]\n"
-      "movups xmm1,[rip+0x.......]\n"
+      "movups xmm0,[0x.......]\n"
+      "movups xmm1,[0x.......]\n"
       "maxpd xmm0,xmm1\n"
       "push eax\n"
       "push eax\n"
@@ -2692,7 +2692,7 @@
   double res = reinterpret_cast<PackedDoubleShuffle>(test->entry())();
   EXPECT_FLOAT_EQ(9.0, res, 0.000001f);
   EXPECT_DISASSEMBLY(
-      "movups xmm0,[rip+0x.......]\n"
+      "movups xmm0,[0x.......]\n"
       "shufpd xmm0, xmm0 [33]\n"
       "shufpd xmm0, xmm0 [0]\n"
       "push eax\n"
@@ -2723,7 +2723,7 @@
   float res = reinterpret_cast<PackedDoubleToSingle>(test->entry())();
   EXPECT_FLOAT_EQ(9.0f, res, 0.000001f);
   EXPECT_DISASSEMBLY(
-      "movups xmm1,[rip+0x.......]\n"
+      "movups xmm1,[0x.......]\n"
       "cvtpd2ps xmm0,xmm1\n"
       "push eax\n"
       "movss [esp],xmm0\n"
@@ -2755,7 +2755,7 @@
   double res = reinterpret_cast<PackedSingleToDouble>(test->entry())();
   EXPECT_FLOAT_EQ(9.0f, res, 0.000001f);
   EXPECT_DISASSEMBLY(
-      "movups xmm1,[rip+0x.......]\n"
+      "movups xmm1,[0x.......]\n"
       "cvtps2pd xmm0,xmm1\n"
       "push eax\n"
       "push eax\n"
@@ -2785,7 +2785,7 @@
   float res = reinterpret_cast<SingleFPOperationsStackCode>(test->entry())(3.4);
   EXPECT_FLOAT_EQ(14.7f, res, 0.001f);
   EXPECT_DISASSEMBLY(
-      "mov eax,0x........\n"
+      "mov eax,0x4144cccd\n"
       "movd xmm0,eax\n"
       "addss xmm0,[esp+0x4]\n"
       "mulss xmm0,[esp+0x4]\n"
@@ -2838,9 +2838,9 @@
   double res = reinterpret_cast<DoubleFPMovesCode>(test->entry())();
   EXPECT_FLOAT_EQ(1024.67, res, 0.0001);
   EXPECT_DISASSEMBLY(
-      "mov eax,0x........\n"
+      "mov eax,0x409002ae\n"
       "push eax\n"
-      "mov eax,0x........\n"
+      "mov eax,0x147ae148\n"
       "push eax\n"
       "movsd xmm0,[esp]\n"
       "movsd xmm1,xmm0\n"
@@ -2891,9 +2891,9 @@
   int64_t res = reinterpret_cast<DoubleFPUStackMovesCode>(test->entry())();
   EXPECT_FLOAT_EQ(1024.67, (bit_cast<double, int64_t>(res)), 0.001);
   EXPECT_DISASSEMBLY(
-      "mov eax,0x........\n"
+      "mov eax,0x409002ae\n"
       "push eax\n"
-      "mov eax,0x........\n"
+      "mov eax,0x147ae148\n"
       "push eax\n"
       "fld_d [esp]\n"
       "mov [esp],0\n"
@@ -2935,16 +2935,16 @@
   double res = reinterpret_cast<DoubleFPOperationsCode>(test->entry())();
   EXPECT_FLOAT_EQ(14.7, res, 0.001);
   EXPECT_DISASSEMBLY(
-      "mov eax,0x........\n"
+      "mov eax,0x40289999\n"
       "push eax\n"
-      "mov eax,0x........\n"
+      "mov eax,0x9999999a\n"
       "push eax\n"
       "movsd xmm0,[esp]\n"
       "pop eax\n"
       "pop eax\n"
-      "mov eax,0x........\n"
+      "mov eax,0x400b3333\n"
       "push eax\n"
-      "mov eax,0x........\n"
+      "mov eax,0x33333333\n"
       "push eax\n"
       "movsd xmm1,[esp]\n"
       "addsd xmm0,xmm1\n"
@@ -2988,9 +2988,9 @@
       reinterpret_cast<DoubleFPOperationsStackCode>(test->entry())(3.4);
   EXPECT_FLOAT_EQ(14.7, res, 0.001);
   EXPECT_DISASSEMBLY(
-      "mov eax,0x........\n"
+      "mov eax,0x40289999\n"
       "push eax\n"
-      "mov eax,0x........\n"
+      "mov eax,0x9999999a\n"
       "push eax\n"
       "movsd xmm0,[esp]\n"
       "pop eax\n"
@@ -3093,8 +3093,8 @@
       reinterpret_cast<NegativeInt64ToDoubleConversionCode>(test->entry())();
   EXPECT_EQ(-6.0, res);
   EXPECT_DISASSEMBLY(
-      "mov eax,0x........\n"
-      "mov edx,0x........\n"
+      "mov eax,0xffffffff\n"
+      "mov edx,0xfffffffa\n"
       "push eax\n"
       "push edx\n"
       "fild_d [esp]\n"
@@ -3188,7 +3188,7 @@
   double res = reinterpret_cast<FloatToDoubleConversionCode>(test->entry())();
   EXPECT_FLOAT_EQ(12.3, res, 0.001);
   EXPECT_DISASSEMBLY(
-      "mov eax,0x........\n"
+      "mov eax,0x4144cccd\n"
       "movd xmm1,eax\n"
       "xor eax,eax\n"
       "cvtss2sd xmm2,xmm1\n"
@@ -3248,26 +3248,26 @@
   EXPECT_EQ(0, res);
   EXPECT_DISASSEMBLY(
       "xor eax,eax\n"
-      "mov edx,0x........\n"
+      "mov edx,0x4144cccd\n"
       "movd xmm0,edx\n"
-      "mov edx,0x........\n"
+      "mov edx,0x41480000\n"
       "movd xmm1,edx\n"
       "comiss xmm0,xmm1\n"
-      "jpe 0x........\n"
-      "ja 0x........\n"
-      "jc 0x........\n"
+      "jpe +43\n"
+      "ja +40\n"
+      "jc +7\n"
       "inc eax\n"
       "mov edx,0\n"
       "movd xmm1,edx\n"
       "divss xmm1,xmm1\n"
       "comiss xmm1,xmm1\n"
-      "jpe 0x........\n"
+      "jpe +7\n"
       "inc eax\n"
       "ret\n"
       "inc eax\n"
-      "jmp 0x........\n"
+      "jmp -38\n"
       "inc eax\n"
-      "jmp 0x........\n");
+      "jmp -35\n");
 }
 
 ASSEMBLER_TEST_GENERATE(DoubleCompare, assembler) {
@@ -3338,14 +3338,14 @@
   int res = reinterpret_cast<DoubleCompareCode>(test->entry())();
   EXPECT_EQ(0, res);
   EXPECT_DISASSEMBLY(
-      "mov edx,0x........\n"
+      "mov edx,0x40289999\n"
       "push edx\n"
-      "mov edx,0x........\n"
+      "mov edx,0x9999999a\n"
       "push edx\n"
       "movsd xmm0,[esp]\n"
       "pop edx\n"
       "pop edx\n"
-      "mov edx,0x........\n"
+      "mov edx,0x40290000\n"
       "push edx\n"
       "mov edx,0\n"
       "push edx\n"
@@ -3354,9 +3354,9 @@
       "pop edx\n"
       "xor eax,eax\n"
       "comisd xmm0,xmm1\n"
-      "jpe 0x........\n"
-      "ja 0x........\n"
-      "jc 0x........\n"
+      "jpe +54\n"
+      "ja +51\n"
+      "jc +7\n"
       "inc eax\n"
       "mov edx,0\n"
       "push edx\n"
@@ -3367,13 +3367,13 @@
       "pop edx\n"
       "divsd xmm1,xmm1\n"
       "comisd xmm1,xmm1\n"
-      "jpe 0x........\n"
+      "jpe +7\n"
       "inc eax\n"
       "ret\n"
       "inc eax\n"
-      "jmp 0x........\n"
+      "jmp -49\n"
       "inc eax\n"
-      "jmp 0x........\n");
+      "jmp -46\n");
 }
 
 ASSEMBLER_TEST_GENERATE(DoubleToFloatConversion, assembler) {
@@ -3396,9 +3396,9 @@
   float res = reinterpret_cast<DoubleToFloatConversionCode>(test->entry())();
   EXPECT_FLOAT_EQ(12.3f, res, 0.001);
   EXPECT_DISASSEMBLY(
-      "mov eax,0x........\n"
+      "mov eax,0x40289999\n"
       "push eax\n"
-      "mov eax,0x........\n"
+      "mov eax,0x9999999a\n"
       "push eax\n"
       "movsd xmm0,[esp]\n"
       "cvtsd2ss xmm1,xmm0\n"
@@ -3499,7 +3499,7 @@
   double res = reinterpret_cast<GlobalAddressCode>(test->entry())();
   EXPECT_FLOAT_EQ(kDoubleConst, res, 0.000001);
   EXPECT_DISASSEMBLY(
-      "movsd xmm0,[rip+0x.......]\n"
+      "movsd xmm0,[0x.......]\n"
       "push eax\n"
       "push eax\n"
       "movsd [esp],xmm0\n"
@@ -3703,7 +3703,7 @@
   EXPECT_FLOAT_EQ(-kFloatConst, res, 0.0001);
   EXPECT_DISASSEMBLY(
       "movss xmm0,[esp+0x4]\n"
-      "xorps xmm0,[rip+0x.......]\n"
+      "xorps xmm0,[0x.......]\n"
       "push eax\n"
       "movss [esp],xmm0\n"
       "fld_s [esp]\n"
@@ -3730,7 +3730,7 @@
   EXPECT_FLOAT_EQ(-kDoubleConst, res, 0.0001);
   EXPECT_DISASSEMBLY(
       "movsd xmm0,[esp+0x4]\n"
-      "xorpd xmm0,[rip+0x.......]\n"
+      "xorpd xmm0,[0x.......]\n"
       "push eax\n"
       "push eax\n"
       "movsd [esp],xmm0\n"
@@ -4124,7 +4124,7 @@
       "push eax\n"
       "fnstcw [esp]\n"
       "movzxw eax,[esp]\n"
-      "or eax,0x...\n"
+      "or eax,0xc00\n"
       "movw [esp+0x4],eax\n"
       "fldcw [esp+0x4]\n"
       "push eax\n"
@@ -4214,7 +4214,7 @@
   EXPECT_DISASSEMBLY(
       "movsd xmm0,[esp+0x4]\n"
       "xorpd xmm1,xmm1\n"
-      "xorpd xmm1,[rip+0x.......]\n"
+      "xorpd xmm1,[0x.......]\n"
       "orpd xmm0,xmm1\n"
       "push eax\n"
       "push eax\n"
@@ -4383,7 +4383,7 @@
   EXPECT_FLOAT_EQ(val, res, 0.001);
   EXPECT_DISASSEMBLY(
       "movsd xmm0,[esp+0x4]\n"
-      "andpd xmm0,[rip+0x.......]\n"
+      "andpd xmm0,[0x.......]\n"
       "push eax\n"
       "push eax\n"
       "movsd [esp],xmm0\n"
@@ -4445,7 +4445,7 @@
       "mov edx,[esp+0x8]\n"
       "xor eax,eax\n"
       "mov ebx,1\n"
-      "mov ecx,0x........\n"
+      "mov ecx,0xffffffff\n"
       "test edx,edx\n"
       "cmovs eax,ecx\n"
       "test edx,edx\n"
@@ -4500,7 +4500,7 @@
       "xor eax,eax\n"
       "mov ecx,1\n"
       "mov edx,[esp+0x4]\n"
-      "cmp edx,0x...\n"
+      "cmp edx,0x311\n"
       "cmovz eax,ecx\n"
       "ret\n");
 }
@@ -4525,7 +4525,7 @@
       "xor eax,eax\n"
       "mov ecx,1\n"
       "mov edx,[esp+0x4]\n"
-      "cmp edx,0x...\n"
+      "cmp edx,0x311\n"
       "cmovnz eax,ecx\n"
       "ret\n");
 }
@@ -4550,7 +4550,7 @@
   EXPECT_EQ(-1, res);  // Less.
   EXPECT_DISASSEMBLY(
       "mov edx,1\n"
-      "mov ecx,0x........\n"
+      "mov ecx,0xffffffff\n"
       "mov eax,[esp+0x4]\n"
       "cmp eax,[esp+0x8]\n"
       "cmovl eax,ecx\n"
@@ -4574,8 +4574,8 @@
   double res = reinterpret_cast<TestLoadDoubleConstantCode>(test->entry())();
   EXPECT_FLOAT_EQ(-12.34, res, 0.0001);
   EXPECT_DISASSEMBLY(
-      "push 0x........\n"
-      "push 0x........\n"
+      "push 0xc028ae14\n"
+      "push 0x7ae147ae\n"
       "movsd xmm3,[esp]\n"
       "add esp,8\n"
       "push eax\n"
@@ -4608,17 +4608,7 @@
   typedef bool (*TestObjectCompare)();
   bool res = reinterpret_cast<TestObjectCompare>(test->entry())();
   EXPECT_EQ(true, res);
-  EXPECT_DISASSEMBLY(
-      "mov eax,0x........\n"
-      "cmp eax,0x........\n"
-      "jnz 0x........\n"
-      "mov ecx,0x........\n"
-      "cmp ecx,0x........\n"
-      "jnz 0x........\n"
-      "mov eax,1\n"
-      "ret\n"
-      "mov eax,0\n"
-      "ret\n");
+  // Disassembly contains absolute addresses of objects that vary between runs.
 }
 
 ASSEMBLER_TEST_GENERATE(TestSetCC, assembler) {
@@ -4633,7 +4623,7 @@
   uword res = reinterpret_cast<TestSetCC>(test->entry())();
   EXPECT_EQ(0xFFFFFF00, res);
   EXPECT_DISASSEMBLY(
-      "mov eax,0x........\n"
+      "mov eax,0xffffffff\n"
       "cmp eax,eax\n"
       "setnz eax\n"
       "ret\n");
@@ -4900,7 +4890,7 @@
       "mov eax,4\n"
       "mov ecx,2\n"
       "bt eax,ecx\n"
-      "jc 0x........\n"
+      "jc +7\n"
       "int3\n"
       "mov eax,1\n"
       "ret\n");
@@ -4923,7 +4913,7 @@
   EXPECT_DISASSEMBLY(
       "mov ecx,0x20\n"
       "bt ecx,5\n"
-      "jc 0x........\n"
+      "jc +7\n"
       "int3\n"
       "mov eax,1\n"
       "ret\n");
diff --git a/runtime/vm/compiler/assembler/assembler_x64_test.cc b/runtime/vm/compiler/assembler/assembler_x64_test.cc
index 3d2deb2..1dded0f 100644
--- a/runtime/vm/compiler/assembler/assembler_x64_test.cc
+++ b/runtime/vm/compiler/assembler/assembler_x64_test.cc
@@ -24,9 +24,9 @@
 #define EXPECT_DISASSEMBLY_NOT_WINDOWS_ENDS_WITH(expected)
 #else
 #define EXPECT_DISASSEMBLY(expected)                                           \
-  EXPECT_STREQ(expected, test->BlankedDisassembly())
+  EXPECT_STREQ(expected, test->RelativeDisassembly())
 #define EXPECT_DISASSEMBLY_ENDS_WITH(expected_arg)                             \
-  char* disassembly = test->BlankedDisassembly();                              \
+  char* disassembly = test->RelativeDisassembly();                             \
   const char* expected = expected_arg;                                         \
   intptr_t dis_len = strlen(disassembly);                                      \
   intptr_t exp_len = strlen(expected);                                         \
@@ -279,18 +279,18 @@
       "movq rax,[r10-0x8]\n"
       "movq rax,[r12-0x8]\n"
       "movq rax,[r13-0x8]\n"
-      "movq rax,[rsp+0x...]\n"
-      "movq rax,[rbp+0x...]\n"
-      "movq rax,[rax+0x...]\n"
-      "movq rax,[r10+0x...]\n"
-      "movq rax,[r12+0x...]\n"
-      "movq rax,[r13+0x...]\n"
-      "movq rax,[rsp-0x...]\n"
-      "movq rax,[rbp-0x...]\n"
-      "movq rax,[rax-0x...]\n"
-      "movq rax,[r10-0x...]\n"
-      "movq rax,[r12-0x...]\n"
-      "movq rax,[r13-0x...]\n"
+      "movq rax,[rsp+0x800]\n"
+      "movq rax,[rbp+0x800]\n"
+      "movq rax,[rax+0x800]\n"
+      "movq rax,[r10+0x800]\n"
+      "movq rax,[r12+0x800]\n"
+      "movq rax,[r13+0x800]\n"
+      "movq rax,[rsp-0x800]\n"
+      "movq rax,[rbp-0x800]\n"
+      "movq rax,[rax-0x800]\n"
+      "movq rax,[r10-0x800]\n"
+      "movq rax,[r12-0x800]\n"
+      "movq rax,[r13-0x800]\n"
       "movq rax,[rax*1+0]\n"
       "movq rax,[rax*2+0]\n"
       "movq rax,[rax*4+0]\n"
@@ -305,11 +305,11 @@
       "movq rax,[r10*2+0x8]\n"
       "movq rax,[r12*2+0x8]\n"
       "movq rax,[r13*2+0x8]\n"
-      "movq rax,[rbp*2+0x...]\n"
-      "movq rax,[rax*2+0x...]\n"
-      "movq rax,[r10*2+0x...]\n"
-      "movq rax,[r12*2+0x...]\n"
-      "movq rax,[r13*2+0x...]\n"
+      "movq rax,[rbp*2+0x800]\n"
+      "movq rax,[rax*2+0x800]\n"
+      "movq rax,[r10*2+0x800]\n"
+      "movq rax,[r12*2+0x800]\n"
+      "movq rax,[r13*2+0x800]\n"
       "movq rax,[rax+rbp*2]\n"
       "movq rax,[rax+rax*2]\n"
       "movq rax,[rax+r10*2]\n"
@@ -370,36 +370,36 @@
       "movq rax,[r13+r10*2+0x8]\n"
       "movq rax,[r13+r12*2+0x8]\n"
       "movq rax,[r13+r13*2+0x8]\n"
-      "movq rax,[rax+rbp*2+0x...]\n"
-      "movq rax,[rax+rax*2+0x...]\n"
-      "movq rax,[rax+r10*2+0x...]\n"
-      "movq rax,[rax+r12*2+0x...]\n"
-      "movq rax,[rax+r13*2+0x...]\n"
-      "movq rax,[rbp+rbp*2+0x...]\n"
-      "movq rax,[rbp+rax*2+0x...]\n"
-      "movq rax,[rbp+r10*2+0x...]\n"
-      "movq rax,[rbp+r12*2+0x...]\n"
-      "movq rax,[rbp+r13*2+0x...]\n"
-      "movq rax,[rsp+rbp*2+0x...]\n"
-      "movq rax,[rsp+rax*2+0x...]\n"
-      "movq rax,[rsp+r10*2+0x...]\n"
-      "movq rax,[rsp+r12*2+0x...]\n"
-      "movq rax,[rsp+r13*2+0x...]\n"
-      "movq rax,[r10+rbp*2+0x...]\n"
-      "movq rax,[r10+rax*2+0x...]\n"
-      "movq rax,[r10+r10*2+0x...]\n"
-      "movq rax,[r10+r12*2+0x...]\n"
-      "movq rax,[r10+r13*2+0x...]\n"
-      "movq rax,[r12+rbp*2+0x...]\n"
-      "movq rax,[r12+rax*2+0x...]\n"
-      "movq rax,[r12+r10*2+0x...]\n"
-      "movq rax,[r12+r12*2+0x...]\n"
-      "movq rax,[r12+r13*2+0x...]\n"
-      "movq rax,[r13+rbp*2+0x...]\n"
-      "movq rax,[r13+rax*2+0x...]\n"
-      "movq rax,[r13+r10*2+0x...]\n"
-      "movq rax,[r13+r12*2+0x...]\n"
-      "movq rax,[r13+r13*2+0x...]\n"
+      "movq rax,[rax+rbp*2+0x800]\n"
+      "movq rax,[rax+rax*2+0x800]\n"
+      "movq rax,[rax+r10*2+0x800]\n"
+      "movq rax,[rax+r12*2+0x800]\n"
+      "movq rax,[rax+r13*2+0x800]\n"
+      "movq rax,[rbp+rbp*2+0x800]\n"
+      "movq rax,[rbp+rax*2+0x800]\n"
+      "movq rax,[rbp+r10*2+0x800]\n"
+      "movq rax,[rbp+r12*2+0x800]\n"
+      "movq rax,[rbp+r13*2+0x800]\n"
+      "movq rax,[rsp+rbp*2+0x800]\n"
+      "movq rax,[rsp+rax*2+0x800]\n"
+      "movq rax,[rsp+r10*2+0x800]\n"
+      "movq rax,[rsp+r12*2+0x800]\n"
+      "movq rax,[rsp+r13*2+0x800]\n"
+      "movq rax,[r10+rbp*2+0x800]\n"
+      "movq rax,[r10+rax*2+0x800]\n"
+      "movq rax,[r10+r10*2+0x800]\n"
+      "movq rax,[r10+r12*2+0x800]\n"
+      "movq rax,[r10+r13*2+0x800]\n"
+      "movq rax,[r12+rbp*2+0x800]\n"
+      "movq rax,[r12+rax*2+0x800]\n"
+      "movq rax,[r12+r10*2+0x800]\n"
+      "movq rax,[r12+r12*2+0x800]\n"
+      "movq rax,[r12+r13*2+0x800]\n"
+      "movq rax,[r13+rbp*2+0x800]\n"
+      "movq rax,[r13+rax*2+0x800]\n"
+      "movq rax,[r13+r10*2+0x800]\n"
+      "movq rax,[r13+r12*2+0x800]\n"
+      "movq rax,[r13+r13*2+0x800]\n"
       "movq rax,[rsp+0]\n"
       "movq rax,[rbp+0]\n"
       "movq rax,[rax+0]\n"
@@ -446,23 +446,23 @@
   typedef void (*JumpAroundCrashCode)();
   reinterpret_cast<JumpAroundCrashCode>(test->entry())();
   EXPECT_DISASSEMBLY(
-      "jo 0x................\n"
-      "jno 0x................\n"
-      "jc 0x................\n"
-      "jnc 0x................\n"
-      "jz 0x................\n"
-      "jnz 0x................\n"
-      "jna 0x................\n"
-      "ja 0x................\n"
-      "js 0x................\n"
-      "jns 0x................\n"
-      "jpe 0x................\n"
-      "jpo 0x................\n"
-      "jl 0x................\n"
-      "jge 0x................\n"
-      "jle 0x................\n"
-      "jg 0x................\n"
-      "jmp 0x................\n"
+      "jo +109\n"
+      "jno +103\n"
+      "jc +97\n"
+      "jnc +91\n"
+      "jz +85\n"
+      "jnz +79\n"
+      "jna +73\n"
+      "ja +67\n"
+      "js +61\n"
+      "jns +55\n"
+      "jpe +49\n"
+      "jpo +43\n"
+      "jl +37\n"
+      "jge +31\n"
+      "jle +25\n"
+      "jg +19\n"
+      "jmp +13\n"
       "movl rax,0\n"
       "movq [rax],rax\n"
       "ret\n");
@@ -489,7 +489,7 @@
       "addq rax,2\n"
       "incq rcx\n"
       "cmpq rcx,0x57\n"
-      "jl 0x................\n"
+      "jl -11\n"
       "ret\n");
 }
 
@@ -510,10 +510,10 @@
   EXPECT_EQ(1, reinterpret_cast<CmpbCode>(test->entry())());
   EXPECT_DISASSEMBLY(
       "movl rax,1\n"
-      "movl r11,0x........\n"
+      "movl r11,0xffffff11\n"
       "push r11\n"
       "cmpb [rsp],0x11\n"
-      "jz 0x................\n"
+      "jz +7\n"
       "movl rax,0\n"
       "pop rcx\n"
       "ret\n");
@@ -542,12 +542,12 @@
   EXPECT_DISASSEMBLY(
       "movl rax,1\n"
       "movl rcx,0\n"
-      "movl r11,0x........\n"
+      "movl r11,0xffffff11\n"
       "push r11\n"
       "testb [rsp],0x10\n"
       "cmovzq rax,rcx\n"
       "testb [rsp],0x20\n"
-      "jz 0x................\n"
+      "jz +11\n"
       "movl rax,0\n"
       "pop rcx\n"
       "ret\n");
@@ -610,43 +610,43 @@
   typedef int64_t (*Testb2Code)();
   EXPECT_EQ(42, reinterpret_cast<Testb2Code>(test->entry())());
   EXPECT_DISASSEMBLY(
-      "movl rax,0x........\n"
+      "movl rax,0xffffefff\n"
       "bsrq rcx,rax\n"
       "cmpq rcx,0x1f\n"
-      "jz 0x................\n"
+      "jz +7\n"
       "int3\n"
 
       "sarq rax,1\n"
-      "cmpq rax,0x........\n"
-      "jz 0x................\n"
+      "cmpq rax,0x7ffff7ff\n"
+      "jz +7\n"
       "int3\n"
 
-      "movl rax,0x........\n"
+      "movl rax,0x7fffffff\n"
       "bsrq rcx,rax\n"
       "cmpq rcx,0x1e\n"
-      "jz 0x................\n"
+      "jz +7\n"
       "int3\n"
 
-      "cmpq rax,0x........\n"
-      "jz 0x................\n"
+      "cmpq rax,0x7fffffff\n"
+      "jz +7\n"
       "int3\n"
 
-      "movq rax,0x................\n"
-      "andl rax,0x........\n"
-      "cmpq rax,0x........\n"
-      "jz 0x................\n"
+      "movq rax,0x0000000101020408\n"
+      "andl rax,0xffffffff\n"
+      "cmpq rax,0x01020408\n"
+      "jz +7\n"
       "int3\n"
 
-      "movq rcx,0x................\n"
-      "andl rcx,0x........\n"
-      "cmpq rcx,0x........\n"
-      "jz 0x................\n"
+      "movq rcx,0x0000000101020408\n"
+      "andl rcx,0xffffffff\n"
+      "cmpq rcx,0x01020408\n"
+      "jz +7\n"
       "int3\n"
 
-      "movl rax,0x........\n"
+      "movl rax,0x0fffeff0\n"
       "bsfq rcx,rax\n"
       "cmpq rcx,4\n"
-      "jz 0x................\n"
+      "jz +7\n"
       "int3\n"
 
       "movl rax,0x2a\n"
@@ -676,7 +676,7 @@
       "push rdi\n"
       "movl rdx,0x10\n"
       "testb rdx,[rsp]\n"
-      "jz 0x................\n"
+      "jz +13\n"
       "movl rax,1\n"
       "pop rcx\n"
       "ret\n"
@@ -725,7 +725,7 @@
   typedef int64_t (*LzcntCode)();
   EXPECT_EQ(108, reinterpret_cast<LzcntCode>(test->entry())());
   EXPECT_DISASSEMBLY(
-      "movl rcx,0x...\n"
+      "movl rcx,0xf00\n"
       "lzcntq rax,rcx\n"
       "movl rcx,0xf0\n"
       "lzcntq rcx,rcx\n"
@@ -818,7 +818,7 @@
   typedef int64_t (*IncrementCodeLong)();
   EXPECT_EQ(0x100000001, reinterpret_cast<IncrementCodeLong>(test->entry())());
   EXPECT_DISASSEMBLY(
-      "movl rax,0x........\n"
+      "movl rax,0xffffffff\n"
       "push rax\n"
       "incq [rsp]\n"
       "movq rcx,[rsp]\n"
@@ -870,7 +870,7 @@
   typedef int64_t (*DecrementCodeLong)();
   EXPECT_EQ(0xffffffff, reinterpret_cast<DecrementCodeLong>(test->entry())());
   EXPECT_DISASSEMBLY(
-      "movq rax,0x................\n"
+      "movq rax,0x0000000100000001\n"
       "push rax\n"
       "decq [rsp]\n"
       "movq rcx,[rsp]\n"
@@ -895,7 +895,7 @@
       "movl rax,2\n"
       "movl rcx,4\n"
       "imull rax,rcx\n"
-      "imull rax,rax,0x...\n"
+      "imull rax,rax,0x3e8\n"
       "ret\n");
 }
 
@@ -1009,13 +1009,13 @@
   EXPECT_EQ(kProductLargeConstants,
             reinterpret_cast<SignedMultiplyLong>(test->entry())());
   EXPECT_DISASSEMBLY(
-      "movq rax,0x................\n"
-      "movq rcx,0x................\n"
+      "movq rax,0x1234567887654321\n"
+      "movq rcx,0x0db4da5f7ef412b1\n"
       "imulq rax,rcx\n"
-      "movq r11,0x................\n"
+      "movq r11,0x1234567887654321\n"
       "imulq rcx,r11\n"
       "cmpq rax,rcx\n"
-      "jz 0x................\n"
+      "jz +7\n"
       "int3\n"
       "ret\n");
 }
@@ -1034,8 +1034,8 @@
   EXPECT_EQ(0, reinterpret_cast<OverflowSignedMultiply>(test->entry())());
   EXPECT_DISASSEMBLY(
       "movl rdx,0\n"
-      "movl rax,0x........\n"
-      "movl rcx,0x........\n"
+      "movl rax,0x0fffffff\n"
+      "movl rcx,0x0fffffff\n"
       "imull rax,rcx\n"
       "imull rax,rdx\n"
       "ret\n");
@@ -1057,7 +1057,7 @@
       "movl rdx,2\n"
       "movl rcx,4\n"
       "imull rdx,rcx\n"
-      "imull rdx,rdx,0x...\n"
+      "imull rdx,rdx,0x3e8\n"
       "movl rax,rdx\n"
       "ret\n");
 }
@@ -1077,7 +1077,7 @@
   EXPECT_DISASSEMBLY(
       "push pp\n"
       "movl pp,2\n"
-      "imull pp,pp,0x...\n"
+      "imull pp,pp,0x3e8\n"
       "movl rax,pp\n"
       "pop pp\n"
       "ret\n");
@@ -1115,7 +1115,7 @@
   typedef int32_t (*SignedDivide)();
   EXPECT_EQ(-87 / 42, reinterpret_cast<SignedDivide>(test->entry())());
   EXPECT_DISASSEMBLY(
-      "movl rax,-0x........\n"
+      "movl rax,-0x00000057\n"
       "movl rdx,0x7b\n"
       "cdq\n"
       "movl rcx,0x2a\n"
@@ -1140,7 +1140,7 @@
   EXPECT_EQ(0xf0000000, reinterpret_cast<UnsignedDivide>(test->entry())());
   EXPECT_DISASSEMBLY(
       "movl rax,0\n"
-      "movl rdx,-0x........\n"
+      "movl rdx,-0x10000000\n"
       "movl rcx,-1\n"
       "divl (rax,rdx),rcx\n"
       "ret\n");
@@ -1160,7 +1160,7 @@
   EXPECT_EQ(kLargeConstant / 42,
             reinterpret_cast<SignedDivideLong>(test->entry())());
   EXPECT_DISASSEMBLY(
-      "movq rax,0x................\n"
+      "movq rax,0x1234567887654321\n"
       "movl rdx,0x7b\n"
       "cqo\n"
       "movl rcx,0x2a\n"
@@ -1187,7 +1187,7 @@
             reinterpret_cast<UnsignedDivideLong>(test->entry())());
   EXPECT_DISASSEMBLY(
       "movl rax,0\n"
-      "movq rdx,0x................\n"
+      "movq rdx,0xf000000000000000\n"
       "movq rcx,-1\n"
       "divq (rax,rdx),rcx\n"
       "ret\n");
@@ -1232,7 +1232,7 @@
   EXPECT_DISASSEMBLY_NOT_WINDOWS(
       "push rdi\n"
       "movq rcx,[rsp]\n"
-      "movl rax,0x...\n"
+      "movl rax,0x29a\n"
       "bsrq rax,rcx\n"
       "pop rcx\n"
       "ret\n");
@@ -1252,7 +1252,7 @@
   typedef int (*MoveExtend)();
   EXPECT_EQ(0xff - 1 + 0xffff, reinterpret_cast<MoveExtend>(test->entry())());
   EXPECT_DISASSEMBLY(
-      "movl rdx,0x....\n"
+      "movl rdx,0xffff\n"
       "movzxbq rax,rdx\n"
       "movsxwq r8,rdx\n"
       "movzxwq rcx,rdx\n"
@@ -1274,9 +1274,9 @@
   typedef intptr_t (*MoveExtend)();
   EXPECT_EQ(0x7ffffffe, reinterpret_cast<MoveExtend>(test->entry())());
   EXPECT_DISASSEMBLY(
-      "movl rdx,0x........\n"
+      "movl rdx,0xffffffff\n"
       "movsxdq rdx,rdx\n"
-      "movl rax,0x........\n"
+      "movl rax,0x7fffffff\n"
       "movsxdq rax,rax\n"
       "addq rax,rdx\n"
       "ret\n");
@@ -1301,7 +1301,7 @@
   EXPECT_EQ(0xff - 1 + 0xffff,
             reinterpret_cast<MoveExtendMemory>(test->entry())());
   EXPECT_DISASSEMBLY(
-      "movq rdx,0x................\n"
+      "movq rdx,0x123456781234ffff\n"
       "push rdx\n"
       "movzxbq rax,[rsp]\n"
       "movsxwq r8,[rsp]\n"
@@ -1327,9 +1327,9 @@
   typedef intptr_t (*MoveExtend)();
   EXPECT_EQ(0x7ffffffe, reinterpret_cast<MoveExtend>(test->entry())());
   EXPECT_DISASSEMBLY(
-      "movl r11,0x........\n"
+      "movl r11,0xffffffff\n"
       "push r11\n"
-      "push 0x........\n"
+      "push 0x7fffffff\n"
       "movsxdq rdx,[rsp+0x8]\n"
       "movsxdq rax,[rsp]\n"
       "addq rsp,0x10\n"
@@ -1378,12 +1378,12 @@
   typedef int64_t (*WordOps)();
   EXPECT_EQ(0x0100010503050507, reinterpret_cast<WordOps>(test->entry())());
   EXPECT_DISASSEMBLY(
-      "movq rax,0x................\n"
+      "movq rax,0x0102030405060708\n"
       "push rax\n"
-      "addw [rsp],0x....\n"
-      "subw [rsp+0x2],0x...\n"
-      "xorw [rsp+0x4],0x...\n"
-      "andw [rsp+0x6],0x...\n"
+      "addw [rsp],0xfdff\n"
+      "subw [rsp+0x2],0x201\n"
+      "xorw [rsp+0x4],0x201\n"
+      "andw [rsp+0x6],0x301\n"
       "andw [rsp],-1\n"
       "pop rax\n"
       "ret\n");
@@ -1405,7 +1405,7 @@
   typedef int64_t (*ByteOps)();
   EXPECT_EQ(0x0100030505050707, reinterpret_cast<ByteOps>(test->entry())());
   EXPECT_DISASSEMBLY(
-      "movq rax,0x................\n"
+      "movq rax,0x0102030405060708\n"
       "push rax\n"
       "addb [rsp],-1\n"
       "subb [rsp+0x2],1\n"
@@ -1904,10 +1904,10 @@
       "orl [rsi],r10\n"
       "movl rcx,0x2a\n"
       "xorl rcx,rcx\n"
-      "orl rcx,0x...\n"
+      "orl rcx,0x100\n"
       "movl rax,4\n"
       "orl rcx,rax\n"
-      "movl rax,0x....\n"
+      "movl rax,0xfff0\n"
       "andl rcx,rax\n"
       "movl rax,1\n"
       "orl rcx,rax\n"
@@ -1961,23 +1961,23 @@
       "xorq rax,[rsp]\n"
       "pop rcx\n"
       "cmpq rax,0\n"
-      "jnz 0x................\n"
+      "jnz +105\n"
       "movl rcx,0xff\n"
       "movl rax,5\n"
       "xorq rcx,rax\n"
       "cmpq rcx,0xfa\n"
-      "jnz 0x................\n"
+      "jnz +79\n"
       "push 0xff\n"
       "movl rcx,5\n"
       "xorq [rsp],rcx\n"
       "pop rcx\n"
       "cmpq rcx,0xfa\n"
-      "jnz 0x................\n"
+      "jnz +51\n"
       "xorq rcx,rcx\n"
-      "orq rcx,0x...\n"
+      "orq rcx,0x100\n"
       "movl rax,4\n"
       "orq rcx,rax\n"
-      "movl rax,0x....\n"
+      "movl rax,0xfff0\n"
       "andq rcx,rax\n"
       "movl rax,1\n"
       "push rax\n"
@@ -2263,155 +2263,155 @@
       "movl rax,4\n"
       "andl rax,2\n"
       "cmpl rax,0\n"
-      "jz 0x................\n"
+      "jz +14\n"
       "movl rax,0\n"
       "movl [rax],rax\n"
       "movl rcx,4\n"
       "andl rcx,4\n"
       "cmpl rcx,0\n"
-      "jnz 0x................\n"
+      "jnz +14\n"
       "movl rax,0\n"
       "movl [rax],rax\n"
       "movl rax,0\n"
       "orl rax,0\n"
       "cmpl rax,0\n"
-      "jz 0x................\n"
+      "jz +14\n"
       "movl rax,0\n"
       "movl [rax],rax\n"
       "movl rax,4\n"
       "orl rax,0\n"
       "cmpl rax,0\n"
-      "jnz 0x................\n"
+      "jnz +14\n"
       "movl rax,0\n"
       "movl [rax],rax\n"
       "push rax\n"
       "movl rax,0xff\n"
       "movl [rsp],rax\n"
       "cmpl [rsp],0xff\n"
-      "jz 0x................\n"
+      "jz +14\n"
       "movl rax,0\n"
       "movq [rax],rax\n"
       "pop rax\n"
       "movl rax,1\n"
       "shll rax,3\n"
       "cmpl rax,8\n"
-      "jz 0x................\n"
+      "jz +14\n"
       "movl rax,0\n"
       "movl [rax],rax\n"
       "movl rax,2\n"
       "shrl rax,1\n"
       "cmpl rax,1\n"
-      "jz 0x................\n"
+      "jz +14\n"
       "movl rax,0\n"
       "movl [rax],rax\n"
       "movl rax,8\n"
       "shrl rax,3\n"
       "cmpl rax,1\n"
-      "jz 0x................\n"
+      "jz +14\n"
       "movl rax,0\n"
       "movl [rax],rax\n"
       "movl rax,1\n"
       "movl rcx,3\n"
       "shll rax,cl\n"
       "cmpl rax,8\n"
-      "jz 0x................\n"
+      "jz +14\n"
       "movl rax,0\n"
       "movl [rax],rax\n"
       "movl rax,8\n"
       "movl rcx,3\n"
       "shrl rax,cl\n"
       "cmpl rax,1\n"
-      "jz 0x................\n"
+      "jz +14\n"
       "movl rax,0\n"
       "movl [rax],rax\n"
       "movl rax,1\n"
       "shlq rax,3\n"
       "cmpl rax,8\n"
-      "jz 0x................\n"
+      "jz +14\n"
       "movl rax,0\n"
       "movl [rax],rax\n"
       "movl rax,2\n"
       "shrq rax,1\n"
       "cmpl rax,1\n"
-      "jz 0x................\n"
+      "jz +14\n"
       "movl rax,0\n"
       "movl [rax],rax\n"
       "movl rax,8\n"
       "shrq rax,3\n"
       "cmpl rax,1\n"
-      "jz 0x................\n"
+      "jz +14\n"
       "movl rax,0\n"
       "movl [rax],rax\n"
       "movl rax,1\n"
       "movl rcx,3\n"
       "shlq rax,cl\n"
       "cmpl rax,8\n"
-      "jz 0x................\n"
+      "jz +14\n"
       "movl rax,0\n"
       "movl [rax],rax\n"
       "movl rax,8\n"
       "movl rcx,3\n"
       "shrq rax,cl\n"
       "cmpl rax,1\n"
-      "jz 0x................\n"
+      "jz +14\n"
       "movl rax,0\n"
       "movl [rax],rax\n"
       "movl rax,1\n"
       "shlq rax,31\n"
       "shrq rax,3\n"
-      "cmpq rax,0x........\n"
-      "jz 0x................\n"
+      "cmpq rax,0x10000000\n"
+      "jz +14\n"
       "movl rax,0\n"
       "movl [rax],rax\n"
       "movl rax,1\n"
       "shlq rax,31\n"
       "sarl rax,3\n"
-      "cmpl rax,0x........\n"
-      "jz 0x................\n"
+      "cmpl rax,0xf0000000\n"
+      "jz +14\n"
       "movl rax,0\n"
       "movl [rax],rax\n"
       "movl rax,1\n"
       "movl rcx,3\n"
       "shlq rax,31\n"
       "sarl rax,cl\n"
-      "cmpl rax,0x........\n"
-      "jz 0x................\n"
+      "cmpl rax,0xf0000000\n"
+      "jz +14\n"
       "movl rax,0\n"
       "movl [rax],rax\n"
-      "movl rdx,-0x........\n"
+      "movl rdx,-0x01000000\n"
       "movl r8,-1\n"
       "movl rcx,2\n"
       "shll rdx,cl\n"
       "shldl rdx,r8,2\n"
-      "cmpl rdx,0x........\n"
-      "jz 0x................\n"
+      "cmpl rdx,0xf0000003\n"
+      "jz +7\n"
       "int3\n"
-      "movq rdx,0x................\n"
+      "movq rdx,0xff00000000000000\n"
       "movq r8,-1\n"
       "movl rcx,2\n"
       "shlq rdx,cl\n"
       "shldq rdx,r8,2\n"
-      "movq r11,0x................\n"
+      "movq r11,0xf000000000000003\n"
       "cmpq rdx,r11\n"
-      "jz 0x................\n"
+      "jz +7\n"
       "int3\n"
-      "movq rdx,0x................\n"
+      "movq rdx,0xff00000000000000\n"
       "movq r8,-1\n"
       "movl rcx,2\n"
       "shlq rdx,cl\n"
       "shldq rdx,r8,cl\n"
-      "movq r11,0x................\n"
+      "movq r11,0xf000000000000003\n"
       "cmpq rdx,r11\n"
-      "jz 0x................\n"
+      "jz +7\n"
       "int3\n"
-      "movq rdx,0x................\n"
+      "movq rdx,0xff00000000000000\n"
       "movq r8,-1\n"
       "movl rcx,2\n"
       "shrq rdx,cl\n"
       "shrdq rdx,r8,cl\n"
-      "movq r11,0x................\n"
+      "movq r11,0xcff0000000000000\n"
       "cmpq rdx,r11\n"
-      "jz 0x................\n"
+      "jz +7\n"
       "int3\n"
       "movl rax,0\n"
       "ret\n");
@@ -2607,126 +2607,126 @@
       "movl rax,4\n"
       "andl rax,2\n"
       "cmpq rax,0\n"
-      "jz 0x................\n"
+      "jz +7\n"
       "int3\n"
       "movl rcx,4\n"
       "push rcx\n"
       "andq rcx,[rsp]\n"
       "pop rax\n"
       "cmpq rcx,0\n"
-      "jnz 0x................\n"
+      "jnz +7\n"
       "int3\n"
       "movl rax,0\n"
       "orq rax,0\n"
       "cmpq rax,0\n"
-      "jz 0x................\n"
+      "jz +7\n"
       "int3\n"
       "movl rax,4\n"
       "orq rax,0\n"
       "cmpq rax,0\n"
-      "jnz 0x................\n"
+      "jnz +7\n"
       "int3\n"
       "push rax\n"
       "movl rax,0xff\n"
       "movq [rsp],rax\n"
       "cmpq [rsp],0xff\n"
-      "jz 0x................\n"
+      "jz +7\n"
       "int3\n"
       "pop rax\n"
       "movl rax,1\n"
       "shlq rax,3\n"
       "cmpq rax,8\n"
-      "jz 0x................\n"
+      "jz +7\n"
       "int3\n"
       "movl rax,2\n"
       "shrq rax,1\n"
       "cmpq rax,1\n"
-      "jz 0x................\n"
+      "jz +7\n"
       "int3\n"
       "movl rax,8\n"
       "shrq rax,3\n"
       "cmpq rax,1\n"
-      "jz 0x................\n"
+      "jz +7\n"
       "int3\n"
       "movl rax,1\n"
       "movl rcx,3\n"
       "shlq rax,cl\n"
       "cmpq rax,8\n"
-      "jz 0x................\n"
+      "jz +7\n"
       "int3\n"
       "movl rax,8\n"
       "movl rcx,3\n"
       "shrq rax,cl\n"
       "cmpq rax,1\n"
-      "jz 0x................\n"
+      "jz +7\n"
       "int3\n"
       "movl rax,1\n"
       "shlq rax,3\n"
       "cmpq rax,8\n"
-      "jz 0x................\n"
+      "jz +14\n"
       "movl rax,0\n"
       "movq [rax],rax\n"
       "movl rax,2\n"
       "shrq rax,1\n"
       "cmpq rax,1\n"
-      "jz 0x................\n"
+      "jz +7\n"
       "int3\n"
       "movl rax,8\n"
       "shrq rax,3\n"
       "cmpq rax,1\n"
-      "jz 0x................\n"
+      "jz +7\n"
       "int3\n"
       "movl rax,1\n"
       "movl rcx,3\n"
       "shlq rax,cl\n"
       "cmpq rax,8\n"
-      "jz 0x................\n"
+      "jz +7\n"
       "int3\n"
       "movl rax,8\n"
       "movl rcx,3\n"
       "shrq rax,cl\n"
       "cmpq rax,1\n"
-      "jz 0x................\n"
+      "jz +7\n"
       "int3\n"
       "movl rax,1\n"
       "shlq rax,31\n"
       "shrq rax,3\n"
-      "cmpq rax,0x........\n"
-      "jz 0x................\n"
+      "cmpq rax,0x10000000\n"
+      "jz +7\n"
       "int3\n"
       "movl rax,1\n"
       "shlq rax,63\n"
       "sarq rax,3\n"
-      "movq r11,0x................\n"
+      "movq r11,0xf000000000000000\n"
       "cmpq rax,r11\n"
-      "jz 0x................\n"
+      "jz +7\n"
       "int3\n"
       "movl rax,1\n"
       "movl rcx,3\n"
       "shlq rax,63\n"
       "sarq rax,cl\n"
-      "movq r11,0x................\n"
+      "movq r11,0xf000000000000000\n"
       "cmpq rax,r11\n"
-      "jz 0x................\n"
+      "jz +7\n"
       "int3\n"
       "push pp\n"
-      "movq pp,0x................\n"
+      "movq pp,0xf000000000000001\n"
       "andq pp,-1\n"
-      "movq r11,0x................\n"
+      "movq r11,0x8000000000000001\n"
       "andq pp,r11\n"
       "orq pp,2\n"
-      "movq r11,0x................\n"
+      "movq r11,0xf800000000000000\n"
       "orq pp,r11\n"
       "xorq pp,1\n"
-      "movq r11,0x................\n"
+      "movq r11,0x0800000000000000\n"
       "xorq pp,r11\n"
-      "movq r11,0x................\n"
+      "movq r11,0xf000000000000002\n"
       "cmpq pp,r11\n"
-      "jz 0x................\n"
+      "jz +7\n"
       "int3\n"
       "andl pp,2\n"
       "cmpq pp,2\n"
-      "jz 0x................\n"
+      "jz +7\n"
       "int3\n"
       "pop pp\n"
       "movl rax,0\n"
@@ -2783,23 +2783,23 @@
       "movl rax,4\n"
       "movl rcx,2\n"
       "testl rax,rcx\n"
-      "jz 0x................\n"
+      "jz +14\n"
       "movl rax,0\n"
       "movl [rax],rax\n"
       "movl rdx,4\n"
       "movl rcx,4\n"
       "testl rdx,rcx\n"
-      "jnz 0x................\n"
+      "jnz +14\n"
       "movl rax,0\n"
       "movl [rax],rax\n"
       "movl rax,0\n"
       "test al,0\n"
-      "jz 0x................\n"
+      "jz +14\n"
       "movl rax,0\n"
       "movl [rax],rax\n"
       "movl rcx,4\n"
       "testb rcx,4\n"
-      "jnz 0x................\n"
+      "jnz +14\n"
       "movl rax,0\n"
       "movl [rax],rax\n"
       "movl rax,0\n"
@@ -2874,33 +2874,33 @@
       "movl rax,4\n"
       "movl rcx,2\n"
       "testq rax,rcx\n"
-      "jz 0x................\n"
+      "jz +14\n"
       "movl rax,0\n"
       "movq [rax],rax\n"
       "movl rdx,4\n"
       "movl rcx,4\n"
       "testq rdx,rcx\n"
-      "jnz 0x................\n"
+      "jnz +14\n"
       "movl rax,0\n"
       "movq [rax],rax\n"
       "movl rax,0\n"
       "test al,0\n"
-      "jz 0x................\n"
+      "jz +14\n"
       "movl rax,0\n"
       "movq [rax],rax\n"
       "movl rcx,4\n"
       "testb rcx,4\n"
-      "jnz 0x................\n"
+      "jnz +14\n"
       "movl rax,0\n"
       "movq [rax],rax\n"
       "movl rcx,0xff\n"
       "testb rcx,0xff\n"
-      "jnz 0x................\n"
+      "jnz +14\n"
       "movl rax,0\n"
       "movq [rax],rax\n"
       "movl rax,0xff\n"
       "test al,0xff\n"
-      "jnz 0x................\n"
+      "jnz +14\n"
       "movl rax,0\n"
       "movq [rax],rax\n"
       "movl rax,0\n"
@@ -2976,7 +2976,7 @@
   EXPECT_EQ(0x100000000,
             reinterpret_cast<CompareSwapEQ32Code>(test->entry())());
   EXPECT_DISASSEMBLY(
-      "movq rax,0x................\n"
+      "movq rax,0x0000000100000000\n"
       "push rax\n"
       "movl rax,4\n"
       "movl rcx,0\n"
@@ -3002,7 +3002,7 @@
   EXPECT_EQ(0x100000004l,
             reinterpret_cast<CompareSwapNEQ32Code>(test->entry())());
   EXPECT_DISASSEMBLY(
-      "movq rax,0x................\n"
+      "movq rax,0x0000000100000000\n"
       "push rax\n"
       "movl rax,2\n"
       "movl rcx,4\n"
@@ -3025,8 +3025,8 @@
   EXPECT_EQ(kAnotherLargeConstant - kLargeConstant,
             reinterpret_cast<Exchange>(test->entry())());
   EXPECT_DISASSEMBLY(
-      "movq rax,0x................\n"
-      "movq rdx,0x................\n"
+      "movq rax,0x1234567887654321\n"
+      "movq rdx,0x0db4da5f7ef412b1\n"
       "xchgq rax,rdx\n"
       "subq rax,rdx\n"
       "ret\n");
@@ -3042,7 +3042,7 @@
   EXPECT_EQ(kLargeConstant,
             reinterpret_cast<LargeConstantCode>(test->entry())());
   EXPECT_DISASSEMBLY(
-      "movq rax,0x................\n"
+      "movq rax,0x1234567887654321\n"
       "ret\n");
 }
 
@@ -3173,7 +3173,7 @@
   typedef float (*SingleFPMovesCode)();
   EXPECT_EQ(234, reinterpret_cast<SingleFPMovesCode>(test->entry())());
   EXPECT_DISASSEMBLY(
-      "movl rax,0x........\n"
+      "movl rax,0x436a0000\n"
       "movd xmm0,rax\n"
       "movss rcx,xmm0\n"
       "movss rdx,xmm1\n"
@@ -3249,7 +3249,7 @@
   typedef float (*SingleFPMoves2Code)();
   EXPECT_EQ(234, reinterpret_cast<SingleFPMoves2Code>(test->entry())());
   EXPECT_DISASSEMBLY(
-      "movl rax,0x........\n"
+      "movl rax,0x436a0000\n"
       "movd xmm0,rax\n"
       "movd xmm8,rax\n"
       "movss rcx,xmm8\n"
@@ -3280,7 +3280,7 @@
   EXPECT_EQ((bit_cast<uint64_t, double>(234.5f)),
             reinterpret_cast<MovqXmmToCpuCode>(test->entry())());
   EXPECT_DISASSEMBLY(
-      "movl rax,0x........\n"
+      "movl rax,0x436a8000\n"
       "movd xmm0,rax\n"
       "cvtss2sd xmm0,xmm0\n"
       "movq rax,xmm0\n"
@@ -3384,7 +3384,7 @@
   EXPECT_FLOAT_EQ(-1.0, res, 0.000001f);
   EXPECT_DISASSEMBLY_NOT_WINDOWS_ENDS_WITH(
       "movups xmm10,[rax]\n"
-      "movq r11,[thr+0x...]\n"
+      "movq r11,[thr+0x2b0]\n"
       "xorpd xmm10,[r11]\n"
       "movaps xmm0,xmm10\n"
       "pop thr\n"
@@ -3413,7 +3413,7 @@
   EXPECT_FLOAT_EQ(1.0, res, 0.000001f);
   EXPECT_DISASSEMBLY_NOT_WINDOWS_ENDS_WITH(
       "movups xmm10,[rax]\n"
-      "movq r11,[thr+0x...]\n"
+      "movq r11,[thr+0x2b8]\n"
       "movups xmm0,[r11]\n"
       "andpd xmm0,xmm10\n"
       "pop thr\n"
@@ -3669,10 +3669,10 @@
   EXPECT_DISASSEMBLY(
       "push rbx\n"
       "push rcx\n"
-      "movl rbx,0x........\n"
+      "movl rbx,0x4144cccd\n"
       "movd xmm0,rbx\n"
       "movd xmm8,rbx\n"
-      "movl rcx,0x........\n"
+      "movl rcx,0x4059999a\n"
       "movd xmm1,rcx\n"
       "movd xmm9,rcx\n"
       "addss xmm0,xmm1\n"
@@ -3710,10 +3710,10 @@
   float res = reinterpret_cast<PackedFPOperationsCode>(test->entry())();
   EXPECT_FLOAT_EQ(14.7f, res, 0.001f);
   EXPECT_DISASSEMBLY(
-      "movl rax,0x........\n"
+      "movl rax,0x4144cccd\n"
       "movd xmm10,rax\n"
       "shufps xmm10,xmm10 [0]\n"
-      "movl rax,0x........\n"
+      "movl rax,0x4059999a\n"
       "movd xmm9,rax\n"
       "shufps xmm9,xmm9 [0]\n"
       "addps xmm10,xmm9\n"
@@ -3829,7 +3829,7 @@
   float res = reinterpret_cast<PackedFPOperations2Code>(test->entry())();
   EXPECT_FLOAT_EQ(0.0f, res, 0.001f);
   EXPECT_DISASSEMBLY(
-      "movl rax,0x........\n"
+      "movl rax,0x40800000\n"
       "movd xmm0,rax\n"
       "shufps xmm0,xmm0 [0]\n"
       "movaps xmm11,xmm0\n"
@@ -3856,10 +3856,10 @@
   uint32_t res = reinterpret_cast<PackedCompareEQCode>(test->entry())();
   EXPECT_EQ(static_cast<uword>(0x0), res);
   EXPECT_DISASSEMBLY(
-      "movl rax,0x........\n"
+      "movl rax,0x40000000\n"
       "movd xmm0,rax\n"
       "shufps xmm0,xmm0 [0]\n"
-      "movl rax,0x........\n"
+      "movl rax,0x40800000\n"
       "movd xmm1,rax\n"
       "shufps xmm1,xmm1 [0]\n"
       "cmpps xmm0,xmm1 [eq]\n"
@@ -3915,10 +3915,10 @@
   uint32_t res = reinterpret_cast<PackedCompareNEQCode>(test->entry())();
   EXPECT_EQ(static_cast<uword>(0xFFFFFFFF), res);
   EXPECT_DISASSEMBLY(
-      "movl rax,0x........\n"
+      "movl rax,0x40000000\n"
       "movd xmm0,rax\n"
       "shufps xmm0,xmm0 [0]\n"
-      "movl rax,0x........\n"
+      "movl rax,0x40800000\n"
       "movd xmm1,rax\n"
       "shufps xmm1,xmm1 [0]\n"
       "cmpps xmm0,xmm1 [neq]\n"
@@ -3943,10 +3943,10 @@
   uint32_t res = reinterpret_cast<PackedCompareLTCode>(test->entry())();
   EXPECT_EQ(static_cast<uword>(0xFFFFFFFF), res);
   EXPECT_DISASSEMBLY(
-      "movl rax,0x........\n"
+      "movl rax,0x40000000\n"
       "movd xmm0,rax\n"
       "shufps xmm0,xmm0 [0]\n"
-      "movl rax,0x........\n"
+      "movl rax,0x40800000\n"
       "movd xmm1,rax\n"
       "shufps xmm1,xmm1 [0]\n"
       "cmpps xmm0,xmm1 [lt]\n"
@@ -3971,10 +3971,10 @@
   uint32_t res = reinterpret_cast<PackedCompareLECode>(test->entry())();
   EXPECT_EQ(static_cast<uword>(0xFFFFFFFF), res);
   EXPECT_DISASSEMBLY(
-      "movl rax,0x........\n"
+      "movl rax,0x40000000\n"
       "movd xmm0,rax\n"
       "shufps xmm0,xmm0 [0]\n"
-      "movl rax,0x........\n"
+      "movl rax,0x40800000\n"
       "movd xmm1,rax\n"
       "shufps xmm1,xmm1 [0]\n"
       "cmpps xmm0,xmm1 [le]\n"
@@ -3999,10 +3999,10 @@
   uint32_t res = reinterpret_cast<PackedCompareNLTCode>(test->entry())();
   EXPECT_EQ(static_cast<uword>(0x0), res);
   EXPECT_DISASSEMBLY(
-      "movl rax,0x........\n"
+      "movl rax,0x40000000\n"
       "movd xmm0,rax\n"
       "shufps xmm0,xmm0 [0]\n"
-      "movl rax,0x........\n"
+      "movl rax,0x40800000\n"
       "movd xmm1,rax\n"
       "shufps xmm1,xmm1 [0]\n"
       "cmpps xmm0,xmm1 [nlt]\n"
@@ -4027,10 +4027,10 @@
   uint32_t res = reinterpret_cast<PackedCompareNLECode>(test->entry())();
   EXPECT_EQ(static_cast<uword>(0x0), res);
   EXPECT_DISASSEMBLY(
-      "movl rax,0x........\n"
+      "movl rax,0x40000000\n"
       "movd xmm0,rax\n"
       "shufps xmm0,xmm0 [0]\n"
-      "movl rax,0x........\n"
+      "movl rax,0x40800000\n"
       "movd xmm1,rax\n"
       "shufps xmm1,xmm1 [0]\n"
       "cmpps xmm0,xmm1 [nle]\n"
@@ -4063,10 +4063,10 @@
       "movq r12,[rdi+0x8]\n"
       "movq thr,rsi\n"
       "movq pp,[r12+0x27]\n"
-      "movl rax,0x........\n"
+      "movl rax,0x4144cccd\n"
       "movd xmm0,rax\n"
       "shufps xmm0,xmm0 [0]\n"
-      "movq r11,[thr+0x...]\n"
+      "movq r11,[thr+0x2c8]\n"
       "xorps xmm0,[r11]\n"
       "shufps xmm0,xmm0 [aa]\n"
       "pop thr\n"
@@ -4100,10 +4100,10 @@
       "movq r12,[rdi+0x8]\n"
       "movq thr,rsi\n"
       "movq pp,[r12+0x27]\n"
-      "movl rax,-0x........\n"
+      "movl rax,-0x3e8b3333\n"
       "movd xmm0,rax\n"
       "shufps xmm0,xmm0 [0]\n"
-      "movq r11,[thr+0x...]\n"
+      "movq r11,[thr+0x2d0]\n"
       "andps xmm0,[r11]\n"
       "shufps xmm0,xmm0 [aa]\n"
       "pop thr\n"
@@ -4135,10 +4135,10 @@
       "movq r12,[rdi+0x8]\n"
       "movq thr,rsi\n"
       "movq pp,[r12+0x27]\n"
-      "movl rax,0x........\n"
+      "movl rax,0x4144cccd\n"
       "movd xmm0,rax\n"
       "shufps xmm0,xmm0 [0]\n"
-      "movq r11,[thr+0x...]\n"
+      "movq r11,[thr+0x2d8]\n"
       "andps xmm0,[r11]\n"
       "shufps xmm0,xmm0 [ff]\n"
       "pop thr\n"
@@ -4161,10 +4161,10 @@
   float res = reinterpret_cast<PackedMinCode>(test->entry())();
   EXPECT_FLOAT_EQ(2.0f, res, 0.001f);
   EXPECT_DISASSEMBLY(
-      "movl rax,0x........\n"
+      "movl rax,0x40000000\n"
       "movd xmm0,rax\n"
       "shufps xmm0,xmm0 [0]\n"
-      "movl rax,0x........\n"
+      "movl rax,0x40800000\n"
       "movd xmm1,rax\n"
       "shufps xmm1,xmm1 [0]\n"
       "minps xmm0,xmm1\n"
@@ -4183,10 +4183,10 @@
   float res = reinterpret_cast<PackedMaxCode>(test->entry())();
   EXPECT_FLOAT_EQ(4.0f, res, 0.001f);
   EXPECT_DISASSEMBLY(
-      "movl rax,0x........\n"
+      "movl rax,0x40000000\n"
       "movd xmm0,rax\n"
       "shufps xmm0,xmm0 [0]\n"
-      "movl rax,0x........\n"
+      "movl rax,0x40800000\n"
       "movd xmm1,rax\n"
       "shufps xmm1,xmm1 [0]\n"
       "maxps xmm0,xmm1\n"
@@ -4288,7 +4288,7 @@
   EXPECT_EQ(static_cast<uword>(0x0), res);
   EXPECT_DISASSEMBLY_NOT_WINDOWS_ENDS_WITH(
       "movups xmm9,[rax]\n"
-      "movq r11,[thr+0x...]\n"
+      "movq r11,[thr+0x2c0]\n"
       "movups xmm0,[r11]\n"
       "xorps xmm0,xmm9\n"
       "push rax\n"
@@ -4635,7 +4635,7 @@
   EXPECT_FLOAT_EQ(1024.67, reinterpret_cast<DoubleFPMovesCode>(test->entry())(),
                   0.001);
   EXPECT_DISASSEMBLY(
-      "movq rax,0x................\n"
+      "movq rax,0x409002ae147ae148\n"
       "push pp\n"
       "push rax\n"
       "movsd xmm0,[rsp]\n"
@@ -4717,11 +4717,11 @@
   double res = reinterpret_cast<SingleFPOperationsCode>(test->entry())();
   EXPECT_FLOAT_EQ(7.668, res, 0.001);
   EXPECT_DISASSEMBLY(
-      "movq rax,0x................\n"
+      "movq rax,0x402899999999999a\n"
       "push rax\n"
       "movsd xmm0,[rsp]\n"
       "movsd xmm8,[rsp]\n"
-      "movq rax,0x................\n"
+      "movq rax,0x400b333333333333\n"
       "movq [rsp],rax\n"
       "movsd xmm12,[rsp]\n"
       "addsd xmm8,xmm12\n"
@@ -4756,9 +4756,9 @@
   double res = reinterpret_cast<Int32ToDoubleConversion>(test->entry())();
   EXPECT_FLOAT_EQ(-2.0, res, 0.001);
   EXPECT_DISASSEMBLY(
-      "movq r11,0x................\n"
+      "movq r11,0x1111111100000006\n"
       "cvtsi2sd xmm0,r11\n"
-      "movq r11,0x................\n"
+      "movq r11,0x2222222200000008\n"
       "cvtsi2sd xmm8,r11\n"
       "subsd xmm0,xmm8\n"
       "ret\n");
@@ -4778,7 +4778,7 @@
   double res = reinterpret_cast<Int64ToDoubleConversionCode>(test->entry())();
   EXPECT_FLOAT_EQ(static_cast<double>(12LL << 32), res, 0.001);
   EXPECT_DISASSEMBLY(
-      "movq rdx,0x................\n"
+      "movq rdx,0x0000000c00000000\n"
       "cvtsi2sd xmm0,rdx\n"
       "movsd xmm15,xmm0\n"
       "addsd xmm0,xmm0\n"
@@ -4818,16 +4818,16 @@
   int64_t res = reinterpret_cast<DoubleToInt64ConversionCode>(test->entry())();
   EXPECT_EQ(420000000000l, res);
   EXPECT_DISASSEMBLY(
-      "movq rax,0x................\n"
+      "movq rax,0x44a1c9a62d04ed0c\n"
       "push rax\n"
       "movsd xmm9,[rsp]\n"
       "pop rax\n"
       "cvttsd2siq rax,xmm9\n"
-      "movq r11,0x................\n"
+      "movq r11,0x8000000000000000\n"
       "cmpq rax,r11\n"
-      "jz 0x................\n"
+      "jz +7\n"
       "int3\n"
-      "movq rax,0x................\n"
+      "movq rax,0x4258727cda000000\n"
       "push rax\n"
       "movsd xmm9,[rsp]\n"
       "movsd xmm6,[rsp]\n"
@@ -4899,26 +4899,26 @@
   int64_t res = reinterpret_cast<DoubleToInt32ConversionCode>(test->entry())();
   EXPECT_EQ(42, res);
   EXPECT_DISASSEMBLY(
-      "movq rax,0x................\n"
+      "movq rax,0x4258727cda000000\n"
       "push rax\n"
       "movsd xmm9,[rsp]\n"
       "pop rax\n"
       "cvttsd2sil rax,xmm9\n"
-      "movl r11,0x........\n"
+      "movl r11,0x80000000\n"
       "cmpq rax,r11\n"
-      "jz 0x................\n"
+      "jz +7\n"
       "int3\n"
-      "movq rax,0x................\n"
+      "movq rax,0xc045000000000000\n"
       "push rax\n"
       "movsd xmm9,[rsp]\n"
       "pop rax\n"
       "movq r10,-1\n"
       "cvttsd2sil r10,xmm9\n"
-      "movl r11,0x........\n"
+      "movl r11,0xffffffd6\n"
       "cmpq r10,r11\n"
-      "jz 0x................\n"
+      "jz +7\n"
       "int3\n"
-      "movq rax,0x................\n"
+      "movq rax,0x4045000000000000\n"
       "push rax\n"
       "movsd xmm9,[rsp]\n"
       "movsd xmm6,[rsp]\n"
@@ -4983,24 +4983,24 @@
       "movq pp,[r12+0x27]\n"
       "movq rax,[pp+0xf]\n"
       "cmpq rax,[pp+0xf]\n"
-      "jnz 0x................\n"
+      "jnz +92\n"
       "movq rcx,[pp+0xf]\n"
       "cmpq rcx,[pp+0xf]\n"
-      "jnz 0x................\n"
+      "jnz +78\n"
       "movl rcx,0x1e\n"
       "cmpq rcx,0x1e\n"
-      "jnz 0x................\n"
+      "jnz +63\n"
       "push rax\n"
       "movq r11,[pp+0xf]\n"
       "movq [rsp],r11\n"
       "pop rcx\n"
       "cmpq rcx,[pp+0xf]\n"
-      "jnz 0x................\n"
+      "jnz +43\n"
       "push rax\n"
       "movq [rsp],0x1e\n"
       "pop rcx\n"
       "cmpq rcx,0x1e\n"
-      "jnz 0x................\n"
+      "jnz +23\n"
       "movl rax,1\n"
       "pop thr\n"
       "pop pp\n"
@@ -5027,24 +5027,24 @@
       "movq pp,[r12+0x27]\n"
       "movq rax,[pp+0xf]\n"
       "cmpl rax,[pp+0xf]\n"
-      "jnz 0x................\n"
+      "jnz +90\n"
       "movq rcx,[pp+0xf]\n"
       "cmpl rcx,[pp+0xf]\n"
-      "jnz 0x................\n"
+      "jnz +76\n"
       "movl rcx,0x1e\n"
       "cmpl rcx,0x1e\n"
-      "jnz 0x................\n"
+      "jnz +62\n"
       "push rax\n"
       "movq r11,[pp+0xf]\n"
       "movq [rsp],r11\n"
       "pop rcx\n"
       "cmpl rcx,[pp+0xf]\n"
-      "jnz 0x................\n"
+      "jnz +42\n"
       "push rax\n"
       "movq [rsp],0x1e\n"
       "pop rcx\n"
       "cmpl rcx,0x1e\n"
-      "jnz 0x................\n"
+      "jnz +23\n"
       "movl rax,1\n"
       "pop thr\n"
       "pop pp\n"
@@ -5207,7 +5207,7 @@
   unsigned int res = reinterpret_cast<TestNot>(test->entry())();
   EXPECT_EQ(0xFFFFFFFF, res);
   EXPECT_DISASSEMBLY(
-      "movq rax,0x................\n"
+      "movq rax,0xffffffff00000000\n"
       "notq rax\n"
       "ret\n");
 }
@@ -5269,7 +5269,7 @@
       "xorpd xmm0,xmm0\n"
       "xorpd xmm0,xmm15\n"
       "comisd xmm0,xmm15\n"
-      "jz 0x................\n"
+      "jz +7\n"
       "int3\n"
       "ret\n");
 }
@@ -5334,7 +5334,7 @@
   int64_t res = reinterpret_cast<DoubleFPUStackMovesCode>(test->entry())();
   EXPECT_FLOAT_EQ(1024.67, (bit_cast<double, int64_t>(res)), 0.001);
   EXPECT_DISASSEMBLY(
-      "movq rax,0x................\n"
+      "movq rax,0x409002ae147ae148\n"
       "push rax\n"
       "fld_d [rsp]\n"
       "movq [rsp],0\n"
@@ -5464,7 +5464,7 @@
       "movq r12,[rdi+0x8]\n"
       "movq thr,rsi\n"
       "movq pp,[r12+0x27]\n"
-      "movq r11,[thr+0x...]\n"
+      "movq r11,[thr+0x2b8]\n"
       "andpd xmm0,[r11]\n"
       "pop thr\n"
       "pop pp\n"
@@ -5506,7 +5506,7 @@
   uword res = reinterpret_cast<TestSetCC>(test->entry())();
   EXPECT_EQ(0xFFFFFF00, res);
   EXPECT_DISASSEMBLY(
-      "movl rax,0x........\n"
+      "movl rax,0xffffffff\n"
       "cmpq rax,rax\n"
       "setnzl rax\n"
       "ret\n");
@@ -5528,7 +5528,7 @@
   EXPECT_EQ(0xFFFF01FF, res);
   EXPECT_DISASSEMBLY(
       "push rbx\n"
-      "movl rbx,0x........\n"
+      "movl rbx,0xffffffff\n"
       "cmpq rbx,rbx\n"
       "setzl rdi\n"
       "movq rax,rbx\n"
@@ -5552,7 +5552,7 @@
   EXPECT_EQ(0xFFFFFF00, res);
   EXPECT_DISASSEMBLY(
       "push r10\n"
-      "movl r10,0x........\n"
+      "movl r10,0xffffffff\n"
       "cmpq r10,r10\n"
       "setnzl r10\n"
       "movq rax,r10\n"
@@ -5576,7 +5576,7 @@
   EXPECT_EQ(0xFFFFFF01, res);
   EXPECT_DISASSEMBLY(
       "push rsi\n"
-      "movl rsi,0x........\n"
+      "movl rsi,0xffffffff\n"
       "cmpq rsi,rsi\n"
       "setzl rsi\n"
       "movq rax,rsi\n"
@@ -5834,7 +5834,7 @@
       "movl rax,4\n"
       "movl r11,2\n"
       "btq rax,r11\n"
-      "jc 0x................\n"
+      "jc +7\n"
       "int3\n"
       "movl rax,1\n"
       "ret\n");
@@ -5857,7 +5857,7 @@
   EXPECT_DISASSEMBLY(
       "movl r11,0x20\n"
       "bt r11,5\n"
-      "jc 0x................\n"
+      "jc +7\n"
       "int3\n"
       "movl rax,1\n"
       "ret\n");
@@ -5882,7 +5882,7 @@
   EXPECT_DISASSEMBLY_ENDS_WITH(
       "xorq rax,rax\n"
       "movl rcx,1\n"
-      "cmpq rdx,0x...\n"
+      "cmpq rdx,0x311\n"
       "cmovzq rax,rcx\n"
       "ret\n");
 }
@@ -6006,61 +6006,61 @@
   EXPECT_EQ(42, res);
   EXPECT_DISASSEMBLY(
       "movl rax,0x2a\n"
-      "imulq rax,rax,0x........\n"
-      "movq r11,0x................\n"
+      "imulq rax,rax,0x3b9aca00\n"
+      "movq r11,0x00000009c7652400\n"
       "cmpq rax,r11\n"
-      "jz 0x................\n"
+      "jz +7\n"
       "int3\n"
       "movl rax,0x2a\n"
-      "imull rax,rax,0x........\n"
-      "movl r11,0x........\n"
+      "imull rax,rax,0x3b9aca00\n"
+      "movl r11,0xc7652400\n"
       "cmpq rax,r11\n"
-      "jz 0x................\n"
+      "jz +7\n"
       "int3\n"
-      "movl rax,0x........\n"
-      "movq r11,0x................\n"
+      "movl rax,0x3b9aca00\n"
+      "movq r11,0x000000098bca5a00\n"
       "addq rax,r11\n"
-      "movq r11,0x................\n"
+      "movq r11,0x00000009c7652400\n"
       "cmpq rax,r11\n"
-      "jz 0x................\n"
+      "jz +7\n"
       "int3\n"
-      "movl rax,0x........\n"
-      "addl rax,0x........\n"
-      "addl rax,0x........\n"
-      "addl rax,0x........\n"
-      "movl r11,0x........\n"
+      "movl rax,0x3b9aca00\n"
+      "addl rax,0x3b9aca00\n"
+      "addl rax,0x3b9aca00\n"
+      "addl rax,0x3b9aca00\n"
+      "movl r11,0xee6b2800\n"
       "cmpq rax,r11\n"
-      "jz 0x................\n"
+      "jz +7\n"
       "int3\n"
-      "movl rax,0x........\n"
-      "subl rax,0x........\n"
-      "addl rax,0x........\n"
-      "subl rax,0x........\n"
-      "movl r11,0x........\n"
+      "movl rax,0x3b9aca00\n"
+      "subl rax,0x4d2fa200\n"
+      "addl rax,0x3b9aca00\n"
+      "subl rax,0x3b9aca00\n"
+      "movl r11,0xee6b2800\n"
       "cmpq rax,r11\n"
-      "jz 0x................\n"
+      "jz +7\n"
       "int3\n"
-      "movl rax,0x........\n"
-      "movq r11,0x................\n"
+      "movl rax,0x3b9aca00\n"
+      "movq r11,0x0000000a02ffee00\n"
       "subq rax,r11\n"
-      "movq r11,0x................\n"
+      "movq r11,0xfffffff6389adc00\n"
       "cmpq rax,r11\n"
-      "jz 0x................\n"
+      "jz +7\n"
       "int3\n"
-      "movq rax,-0x........\n"
-      "subl rax,0x........\n"
-      "subl rax,0x........\n"
-      "subl rax,0x........\n"
-      "cmpq rax,0x........\n"
-      "jz 0x................\n"
+      "movq rax,-0x3b9aca00\n"
+      "subl rax,0x3b9aca00\n"
+      "subl rax,0x3b9aca00\n"
+      "subl rax,0x3b9aca00\n"
+      "cmpq rax,0x1194d800\n"
+      "jz +7\n"
       "int3\n"
-      "movl rax,0x........\n"
-      "subl rax,0x........\n"
-      "subl rax,0x........\n"
-      "addl rax,0x........\n"
-      "movl r11,0x........\n"
+      "movl rax,0x3b9aca00\n"
+      "subl rax,0x4d2fa200\n"
+      "subl rax,0x3b9aca00\n"
+      "addl rax,0x3b9aca00\n"
+      "movl r11,0xee6b2800\n"
       "cmpq rax,r11\n"
-      "jz 0x................\n"
+      "jz +7\n"
       "int3\n"
       "movl rax,0x2a\n"
       "ret\n");
@@ -6261,10 +6261,10 @@
       "push rcx\n"
       "xorq rcx,rcx\n"
       "push rcx\n"
-      "subq rsp,0x...\n"
-      "movq [rsp+0x...],rdx\n"
-      "movq rax,[rsp+0x...]\n"
-      "addq rsp,0x...\n"
+      "subq rsp,0x400\n"
+      "movq [rsp+0x400],rdx\n"
+      "movq rax,[rsp+0x400]\n"
+      "addq rsp,0x400\n"
       "pop rcx\n"
       "pop rcx\n"
       "ret\n");
diff --git a/runtime/vm/compiler/assembler/disassembler_arm64.cc b/runtime/vm/compiler/assembler/disassembler_arm64.cc
index 8f441ef..ced8987 100644
--- a/runtime/vm/compiler/assembler/disassembler_arm64.cc
+++ b/runtime/vm/compiler/assembler/disassembler_arm64.cc
@@ -836,8 +836,8 @@
         }
       }
       if ((s_imm != (reg_size - 1)) && ((s_imm + 1) == r_imm)) {
-        int shift = reg_size - s_imm;
-        Format(instr, "lsl'sf 'rd, 'rn, ");
+        int shift = reg_size - s_imm - 1;
+        Format(instr, "lsl'sf 'rd, 'rn, #");
         PrintInt(shift);
         break;
       } else if (s_imm == (reg_size - 1)) {
diff --git a/runtime/vm/compiler/assembler/disassembler_x86.cc b/runtime/vm/compiler/assembler/disassembler_x86.cc
index 77021e4..fb4c917 100644
--- a/runtime/vm/compiler/assembler/disassembler_x86.cc
+++ b/runtime/vm/compiler/assembler/disassembler_x86.cc
@@ -404,9 +404,14 @@
   switch (mod) {
     case 0:
       if ((rm & 7) == 5) {
+#if defined(TARGET_ARCH_IA32)
+        int32_t abs = LoadUnaligned(reinterpret_cast<int32_t*>(modrmp + 1));
+        Print("[%#x]", abs);
+#else
         int32_t disp = LoadUnaligned(reinterpret_cast<int32_t*>(modrmp + 1));
         Print("[rip");
         PrintDisp(disp, "]");
+#endif
         return 5;
       } else if ((rm & 7) == 4) {
         // Codes for SIB byte.
diff --git a/runtime/vm/unit_test.cc b/runtime/vm/unit_test.cc
index e96548eb7..a2478ad 100644
--- a/runtime/vm/unit_test.cc
+++ b/runtime/vm/unit_test.cc
@@ -667,7 +667,7 @@
   return Api::NewHandle(thread, val.ptr());
 }
 
-#if !defined(PRODUCT)
+#if !defined(PRODUCT) && defined(TARGET_ARCH_IA32)
 static bool IsHex(int c) {
   return ('0' <= c && c <= '9') || ('a' <= c && c <= 'f');
 }
@@ -695,6 +695,8 @@
   code_.set_owner(function);
   code_.set_exception_handlers(Object::empty_exception_handlers());
 #ifndef PRODUCT
+  // Disassemble relative since code addresses are not stable from run to run.
+  SetFlagScope<bool> sfs(&FLAG_disassemble_relative, true);
   uword start = code_.PayloadStart();
   if (FLAG_disassemble) {
     OS::PrintErr("Code for test '%s' {\n", name_);
@@ -703,7 +705,9 @@
   }
   Disassembler::Disassemble(start, start + assembler_->CodeSize(), disassembly_,
                             DISASSEMBLY_SIZE);
-  // Blank out big hex constants, since they are not stable from run to run.
+#if defined(TARGET_ARCH_IA32)
+  // Blank out absolute addressing constants, since they are not stable from run
+  // to run.
   bool in_hex_constant = false;
   for (char* p = disassembly_; *p != '\0'; p++) {
     if (in_hex_constant) {
@@ -713,13 +717,14 @@
         in_hex_constant = false;
       }
     } else {
-      if (*p == '0' && *(p + 1) == 'x' && IsHex(*(p + 2)) && IsHex(*(p + 3)) &&
+      if (*p == '[' && *(p + 1) == '0' && *(p + 2) == 'x' && IsHex(*(p + 3)) &&
           IsHex(*(p + 4))) {
-        p++;
+        p += 2;
         in_hex_constant = true;
       }
     }
   }
+#endif  // TARGET_ARCH_IA32
 #endif  // !PRODUCT
 }
 
diff --git a/runtime/vm/unit_test.h b/runtime/vm/unit_test.h
index 7bc9f23..bc86b9e 100644
--- a/runtime/vm/unit_test.h
+++ b/runtime/vm/unit_test.h
@@ -587,8 +587,8 @@
   // Assemble test and set code_.
   void Assemble();
 
-  // Disassembly of the code with large constants blanked out.
-  char* BlankedDisassembly() { return disassembly_; }
+  // Disassembly of the code with relative branch/jump targets.
+  char* RelativeDisassembly() { return disassembly_; }
 
  private:
   const char* name_;
diff --git a/tools/VERSION b/tools/VERSION
index 5d1e0e8..2ce508d 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 16
 PATCH 0
-PRERELEASE 95
+PRERELEASE 96
 PRERELEASE_PATCH 0
\ No newline at end of file