therubyracer 0.4.7-x86-darwin-9

data/ext/v8/upstream/2.0.6/test/cctest/test-disasm-arm.cc

@@ -0,0 +1,281 @@
+// Copyright 2007-2008 the V8 project authors. All rights reserved.
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+//       copyright notice, this list of conditions and the following
+//       disclaimer in the documentation and/or other materials provided
+//       with the distribution.
+//     * Neither the name of Google Inc. nor the names of its
+//       contributors may be used to endorse or promote products derived
+//       from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+
+#include <stdlib.h>
+
+#include "v8.h"
+
+#include "debug.h"
+#include "disasm.h"
+#include "disassembler.h"
+#include "macro-assembler.h"
+#include "serialize.h"
+#include "cctest.h"
+
+using namespace v8::internal;
+
+
+static v8::Persistent<v8::Context> env;
+
+static void InitializeVM() {
+  if (env.IsEmpty()) {
+    env = v8::Context::New();
+  }
+}
+
+
+bool DisassembleAndCompare(byte* pc, const char* compare_string) {
+  disasm::NameConverter converter;
+  disasm::Disassembler disasm(converter);
+  EmbeddedVector<char, 128> disasm_buffer;
+
+  disasm.InstructionDecode(disasm_buffer, pc);
+
+  if (strcmp(compare_string, disasm_buffer.start()) != 0) {
+    fprintf(stderr,
+            "expected: \n"
+            "%s\n"
+            "disassembled: \n"
+            "%s\n\n",
+            compare_string, disasm_buffer.start());
+    return false;
+  }
+  return true;
+}
+
+
+// Setup V8 to a state where we can at least run the assembler and
+// disassembler. Declare the variables and allocate the data structures used
+// in the rest of the macros.
+#define SETUP() \
+  InitializeVM(); \
+  v8::HandleScope scope; \
+  byte *buffer = reinterpret_cast<byte*>(malloc(4*1024)); \
+  Assembler assm(buffer, 4*1024); \
+  bool failure = false;
+
+
+// This macro assembles one instruction using the preallocated assembler and
+// disassembles the generated instruction, comparing the output to the expected
+// value. If the comparison fails an error message is printed, but the test
+// continues to run until the end.
+#define COMPARE(asm_, compare_string) \
+  { \
+    int pc_offset = assm.pc_offset(); \
+    byte *pc = &buffer[pc_offset]; \
+    assm.asm_; \
+    if (!DisassembleAndCompare(pc, compare_string)) failure = true; \
+  }
+
+
+// Verify that all invocations of the COMPARE macro passed successfully.
+// Exit with a failure if at least one of the tests failed.
+#define VERIFY_RUN() \
+if (failure) { \
+    V8_Fatal(__FILE__, __LINE__, "ARM Disassembler tests failed.\n"); \
+  }
+
+
+TEST(Type0) {
+  SETUP();
+
+  COMPARE(and_(r0, r1, Operand(r2)),
+          "e0010002       and r0, r1, r2");
+  COMPARE(and_(r1, r2, Operand(r3), LeaveCC),
+          "e0021003       and r1, r2, r3");
+  COMPARE(and_(r2, r3, Operand(r4), SetCC),
+          "e0132004       ands r2, r3, r4");
+  COMPARE(and_(r3, r4, Operand(r5), LeaveCC, eq),
+          "00043005       andeq r3, r4, r5");
+
+  COMPARE(eor(r4, r5, Operand(r6, LSL, 0)),
+          "e0254006       eor r4, r5, r6");
+  COMPARE(eor(r4, r5, Operand(r7, LSL, 1), SetCC),
+          "e0354087       eors r4, r5, r7, lsl #1");
+  COMPARE(eor(r4, r5, Operand(r8, LSL, 2), LeaveCC, ne),
+          "10254108       eorne r4, r5, r8, lsl #2");
+  COMPARE(eor(r4, r5, Operand(r9, LSL, 3), SetCC, cs),
+          "20354189       eorcss r4, r5, r9, lsl #3");
+
+  COMPARE(sub(r5, r6, Operand(r10, LSL, 31), LeaveCC, hs),
+          "20465f8a       subcs r5, r6, r10, lsl #31");
+  COMPARE(sub(r5, r6, Operand(r10, LSL, 30), SetCC, cc),
+          "30565f0a       subccs r5, r6, r10, lsl #30");
+  COMPARE(sub(r5, r6, Operand(r10, LSL, 24), LeaveCC, lo),
+          "30465c0a       subcc r5, r6, r10, lsl #24");
+  COMPARE(sub(r5, r6, Operand(r10, LSL, 16), SetCC, mi),
+          "4056580a       submis r5, r6, r10, lsl #16");
+
+  COMPARE(rsb(r6, r7, Operand(fp)),
+          "e067600b       rsb r6, r7, fp");
+  COMPARE(rsb(r6, r7, Operand(fp, LSR, 1)),
+          "e06760ab       rsb r6, r7, fp, lsr #1");
+  COMPARE(rsb(r6, r7, Operand(fp, LSR, 0), SetCC),
+          "e077602b       rsbs r6, r7, fp, lsr #32");
+  COMPARE(rsb(r6, r7, Operand(fp, LSR, 31), LeaveCC, pl),
+          "50676fab       rsbpl r6, r7, fp, lsr #31");
+
+  COMPARE(add(r7, r8, Operand(ip, ASR, 1)),
+          "e08870cc       add r7, r8, ip, asr #1");
+  COMPARE(add(r7, r8, Operand(ip, ASR, 0)),
+          "e088704c       add r7, r8, ip, asr #32");
+  COMPARE(add(r7, r8, Operand(ip), SetCC),
+          "e098700c       adds r7, r8, ip");
+  COMPARE(add(r7, r8, Operand(ip, ASR, 31), SetCC, vs),
+          "60987fcc       addvss r7, r8, ip, asr #31");
+
+  COMPARE(adc(r7, fp, Operand(ip, ASR, 5)),
+          "e0ab72cc       adc r7, fp, ip, asr #5");
+  COMPARE(adc(r4, ip, Operand(ip, ASR, 1), LeaveCC, vc),
+          "70ac40cc       adcvc r4, ip, ip, asr #1");
+  COMPARE(adc(r5, sp, Operand(ip), SetCC),
+          "e0bd500c       adcs r5, sp, ip");
+  COMPARE(adc(r8, lr, Operand(ip, ASR, 31), SetCC, vc),
+          "70be8fcc       adcvcs r8, lr, ip, asr #31");
+
+  COMPARE(sbc(r7, r1, Operand(ip, ROR, 1), LeaveCC, hi),
+          "80c170ec       sbchi r7, r1, ip, ror #1");
+  COMPARE(sbc(r7, r9, Operand(ip, ROR, 4)),
+          "e0c9726c       sbc r7, r9, ip, ror #4");
+  COMPARE(sbc(r7, r10, Operand(ip), SetCC),
+          "e0da700c       sbcs r7, r10, ip");
+  COMPARE(sbc(r7, ip, Operand(ip, ROR, 31), SetCC, hi),
+          "80dc7fec       sbchis r7, ip, ip, ror #31");
+
+  COMPARE(rsc(r7, r8, Operand(ip, LSL, r0)),
+          "e0e8701c       rsc r7, r8, ip, lsl r0");
+  COMPARE(rsc(r7, r8, Operand(ip, LSL, r1)),
+          "e0e8711c       rsc r7, r8, ip, lsl r1");
+  COMPARE(rsc(r7, r8, Operand(ip), SetCC),
+          "e0f8700c       rscs r7, r8, ip");
+  COMPARE(rsc(r7, r8, Operand(ip, LSL, r3), SetCC, ls),
+          "90f8731c       rsclss r7, r8, ip, lsl r3");
+
+  COMPARE(tst(r7, Operand(r5, ASR, ip), ge),
+          "a1170c55       tstge r7, r5, asr ip");
+  COMPARE(tst(r7, Operand(r6, ASR, sp)),
+          "e1170d56       tst r7, r6, asr sp");
+  COMPARE(tst(r7, Operand(r7), ge),
+          "a1170007       tstge r7, r7");
+  COMPARE(tst(r7, Operand(r8, ASR, fp), ge),
+          "a1170b58       tstge r7, r8, asr fp");
+
+  COMPARE(teq(r7, Operand(r5, ROR, r0), lt),
+          "b1370075       teqlt r7, r5, ror r0");
+  COMPARE(teq(r7, Operand(r6, ROR, lr)),
+          "e1370e76       teq r7, r6, ror lr");
+  COMPARE(teq(r7, Operand(r7), lt),
+          "b1370007       teqlt r7, r7");
+  COMPARE(teq(r7, Operand(r8, ROR, r1)),
+          "e1370178       teq r7, r8, ror r1");
+
+  COMPARE(cmp(r7, Operand(r4)),
+          "e1570004       cmp r7, r4");
+  COMPARE(cmp(r7, Operand(r6, LSL, 1), gt),
+          "c1570086       cmpgt r7, r6, lsl #1");
+  COMPARE(cmp(r7, Operand(r8, LSR, 3), gt),
+          "c15701a8       cmpgt r7, r8, lsr #3");
+  COMPARE(cmp(r7, Operand(r8, ASR, 19)),
+          "e15709c8       cmp r7, r8, asr #19");
+
+  COMPARE(cmn(r0, Operand(r4)),
+          "e1700004       cmn r0, r4");
+  COMPARE(cmn(r1, Operand(r6, ROR, 1)),
+          "e17100e6       cmn r1, r6, ror #1");
+  COMPARE(cmn(r2, Operand(r8)),
+          "e1720008       cmn r2, r8");
+  COMPARE(cmn(r3, Operand(fp), le),
+          "d173000b       cmnle r3, fp");
+
+  COMPARE(orr(r7, r8, Operand(lr), LeaveCC, al),
+          "e188700e       orr r7, r8, lr");
+  COMPARE(orr(r7, r8, Operand(fp)),
+          "e188700b       orr r7, r8, fp");
+  COMPARE(orr(r7, r8, Operand(sp), SetCC),
+          "e198700d       orrs r7, r8, sp");
+  COMPARE(orr(r7, r8, Operand(ip), SetCC, al),
+          "e198700c       orrs r7, r8, ip");
+
+  COMPARE(mov(r0, Operand(r1), LeaveCC, eq),
+          "01a00001       moveq r0, r1");
+  COMPARE(mov(r0, Operand(r2)),
+          "e1a00002       mov r0, r2");
+  COMPARE(mov(r0, Operand(r3), SetCC),
+          "e1b00003       movs r0, r3");
+  COMPARE(mov(r0, Operand(r4), SetCC, pl),
+          "51b00004       movpls r0, r4");
+
+  COMPARE(bic(r0, lr, Operand(r1), LeaveCC, vs),
+          "61ce0001       bicvs r0, lr, r1");
+  COMPARE(bic(r0, r9, Operand(r2), LeaveCC, vc),
+          "71c90002       bicvc r0, r9, r2");
+  COMPARE(bic(r0, r5, Operand(r3), SetCC),
+          "e1d50003       bics r0, r5, r3");
+  COMPARE(bic(r0, r1, Operand(r4), SetCC, pl),
+          "51d10004       bicpls r0, r1, r4");
+
+  COMPARE(mvn(r10, Operand(r1)),
+          "e1e0a001       mvn r10, r1");
+  COMPARE(mvn(r9, Operand(r2)),
+          "e1e09002       mvn r9, r2");
+  COMPARE(mvn(r0, Operand(r3), SetCC),
+          "e1f00003       mvns r0, r3");
+  COMPARE(mvn(r5, Operand(r4), SetCC, cc),
+          "31f05004       mvnccs r5, r4");
+
+  VERIFY_RUN();
+}
+
+
+TEST(Type1) {
+  SETUP();
+
+  COMPARE(and_(r0, r1, Operand(0x00000000)),
+          "e2010000       and r0, r1, #0");
+  COMPARE(and_(r1, r2, Operand(0x00000001), LeaveCC),
+          "e2021001       and r1, r2, #1");
+  COMPARE(and_(r2, r3, Operand(0x00000010), SetCC),
+          "e2132010       ands r2, r3, #16");
+  COMPARE(and_(r3, r4, Operand(0x00000100), LeaveCC, eq),
+          "02043c01       andeq r3, r4, #256");
+  COMPARE(and_(r4, r5, Operand(0x00001000), SetCC, ne),
+          "12154a01       andnes r4, r5, #4096");
+
+  COMPARE(eor(r4, r5, Operand(0x00001000)),
+          "e2254a01       eor r4, r5, #4096");
+  COMPARE(eor(r4, r4, Operand(0x00010000), LeaveCC),
+          "e2244801       eor r4, r4, #65536");
+  COMPARE(eor(r4, r3, Operand(0x00100000), SetCC),
+          "e2334601       eors r4, r3, #1048576");
+  COMPARE(eor(r4, r2, Operand(0x01000000), LeaveCC, cs),
+          "22224401       eorcs r4, r2, #16777216");
+  COMPARE(eor(r4, r1, Operand(0x10000000), SetCC, cc),
+          "32314201       eorccs r4, r1, #268435456");
+
+  VERIFY_RUN();
+}

