X64 Crankshaft: Added a bunch of operations.

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 135 matching lines @@
   }
   // Return the 3 low bits of the register code.  Used when encoding registers
   // in modR/M, SIB, and opcode bytes.
   int low_bits() const {
     return code_ & 0x7;
   }
 
   // Unfortunately we can't make this private in a struct when initializing
   // by assignment.
   int code_;
+
  private:
   static const int registerCodeByAllocationIndex[kNumAllocatableRegisters];
   static const int allocationIndexByRegisterCode[kNumRegisters];
 };
 
 const Register rax = { 0 };
 const Register rcx = { 1 };
 const Register rdx = { 2 };
 const Register rbx = { 3 };
 const Register rsp = { 4 };
@@ skipping 217 matching lines @@
   // [index*scale + disp/r]
   Operand(Register index,
           ScaleFactor scale,
           int32_t disp);
 
   // Offset from existing memory operand.
   // Offset is added to existing displacement as 32-bit signed values and
   // this must not overflow.
   Operand(const Operand& base, int32_t offset);
 
+  // Checks whether either base or index register is the given reg.
+  // Does not check the "reg" part of the Operand.
+  bool depends_on_register(Register reg) const {

[William Hesse, 2011/01/24 16:25:27]

Could you call it address_uses_register() ?

[Lasse Reichstein, 2011/01/25 10:13:27]

It should probably even be AddressUsesRegister.
And it's a big function. I'll move it to the .cc file.

+    int code = reg.code();
+    ASSERT((buf_[0] & 0xC0) != 0xC0);  // Always a memory operand.
+    int base_bits = buf_[0] & 0x07;
+    int base_code;
+    if (base_bits == 0x04) {
+      // SIB byte present in buf_[1].
+      // Check the index register from the SIB byte + REX.X prefix.
+      int index_code = ((buf_[1] >> 3) & 0x07) | ((rex_ & 0x02) << 2);
+      // Index code (including REX.X) of 0x04 (esp) means no index register.

[Rico, 2011/01/25 07:13:28]

esp -> rsp

[Lasse Reichstein, 2011/01/25 10:13:27]

Done.

+      if (index_code != 0x04 && index_code == code) return true;

[Rico, 2011/01/25 07:13:28]

What about using rsp.code() instead of 0x04

[Lasse Reichstein, 2011/01/25 10:13:27]

Done, and also rbp.code() instead of 0x05 later.

+      // Add REX.B to base_bits to get base register code.
+      base_bits = (buf_[1] & 0x07) | ((rex_ & 0x01) << 3);
+      base_code = base_bits;
+    } else {
+      // Add REX.B to base_bits to get base register code.
+      base_code = base_bits | ((rex_ & 0x01) << 3);
+    }
+    // Base register is unused if mod = 0 and r/m = 5 (ebp).
+    // Comparison uses REX.B if using the SIB byte, otherwise not.

[William Hesse, 2011/01/24 16:25:27]

instead of "if using the SIB byte", say "if base_code came from the SIB byte". 
Maybe it is simpler if you have only base_code = buf_[0] & 0x7, test against
0x05, then test against 0x04, and finally inside SIB byte test the 4-bit bit
code against 0x05 again.  Then there is no need for the base_bits variable.

[Lasse Reichstein, 2011/01/25 10:13:27]

I have rewritten it so the two branches have no shared code. They now differ on
when the REX.B bit is added to the base_code value (before or after testing for
r/m=rbp,mod=0).

+    if (base_bits == 0x05 && ((buf_[0] & 0xC0) == 0)) return false;
+    return code == base_code;
+  }
+
  private:
   byte rex_;
   byte buf_[6];
   // The number of bytes in buf_.
   unsigned int 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 411 matching lines @@
   }
 
   void andl(Register dst, Immediate src) {
     immediate_arithmetic_op_32(0x4, dst, src);
   }
 
   void andl(Register dst, Register src) {
     arithmetic_op_32(0x23, dst, src);
   }
 
+  void andl(Register dst, const Operand& src) {

[William Hesse, 2011/01/24 16:25:27]

Add to disassembler.

[Lasse Reichstein, 2011/01/25 10:13:27]

This one is already there (it's one of the fairly generic "arithmetic"
operations, where we are just adding another case).

+    arithmetic_op_32(0x23, dst, src);
+  }
+
   void andb(Register dst, Immediate src) {
     immediate_arithmetic_op_8(0x4, dst, src);
   }
 
   void decq(Register dst);
   void decq(const Operand& dst);
   void decl(Register dst);
   void decl(const Operand& dst);
   void decb(Register dst);
   void decb(const Operand& dst);
@@ skipping 364 matching lines @@
   void movd(XMMRegister dst, Register src);
   void movd(Register dst, XMMRegister src);
   void movq(XMMRegister dst, Register src);
   void movq(Register dst, XMMRegister src);
   void extractps(Register dst, XMMRegister src, byte imm8);
 
   void movsd(const Operand& dst, XMMRegister src);
   void movsd(XMMRegister dst, XMMRegister src);
   void movsd(XMMRegister dst, const Operand& src);
 
+  void movdqa(const Operand& dst, XMMRegister src);

[William Hesse, 2011/01/24 16:25:27]

Add to disassembler.

[Lasse Reichstein, 2011/01/25 10:13:27]

Done.

+  void movdqa(XMMRegister dst, const Operand& src);
+
   void movss(XMMRegister dst, const Operand& src);
   void movss(const Operand& dst, XMMRegister src);
 
   void cvttss2si(Register dst, const Operand& src);
   void cvttss2si(Register dst, XMMRegister src);
   void cvttsd2si(Register dst, const Operand& src);
   void cvttsd2si(Register dst, XMMRegister src);
   void cvttsd2siq(Register dst, XMMRegister src);
 
   void cvtlsi2sd(XMMRegister dst, const Operand& src);
@@ skipping 20 matching lines @@
 
   void ucomisd(XMMRegister dst, XMMRegister src);
   void ucomisd(XMMRegister dst, const Operand& src);
 
   // The first argument is the reg field, the second argument is the r/m field.
   void emit_sse_operand(XMMRegister dst, XMMRegister src);
   void emit_sse_operand(XMMRegister reg, const Operand& adr);
   void emit_sse_operand(XMMRegister dst, Register src);
   void emit_sse_operand(Register dst, XMMRegister src);
 
   // Use either movsd or movlpd.

[William Hesse, 2011/01/24 16:25:27]

I commented these, but did not remove them.  We should remove them.

[Lasse Reichstein, 2011/01/25 10:13:27]

Done.

   // void movdbl(XMMRegister dst, const Operand& src);
   // void movdbl(const Operand& dst, XMMRegister src);
 
   // Debugging
   void Print();
 
   // Check the code size generated from label to here.
   int SizeOfCodeGeneratedSince(Label* l) { return pc_offset() - l->pos(); }
 
   // Mark address of the ExitJSFrame code.
@@ skipping 265 matching lines @@
  private:
   Assembler* assembler_;
 #ifdef DEBUG
   int space_before_;
 #endif
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_X64_ASSEMBLER_X64_H_