Teach the assembler how to generate multi-byte nops. Teach the

runtime/vm/assembler_ia32.cc

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/globals.h"
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/assembler.h"
 #include "vm/heap.h"
 #include "vm/memory_region.h"
@@ skipping 1078 matching lines @@
 
 void Assembler::ret(const Immediate& imm) {
   AssemblerBuffer::EnsureCapacity ensured(&buffer_);
   EmitUint8(0xC2);
   ASSERT(imm.is_uint16());
   EmitUint8(imm.value() & 0xFF);
   EmitUint8((imm.value() >> 8) & 0xFF);
 }
 
 
-
-void Assembler::nop() {
+void Assembler::nop(int size) {
   AssemblerBuffer::EnsureCapacity ensured(&buffer_);
-  EmitUint8(0x90);
+  // There are nops up to size 15, but for now just provide up to size 8.
+  ASSERT(0 < size && size <= MAX_NOP_SIZE);

[srdjan, 2011/12/08 22:18:12]

I would document this limitation in header file.

[turnidge, 2011/12/08 23:04:57]

Done.

+  switch (size) {
+    case 1:
+      EmitUint8(0x90);
+      break;
+    case 2:
+      EmitUint8(0x66);
+      EmitUint8(0x90);
+      break;
+    case 3:
+      EmitUint8(0x0F);
+      EmitUint8(0x1F);
+      EmitUint8(0x00);
+      break;
+    case 4:
+      EmitUint8(0x0F);
+      EmitUint8(0x1F);
+      EmitUint8(0x40);
+      EmitUint8(0x00);
+      break;
+    case 5:
+      EmitUint8(0x0F);
+      EmitUint8(0x1F);
+      EmitUint8(0x44);
+      EmitUint8(0x00);
+      EmitUint8(0x00);
+      break;
+    case 6:
+      EmitUint8(0x66);
+      EmitUint8(0x0F);
+      EmitUint8(0x1F);
+      EmitUint8(0x44);
+      EmitUint8(0x00);
+      EmitUint8(0x00);
+      break;
+    case 7:
+      EmitUint8(0x0F);
+      EmitUint8(0x1F);
+      EmitUint8(0x80);
+      EmitUint8(0x00);
+      EmitUint8(0x00);
+      EmitUint8(0x00);
+      EmitUint8(0x00);
+      break;
+    case 8:
+      EmitUint8(0x0F);
+      EmitUint8(0x1F);
+      EmitUint8(0x84);
+      EmitUint8(0x00);
+      EmitUint8(0x00);
+      EmitUint8(0x00);
+      EmitUint8(0x00);
+      EmitUint8(0x00);
+      break;
+    default:
+      UNIMPLEMENTED();
+  }
 }
 
 
 void Assembler::int3() {
   AssemblerBuffer::EnsureCapacity ensured(&buffer_);
   EmitUint8(0xCC);
 }
 
 
 void Assembler::hlt() {
@@ skipping 213 matching lines @@
 }
 
 
 void Assembler::CallRuntimeFromStub(const RuntimeEntry& entry) {
   entry.CallFromStub(this);
 }
 
 
 void Assembler::Align(int alignment, int offset) {
   ASSERT(Utils::IsPowerOfTwo(alignment));
-  // Emit nop instruction until the real position is aligned.
-  while (((offset + buffer_.GetPosition()) & (alignment-1)) != 0) {
-    nop();
+  int pos = offset + buffer_.GetPosition();
+  int mod = pos & (alignment - 1);
+  if (mod == 0) {
+    return;
   }
+  int bytes_needed = alignment - mod;
+  while (bytes_needed > MAX_NOP_SIZE) {
+    nop(MAX_NOP_SIZE);
+    bytes_needed -= MAX_NOP_SIZE;
+  }
+  if (bytes_needed) {
+    nop(bytes_needed);
+  }
+  ASSERT(((offset + buffer_.GetPosition()) & (alignment-1)) == 0);
 }
 
 
 void Assembler::Bind(Label* label) {
   int bound = buffer_.Size();
   ASSERT(!label->IsBound());  // Labels can only be bound once.
   while (label->IsLinked()) {
     int position = label->LinkPosition();
     int next = buffer_.Load<int32_t>(position);
     buffer_.Store<int32_t>(position, bound - (position + 4));
@@ skipping 106 matching lines @@
                                  Register shifter) {
   AssemblerBuffer::EnsureCapacity ensured(&buffer_);
   ASSERT(shifter == ECX);
   EmitUint8(0xD3);
   EmitOperand(rm, Operand(operand));
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32