Add immediate operands and arithmetic operations to the x64 assembler.

src/x64/assembler-x64.cc

 // Copyright 2009 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
@@ skipping 283 matching lines @@
   pc_[0] = (adr.buf_[0] & ~0x38) | ((reg.code() && 0x7) << 3);
 
   // Emit the rest of the encoded operand.
   for (unsigned i = 1; i < length; i++) pc_[i] = adr.buf_[i];
   pc_ += length;
 }
 
 
 // Assembler Instruction implementations
 
-void Assembler::add(Register dst, const Operand& src) {
+void Assembler::arithmetic_op(byte opcode, Register reg, const Operand& op) {
+  EnsureSpace ensure_space(this);
+  last_pc_ = pc_;
+  emit_rex_64(reg, op);
+  EMIT(opcode);
+  emit_operand(reg, op);
+}
+
+
+void Assembler::arithmetic_op(byte opcode, Register dst, Register src) {
   EnsureSpace ensure_space(this);
   last_pc_ = pc_;
   emit_rex_64(dst, src);
-  EMIT(0x03);
-  emit_operand(dst, src);
+  EMIT(opcode);
+  EMIT(0xC0 | (dst.code() & 0x7) << 3 | (src.code() & 0x7));
 }
 
-
-void Assembler::add(Register dst, Register src) {
+void Assembler::immediate_arithmetic_op(byte subcode,
+                                        Register dst,
+                                        Immediate src) {
   EnsureSpace ensure_space(this);
   last_pc_ = pc_;
-  emit_rex_64(dst, src);
-  EMIT(0x03);
-  EMIT(0xC0 | (dst.code() & 0x7) << 3 | (src.code() & 0x7));
+  emit_rex_64(rax, dst);
+  if (is_int8(src.value_)) {
+    EMIT(0x83);
+    EMIT(0xC0 | (subcode << 3) | (dst.code() & 0x7));
+    EMIT(src.value_);
+  } else {
+    EMIT(0x81);
+    EMIT(0xC0 | (subcode << 3) | (dst.code() & 0x7));
+    emitl(src.value_);
+  }
+}
+
+void Assembler::immediate_arithmetic_op(byte subcode,
+                                        const Operand& dst,
+                                        Immediate src) {
+  EnsureSpace ensure_space(this);
+  last_pc_ = pc_;
+  emit_rex_64(rax, dst);
+  if (is_int8(src.value_)) {
+    EMIT(0x83);
+    emit_operand(Register::toRegister(subcode), dst);
+    EMIT(src.value_);
+  } else {
+    EMIT(0x81);
+    emit_operand(Register::toRegister(subcode), dst);
+    emitl(src.value_);
+  }
 }
 
 
 void Assembler::call(Label* L) {
   EnsureSpace ensure_space(this);
   last_pc_ = pc_;
   // 1110 1000 #32-bit disp
   EMIT(0xE8);
   if (L->is_bound()) {
     int offset = L->pos() - pc_offset() - sizeof(int32_t);
     ASSERT(offset <= 0);
-    emit(offset);
+    emitl(offset);
   } else if (L->is_linked()) {
-    emit(L->pos());
+    emitl(L->pos());
     L->link_to(pc_offset() - sizeof(int32_t));
   } else {
     ASSERT(L->is_unused());
     int32_t current = pc_offset();
-    emit(current);
+    emitl(current);
     L->link_to(current);
   }
 }
 
 
 void Assembler::dec(Register dst) {
   EnsureSpace ensure_space(this);
   last_pc_ = pc_;
   emit_rex_64(rcx, dst);
   EMIT(0xFF);
@@ skipping 52 matching lines @@
     int offs = L->pos() - pc_offset();
     ASSERT(offs <= 0);
     if (is_int8(offs - short_size)) {
       // 0111 tttn #8-bit disp
       EMIT(0x70 | cc);
       EMIT((offs - short_size) & 0xFF);
     } else {
       // 0000 1111 1000 tttn #32-bit disp
       EMIT(0x0F);
       EMIT(0x80 | cc);
-      emit(offs - long_size);
+      emitl(offs - long_size);
     }
   } else if (L->is_linked()) {
     // 0000 1111 1000 tttn #32-bit disp
     EMIT(0x0F);
     EMIT(0x80 | cc);
-    emit(L->pos());
+    emitl(L->pos());
     L->link_to(pc_offset() - sizeof(int32_t));
   } else {
     ASSERT(L->is_unused());
     EMIT(0x0F);
     EMIT(0x80 | cc);
     int32_t current = pc_offset();
-    emit(current);
+    emitl(current);
     L->link_to(current);
   }
 }
 
 
 void Assembler::jmp(Label* L) {
   EnsureSpace ensure_space(this);
   last_pc_ = pc_;
   if (L->is_bound()) {
     int offs = L->pos() - pc_offset() - 1;
     ASSERT(offs <= 0);
     if (is_int8(offs - sizeof(int8_t))) {
       // 1110 1011 #8-bit disp
       EMIT(0xEB);
       EMIT((offs - sizeof(int8_t)) & 0xFF);
     } else {
       // 1110 1001 #32-bit disp
       EMIT(0xE9);
-      emit(offs - sizeof(int32_t));
+      emitl(offs - sizeof(int32_t));
     }
   } else  if (L->is_linked()) {
     // 1110 1001 #32-bit disp
     EMIT(0xE9);
-    emit(L->pos());
+    emitl(L->pos());
     L->link_to(pc_offset() - sizeof(int32_t));
   } else {
     // 1110 1001 #32-bit disp
     ASSERT(L->is_unused());
     EMIT(0xE9);
     int32_t current = pc_offset();
-    emit(current);
+    emitl(current);
     L->link_to(current);
   }
 }
 
 
-void Assembler::mov(Register dst, const Operand& src) {
+void Assembler::movq(Register dst, const Operand& src) {
   EnsureSpace ensure_space(this);
   last_pc_ = pc_;
   emit_rex_64(dst, src);
   EMIT(0x8B);
   emit_operand(dst, src);
 }
 
 
-void Assembler::mov(Register dst, Register src) {
+void Assembler::movq(Register dst, Register src) {
   EnsureSpace ensure_space(this);
   last_pc_ = pc_;
   emit_rex_64(dst, src);
   EMIT(0x8B);
   EMIT(0xC0 | (dst.code() & 0x7) << 3 | (src.code() & 0x7));
 }
 
 
+void Assembler::movq(Register dst, Immediate value) {
+  EnsureSpace ensure_space(this);
+  last_pc_ = pc_;
+  emit_rex_64(rax, dst);
+  EMIT(0xC7);
+  EMIT(0xC0 | (dst.code() & 0x7));
+  emit(value);  // Only 32-bit immediates are possible, not 8-bit immediates.
+}
+
+
+void Assembler::movq(Register dst, int64_t value, RelocInfo::Mode rmode) {
+  EnsureSpace ensure_space(this);
+  last_pc_ = pc_;
+  emit_rex_64(rax, dst);
+  EMIT(0xB8 | (dst.code() & 0x7));
+  emitq(value, rmode);
+}
+
+
 void Assembler::nop() {
   EnsureSpace ensure_space(this);
   last_pc_ = pc_;
   EMIT(0x90);
 }
 
+
 void Assembler::pop(Register dst) {
   EnsureSpace ensure_space(this);
   last_pc_ = pc_;
   if (dst.code() & 0x8) {
     emit_rex_64(rax, dst);
   }
   EMIT(0x58 | (dst.code() & 0x7));
 }
 
 
@@ skipping 312 matching lines @@
   UNIMPLEMENTED();
   return NULL;
 }
 
 byte* JavaScriptFrame::GetCallerStackPointer() const {
   UNIMPLEMENTED();
   return NULL;
 }
 
 } }  // namespace v8::internal