data/ext/v8/upstream/2.0.6/test/cctest/test-disasm-ia32.cc

@@ -0,0 +1,418 @@
+// Copyright 2007-2008 the V8 project authors. All rights reserved.
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+//       copyright notice, this list of conditions and the following
+//       disclaimer in the documentation and/or other materials provided
+//       with the distribution.
+//     * Neither the name of Google Inc. nor the names of its
+//       contributors may be used to endorse or promote products derived
+//       from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include <stdlib.h>
+
+#include "v8.h"
+
+#include "debug.h"
+#include "disasm.h"
+#include "disassembler.h"
+#include "macro-assembler.h"
+#include "serialize.h"
+#include "cctest.h"
+
+using namespace v8::internal;
+
+static v8::Persistent<v8::Context> env;
+
+static void InitializeVM() {
+  if (env.IsEmpty()) {
+    env = v8::Context::New();
+  }
+}
+
+
+#define __ assm.
+
+
+static void DummyStaticFunction(Object* result) {
+}
+
+
+TEST(DisasmIa320) {
+  InitializeVM();
+  v8::HandleScope scope;
+  v8::internal::byte buffer[2048];
+  Assembler assm(buffer, sizeof buffer);
+  DummyStaticFunction(NULL);  // just bloody use it (DELETE; debugging)
+
+  // Short immediate instructions
+  __ adc(eax, 12345678);
+  __ add(Operand(eax), Immediate(12345678));
+  __ or_(eax, 12345678);
+  __ sub(Operand(eax), Immediate(12345678));
+  __ xor_(eax, 12345678);
+  __ and_(eax, 12345678);
+  Handle<FixedArray> foo = Factory::NewFixedArray(10, TENURED);
+  __ cmp(eax, foo);
+
+  // ---- This one caused crash
+  __ mov(ebx,  Operand(esp, ecx, times_2, 0));  // [esp+ecx*4]
+
+  // ---- All instructions that I can think of
+  __ add(edx, Operand(ebx));
+  __ add(edx, Operand(12, RelocInfo::NONE));
+  __ add(edx, Operand(ebx, 0));
+  __ add(edx, Operand(ebx, 16));
+  __ add(edx, Operand(ebx, 1999));
+  __ add(edx, Operand(esp, 0));
+  __ add(edx, Operand(esp, 16));
+  __ add(edx, Operand(esp, 1999));
+  __ nop();
+  __ add(edi, Operand(ebp, ecx, times_4, 0));
+  __ add(edi, Operand(ebp, ecx, times_4, 12));
+  __ add(Operand(ebp, ecx, times_4, 12), Immediate(12));
+
+  __ nop();
+  __ add(Operand(ebx), Immediate(12));
+  __ nop();
+  __ adc(ecx, 12);
+  __ adc(ecx, 1000);
+  __ nop();
+  __ and_(edx, 3);
+  __ and_(edx, Operand(esp, 4));
+  __ cmp(edx, 3);
+  __ cmp(edx, Operand(esp, 4));
+  __ cmp(Operand(ebp, ecx, times_4, 0), Immediate(1000));
+  Handle<FixedArray> foo2 = Factory::NewFixedArray(10, TENURED);
+  __ cmp(ebx, foo2);
+  __ or_(edx, 3);
+  __ xor_(edx, 3);
+  __ nop();
+  {
+    CHECK(CpuFeatures::IsSupported(CPUID));
+    CpuFeatures::Scope fscope(CPUID);
+    __ cpuid();
+  }
+  {
+    CHECK(CpuFeatures::IsSupported(RDTSC));
+    CpuFeatures::Scope fscope(RDTSC);
+    __ rdtsc();
+  }
+  __ movsx_b(edx, Operand(ecx));
+  __ movsx_w(edx, Operand(ecx));
+  __ movzx_b(edx, Operand(ecx));
+  __ movzx_w(edx, Operand(ecx));
+
+  __ nop();
+  __ imul(edx, Operand(ecx));
+  __ shld(edx, Operand(ecx));
+  __ shrd(edx, Operand(ecx));
+  __ bts(Operand(edx), ecx);
+  __ bts(Operand(ebx, ecx, times_4, 0), ecx);
+  __ nop();
+  __ pushad();
+  __ popad();
+  __ pushfd();
+  __ popfd();
+  __ push(Immediate(12));
+  __ push(Immediate(23456));
+  __ push(ecx);
+  __ push(esi);
+  __ push(Operand(ebp, JavaScriptFrameConstants::kFunctionOffset));
+  __ push(Operand(ebx, ecx, times_4, 0));
+  __ push(Operand(ebx, ecx, times_4, 0));
+  __ push(Operand(ebx, ecx, times_4, 10000));
+  __ pop(edx);
+  __ pop(eax);
+  __ pop(Operand(ebx, ecx, times_4, 0));
+  __ nop();
+
+  __ add(edx, Operand(esp, 16));
+  __ add(edx, Operand(ecx));
+  __ mov_b(edx, Operand(ecx));
+  __ mov_b(Operand(ecx), 6);
+  __ mov_b(Operand(ebx, ecx, times_4, 10000), 6);
+  __ mov_b(Operand(esp, 16), edx);
+  __ mov_w(edx, Operand(esp, 16));
+  __ mov_w(Operand(esp, 16), edx);
+  __ nop();
+  __ movsx_w(edx, Operand(esp, 12));
+  __ movsx_b(edx, Operand(esp, 12));
+  __ movzx_w(edx, Operand(esp, 12));
+  __ movzx_b(edx, Operand(esp, 12));
+  __ nop();
+  __ mov(edx, 1234567);
+  __ mov(edx, Operand(esp, 12));
+  __ mov(Operand(ebx, ecx, times_4, 10000), Immediate(12345));
+  __ mov(Operand(ebx, ecx, times_4, 10000), edx);
+  __ nop();
+  __ dec_b(edx);
+  __ dec(edx);
+  __ cdq();
+
+  __ nop();
+  __ idiv(edx);
+  __ mul(edx);
+  __ neg(edx);
+  __ not_(edx);
+  __ test(Operand(ebx, ecx, times_4, 10000), Immediate(123456));
+
+  __ imul(edx, Operand(ebx, ecx, times_4, 10000));
+  __ imul(edx, ecx, 12);
+  __ imul(edx, ecx, 1000);
+
+  __ inc(edx);
+  __ inc(Operand(ebx, ecx, times_4, 10000));
+  __ push(Operand(ebx, ecx, times_4, 10000));
+  __ pop(Operand(ebx, ecx, times_4, 10000));
+  __ call(Operand(ebx, ecx, times_4, 10000));
+  __ jmp(Operand(ebx, ecx, times_4, 10000));
+
+  __ lea(edx, Operand(ebx, ecx, times_4, 10000));
+  __ or_(edx, 12345);
+  __ or_(edx, Operand(ebx, ecx, times_4, 10000));
+
+  __ nop();
+
+  __ rcl(edx, 1);
+  __ rcl(edx, 7);
+  __ sar(edx, 1);
+  __ sar(edx, 6);
+  __ sar_cl(edx);
+  __ sbb(edx, Operand(ebx, ecx, times_4, 10000));
+  __ shld(edx, Operand(ebx, ecx, times_4, 10000));
+  __ shl(edx, 1);
+  __ shl(edx, 6);
+  __ shl_cl(edx);
+  __ shrd(edx, Operand(ebx, ecx, times_4, 10000));
+  __ shr(edx, 1);
+  __ shr(edx, 7);
+  __ shr_cl(edx);
+
+
+  // Immediates
+
+  __ adc(edx, 12345);
+
+  __ add(Operand(ebx), Immediate(12));
+  __ add(Operand(edx, ecx, times_4, 10000), Immediate(12));
+
+  __ and_(ebx, 12345);
+
+  __ cmp(ebx, 12345);
+  __ cmp(Operand(ebx), Immediate(12));
+  __ cmp(Operand(edx, ecx, times_4, 10000), Immediate(12));
+
+  __ or_(ebx, 12345);
+
+  __ sub(Operand(ebx), Immediate(12));
+  __ sub(Operand(edx, ecx, times_4, 10000), Immediate(12));
+  __ subb(Operand(edx, ecx, times_4, 10000), 100);
+  __ subb(Operand(eax), 100);
+  __ subb(eax, Operand(edx, ecx, times_4, 10000));
+
+  __ xor_(ebx, 12345);
+
+  __ imul(edx, ecx, 12);
+  __ imul(edx, ecx, 1000);
+
+  __ rep_movs();
+
+  __ sub(edx, Operand(ebx, ecx, times_4, 10000));
+  __ sub(edx, Operand(ebx));
+
+  __ test(edx, Immediate(12345));
+  __ test(edx, Operand(ebx, ecx, times_8, 10000));
+  __ nop();
+
+  __ xor_(edx, 12345);
+  __ xor_(edx, Operand(ebx, ecx, times_8, 10000));
+  __ bts(Operand(ebx, ecx, times_8, 10000), edx);
+  __ hlt();
+  __ int3();
+  __ ret(0);
+  __ ret(8);
+
+  // Calls
+
+  Label L1, L2;
+  __ bind(&L1);
+  __ nop();
+  __ call(&L1);
+  __ call(&L2);
+  __ nop();
+  __ bind(&L2);
+  __ call(Operand(ebx, ecx, times_4, 10000));
+  __ nop();
+  Handle<Code> ic(Builtins::builtin(Builtins::LoadIC_Initialize));
+  __ call(ic, RelocInfo::CODE_TARGET);
+  __ nop();
+  __ call(FUNCTION_ADDR(DummyStaticFunction), RelocInfo::RUNTIME_ENTRY);
+  __ nop();
+
+  __ jmp(&L1);
+  __ jmp(Operand(ebx, ecx, times_4, 10000));
+  ExternalReference after_break_target =
+      ExternalReference(Debug_Address::AfterBreakTarget());
+  __ jmp(Operand::StaticVariable(after_break_target));
+  __ jmp(ic, RelocInfo::CODE_TARGET);
+  __ nop();
+
+
+  Label Ljcc;
+  __ nop();
+  // long jumps
+  __ j(overflow, &Ljcc);
+  __ j(no_overflow, &Ljcc);
+  __ j(below, &Ljcc);
+  __ j(above_equal, &Ljcc);
+  __ j(equal, &Ljcc);
+  __ j(not_equal, &Ljcc);
+  __ j(below_equal, &Ljcc);
+  __ j(above, &Ljcc);
+  __ j(sign, &Ljcc);
+  __ j(not_sign, &Ljcc);
+  __ j(parity_even, &Ljcc);
+  __ j(parity_odd, &Ljcc);
+  __ j(less, &Ljcc);
+  __ j(greater_equal, &Ljcc);
+  __ j(less_equal, &Ljcc);
+  __ j(greater, &Ljcc);
+  __ nop();
+  __ bind(&Ljcc);
+  // short jumps
+  __ j(overflow, &Ljcc);
+  __ j(no_overflow, &Ljcc);
+  __ j(below, &Ljcc);
+  __ j(above_equal, &Ljcc);
+  __ j(equal, &Ljcc);
+  __ j(not_equal, &Ljcc);
+  __ j(below_equal, &Ljcc);
+  __ j(above, &Ljcc);
+  __ j(sign, &Ljcc);
+  __ j(not_sign, &Ljcc);
+  __ j(parity_even, &Ljcc);
+  __ j(parity_odd, &Ljcc);
+  __ j(less, &Ljcc);
+  __ j(greater_equal, &Ljcc);
+  __ j(less_equal, &Ljcc);
+  __ j(greater, &Ljcc);
+
+  // checking hints
+  __ j(zero, &Ljcc, taken);
+  __ j(zero, &Ljcc, not_taken);
+
+  // __ mov(Operand::StaticVariable(Top::handler_address()), eax);
+  // 0xD9 instructions
+  __ nop();
+
+  __ fld1();
+  __ fldz();
+  __ fabs();
+  __ fchs();
+  __ fprem();
+  __ fprem1();
+  __ fincstp();
+  __ ftst();
+  __ fxch(3);
+  __ fld_s(Operand(ebx, ecx, times_4, 10000));
+  __ fstp_s(Operand(ebx, ecx, times_4, 10000));
+  __ ffree(3);
+  __ fld_d(Operand(ebx, ecx, times_4, 10000));
+  __ fstp_d(Operand(ebx, ecx, times_4, 10000));
+  __ nop();
+
+  __ fild_s(Operand(ebx, ecx, times_4, 10000));
+  __ fistp_s(Operand(ebx, ecx, times_4, 10000));
+  __ fild_d(Operand(ebx, ecx, times_4, 10000));
+  __ fistp_d(Operand(ebx, ecx, times_4, 10000));
+  __ fnstsw_ax();
+  __ nop();
+  __ fadd(3);
+  __ fsub(3);
+  __ fmul(3);
+  __ fdiv(3);
+
+  __ faddp(3);
+  __ fsubp(3);
+  __ fmulp(3);
+  __ fdivp(3);
+  __ fcompp();
+  __ fwait();
+  __ nop();
+  {
+    CHECK(CpuFeatures::IsSupported(SSE2));
+    CpuFeatures::Scope fscope(SSE2);
+    __ cvttss2si(edx, Operand(ebx, ecx, times_4, 10000));
+    __ cvtsi2sd(xmm1, Operand(ebx, ecx, times_4, 10000));
+    __ addsd(xmm1, xmm0);
+    __ mulsd(xmm1, xmm0);
+    __ subsd(xmm1, xmm0);
+    __ divsd(xmm1, xmm0);
+    __ movdbl(xmm1, Operand(ebx, ecx, times_4, 10000));
+    __ movdbl(Operand(ebx, ecx, times_4, 10000), xmm1);
+    __ comisd(xmm0, xmm1);
+
+    // 128 bit move instructions.
+    __ movdqa(xmm0, Operand(ebx, ecx, times_4, 10000));
+    __ movdqa(Operand(ebx, ecx, times_4, 10000), xmm0);
+    __ movdqu(xmm0, Operand(ebx, ecx, times_4, 10000));
+    __ movdqu(Operand(ebx, ecx, times_4, 10000), xmm0);
+  }
+
+  // cmov.
+  {
+    CHECK(CpuFeatures::IsSupported(CMOV));
+    CpuFeatures::Scope use_cmov(CMOV);
+    __ cmov(overflow, eax, Operand(eax, 0));
+    __ cmov(no_overflow, eax, Operand(eax, 1));
+    __ cmov(below, eax, Operand(eax, 2));
+    __ cmov(above_equal, eax, Operand(eax, 3));
+    __ cmov(equal, eax, Operand(ebx, 0));
+    __ cmov(not_equal, eax, Operand(ebx, 1));
+    __ cmov(below_equal, eax, Operand(ebx, 2));
+    __ cmov(above, eax, Operand(ebx, 3));
+    __ cmov(sign, eax, Operand(ecx, 0));
+    __ cmov(not_sign, eax, Operand(ecx, 1));
+    __ cmov(parity_even, eax, Operand(ecx, 2));
+    __ cmov(parity_odd, eax, Operand(ecx, 3));
+    __ cmov(less, eax, Operand(edx, 0));
+    __ cmov(greater_equal, eax, Operand(edx, 1));
+    __ cmov(less_equal, eax, Operand(edx, 2));
+    __ cmov(greater, eax, Operand(edx, 3));
+  }
+
+  __ ret(0);
+
+  CodeDesc desc;
+  assm.GetCode(&desc);
+  Object* code = Heap::CreateCode(desc,
+                                  NULL,
+                                  Code::ComputeFlags(Code::STUB),
+                                  Handle<Object>(Heap::undefined_value()));
+  CHECK(code->IsCode());
+#ifdef DEBUG
+  Code::cast(code)->Print();
+  byte* begin = Code::cast(code)->instruction_start();
+  byte* end = begin + Code::cast(code)->instruction_size();
+  disasm::Disassembler::Disassemble(stdout, begin, end);
+#endif
+}
+
+#undef __