Optimize the emitted instruction of random function for X64

src/x64/assembler-x64.h

 // 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 401 matching lines @@
   bool AddressUsesRegister(Register reg) const;
 
   // Queries related to the size of the generated instruction.
   // Whether the generated instruction will have a REX prefix.
   bool requires_rex() const { return rex_ != 0; }
   // Size of the ModR/M, SIB and displacement parts of the generated
   // instruction.
   int operand_size() const { return len_; }
 
  private:
+  explicit Operand(Register reg);

[Jakob Kummerow, 2013/01/11 17:43:38]

On x64 so far, an Operand always means a memory access, and I'd like to keep
that consistency. So please don't add this constructor. Instead, please
implement an overloaded version of movzxwl that takes two registers as input
(similar to how we have two versions of movsxlq).

+
   byte rex_;
   byte buf_[6];
   // The number of bytes of buf_ in use.
   byte len_;
 
   // Set the ModR/M byte without an encoded 'reg' register. The
   // register is encoded later as part of the emit_operand operation.
   // set_modrm can be called before or after set_sib and set_disp*.
   inline void set_modrm(int mod, Register rm);
 
@@ skipping 293 matching lines @@
   void movq(Register dst, Handle<Object> handle, RelocInfo::Mode rmode);
 
   void movsxbq(Register dst, const Operand& src);
   void movsxwq(Register dst, const Operand& src);
   void movsxlq(Register dst, Register src);
   void movsxlq(Register dst, const Operand& src);
   void movzxbq(Register dst, const Operand& src);
   void movzxbl(Register dst, const Operand& src);
   void movzxwq(Register dst, const Operand& src);
   void movzxwl(Register dst, const Operand& src);
+  void movzxwl(Register dst, Register src) { movzxwl(dst, Operand(src)); }
 
   // Repeated moves.
 
   void repmovsb();
   void repmovsw();
   void repmovsl();
   void repmovsq();
 
   // Instruction to load from an immediate 64-bit pointer into RAX.
   void load_rax(void* ptr, RelocInfo::Mode rmode);
@@ skipping 922 matching lines @@
  private:
   Assembler* assembler_;
 #ifdef DEBUG
   int space_before_;
 #endif
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_X64_ASSEMBLER_X64_H_