Avoid memmove when emitting operands in the assembler ...

src/assembler-ia32.cc

 // Copyright (c) 1994-2006 Sun Microsystems Inc.
 // All Rights Reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions
 // are met:
 //
 // - Redistributions of source code must retain the above copyright notice,
 // this list of conditions and the following disclaimer.
 //
@@ skipping 237 matching lines @@
   len_ = 2;
 }
 
 
 void Operand::set_disp8(int8_t disp) {
   ASSERT(len_ == 1 || len_ == 2);
   *reinterpret_cast<int8_t*>(&buf_[len_++]) = disp;
 }
 
 
-void Operand::set_reg(Register reg) const {
-  ASSERT(len_ > 0);
-  buf_[0] = (buf_[0] & ~0x38) | static_cast<byte>(reg.code() << 3);
-}
-
-
 bool Operand::is_reg(Register reg) const {
   return ((buf_[0] & 0xF8) == 0xC0)  // addressing mode is register only.
       && ((buf_[0] & 0x07) == reg.code());  // register codes match.
 }
 
 // -----------------------------------------------------------------------------
 // Implementation of Assembler
 
 // Emit a single byte. Must always be inlined.
 #define EMIT(x)                                 \
@@ skipping 1817 matching lines @@
     emit(x);
   } else {
     EMIT(0x81);  // using a literal 32-bit immediate.
     emit_operand(ireg, dst);
     emit(x);
   }
 }
 
 
 void Assembler::emit_operand(Register reg, const Operand& adr) {
-  adr.set_reg(reg);
-  memmove(pc_, adr.buf_, adr.len_);
-  pc_ += adr.len_;
-  if (adr.len_ >= sizeof(int32_t) && adr.rmode_ != RelocInfo::NONE) {
+  const unsigned length = adr.len_;
+  ASSERT(length > 0);
+
+  // Emit updated ModRM byte containing the given register.
+  pc_[0] = (adr.buf_[0] & ~0x38) | (reg.code() << 3);
+
+  // Emit the rest of the encoded operand.
+  for (unsigned i = 1; i < length; i++) pc_[i] = adr.buf_[i];
+  pc_ += length;
+
+  // Emit relocation information if necessary.
+  if (length >= sizeof(int32_t) && adr.rmode_ != RelocInfo::NONE) {
     pc_ -= sizeof(int32_t);  // pc_ must be *at* disp32
     RecordRelocInfo(adr.rmode_);
     pc_ += sizeof(int32_t);
   }
 }
 
 
 void Assembler::emit_farith(int b1, int b2, int i) {
   ASSERT(is_uint8(b1) && is_uint8(b2));  // wrong opcode
   ASSERT(0 <= i &&  i < 8);  // illegal stack offset
@@ skipping 25 matching lines @@
   ASSERT(bound_label.is_bound());
   ASSERT(0 <= position);
   ASSERT(position + static_cast<int>(sizeof(uint32_t)) <= pc_offset());
   ASSERT(long_at(position) == 0);  // only initialize once!
 
   uint32_t label_loc = reinterpret_cast<uint32_t>(addr_at(bound_label.pos()));
   long_at_put(position, label_loc);
 }
 
 } }  // namespace v8::internal