Eliminates more large immediates from x64 code.

runtime/vm/assembler_x64.h

 // Copyright (c) 2013, 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.
 
 #ifndef VM_ASSEMBLER_X64_H_
 #define VM_ASSEMBLER_X64_H_
 
 #ifndef VM_ASSEMBLER_H_
 #error Do not include assembler_x64.h directly; use assembler.h instead.
 #endif
@@ skipping 338 matching lines @@
   void call(Register reg);
   void call(const Address& address);
   void call(Label* label);
   void call(const ExternalLabel* label);
 
   static const intptr_t kCallExternalLabelSize = 10;
 
   void pushq(Register reg);
   void pushq(const Address& address);
   void pushq(const Immediate& imm);
+  void PushImmediate(const Immediate& imm, Register pp);
 
   void popq(Register reg);
   void popq(const Address& address);
 
   void setcc(Condition condition, ByteRegister dst);
 
   void movl(Register dst, Register src);
   void movl(Register dst, const Immediate& imm);
   void movl(Register dst, const Address& src);
   void movl(const Address& dst, Register src);
@@ skipping 113 matching lines @@
   void cmpl(Register reg0, Register reg1);
   void cmpl(Register reg, const Address& address);
   void cmpl(const Address& address, const Immediate& imm);
 
   void cmpq(Register reg, const Immediate& imm);
   void cmpq(const Address& address, Register reg);
   void cmpq(const Address& address, const Immediate& imm);
   void cmpq(Register reg0, Register reg1);
   void cmpq(Register reg, const Address& address);
 
+  void CompareImmediate(Register reg, const Immediate& imm, Register pp);
+  void CompareImmediate(const Address& address, const Immediate& imm,
+                        Register pp);
+
   void testl(Register reg1, Register reg2);
   void testl(Register reg, const Immediate& imm);
 
   void testq(Register reg1, Register reg2);
   void testq(Register reg, const Immediate& imm);
 
   void andl(Register dst, Register src);
   void andl(Register dst, const Immediate& imm);
 
   void orl(Register dst, Register src);
   void orl(Register dst, const Immediate& imm);
 
   void xorl(Register dst, Register src);
 
   void andq(Register dst, Register src);
   void andq(Register dst, const Address& address);
   void andq(Register dst, const Immediate& imm);
+  void AndImmediate(Register dst, const Immediate& imm, Register pp);
 
   void orq(Register dst, Register src);
   void orq(Register dst, const Address& address);
   void orq(Register dst, const Immediate& imm);
+  void OrImmediate(Register dst, const Immediate& imm, Register pp);
 
   void xorq(Register dst, Register src);
   void xorq(Register dst, const Address& address);
   void xorq(const Address& dst, Register src);
   void xorq(Register dst, const Immediate& imm);
+  void XorImmediate(Register dst, const Immediate& imm, Register pp);
 
   void addl(Register dst, Register src);
   void addl(const Address& address, const Immediate& imm);
 
   void addq(Register dst, Register src);
   void addq(Register reg, const Immediate& imm);
   void addq(Register reg, const Address& address);
   void addq(const Address& address, const Immediate& imm);
   void addq(const Address& address, Register reg);
 
   void adcl(Register dst, Register src);
 
   void subl(Register dst, Register src);
 
   void cdq();
   void cqo();
 
   void idivl(Register reg);
   void idivq(Register reg);
 
   void imull(Register dst, Register src);
   void imull(Register reg, const Immediate& imm);
 
   void imulq(Register dst, Register src);
   void imulq(Register dst, const Address& address);
   void imulq(Register dst, const Immediate& imm);
+  void MulImmediate(Register reg, const Immediate& imm, Register pp);
 
   void subq(Register dst, Register src);
   void subq(Register reg, const Immediate& imm);
   void subq(Register reg, const Address& address);
+  void subq(const Address& address, Register reg);
+  void subq(const Address& address, const Immediate& imm);
 
   void shll(Register reg, const Immediate& imm);
   void shll(Register operand, Register shifter);
   void shrl(Register reg, const Immediate& imm);
   void shrl(Register operand, Register shifter);
   void sarl(Register reg, const Immediate& imm);
   void sarl(Register operand, Register shifter);
 
   void shlq(Register reg, const Immediate& imm);
   void shlq(Register operand, Register shifter);
@@ skipping 92 matching lines @@
   /*
    * Macros for High-level operations and implemented on all architectures.
    */
 
   void CompareRegisters(Register a, Register b);
 
   // Issues a move instruction if 'to' is not the same as 'from'.
   void MoveRegister(Register to, Register from);
   void PopRegister(Register r);
 
-  void AddImmediate(Register reg, const Immediate& imm);
+  void AddImmediate(Register reg, const Immediate& imm, Register pp);
+  void AddImmediate(const Address& address, const Immediate& imm, Register pp);
 
   void Drop(intptr_t stack_elements);
 
   enum Patchability {
     kPatchable,
     kNotPatchable,
   };
 
+  bool CanLoadImmediateFromPool(const Immediate& imm, Register pp);
+  void LoadImmediate(Register reg, const Immediate& imm, Register pp);
+  void LoadImmediate(const Address& dst, const Immediate& imm, Register pp);
   void LoadObject(Register dst, const Object& obj, Register pp);
   void JmpPatchable(const ExternalLabel* label, Register pp);
   void Jmp(const ExternalLabel* label, Register pp);
   void J(Condition condition, const ExternalLabel* label, Register pp);
   void CallPatchable(const ExternalLabel* label);
   void Call(const ExternalLabel* label, Register pp);
-  void StoreObject(const Address& dst, const Object& obj);
-  void PushObject(const Object& object);
-  void CompareObject(Register reg, const Object& object);
+  void StoreObject(const Address& dst, const Object& obj, Register pp);
+  void PushObject(const Object& object, Register pp);
+  void CompareObject(Register reg, const Object& object, Register pp);
   void LoadDoubleConstant(XmmRegister dst, double value);
 
   // Destroys value.
   void StoreIntoObject(Register object,  // Object we are storing into.
                        const Address& dest,  // Where we are storing into.
                        Register value,  // Value we are storing.
                        bool can_value_be_smi = true);
 
   void StoreIntoObjectNoBarrier(Register object,
                                 const Address& dest,
@@ skipping 117 matching lines @@
   //   pushq rbp          (size is 1 byte)
   //   movq rbp, rsp      (size is 3 bytes)
   //   call L             (size is 5 bytes)
   //   L:
   static const intptr_t kEntryPointToPcMarkerOffset = 9;
 
   // Inlined allocation of an instance of class 'cls', code has no runtime
   // calls. Jump to 'failure' if the instance cannot be allocated here.
   // Allocated instance is returned in 'instance_reg'.
   // Only the tags field of the object is initialized.
+  // Loads large immediates from the object pool with pool pointer in PP if it
+  // is not kNoRegister
   void TryAllocate(const Class& cls,
                    Label* failure,
                    bool near_jump,
-                   Register instance_reg);
+                   Register instance_reg,
+                   Register pp);
 
   // Debugging and bringup support.
   void Stop(const char* message);
   void Unimplemented(const char* message);
   void Untested(const char* message);
   void Unreachable(const char* message);
 
   static void InitializeMemoryWithBreakpoints(uword data, int length);
 
   static const char* RegisterName(Register reg);
@@ skipping 65 matching lines @@
     const String& comment_;
 
     DISALLOW_COPY_AND_ASSIGN(CodeComment);
   };
 
   GrowableArray<CodeComment*> comments_;
 
   intptr_t FindObject(const Object& obj, Patchability patchable);
   intptr_t FindExternalLabel(const ExternalLabel* label,
                              Patchability patchable);
+  intptr_t FindImmediate(int64_t imm);
   void LoadExternalLabel(Register dst,
                          const ExternalLabel* label,
                          Patchability patchable,
                          Register pp);
   bool CanLoadFromObjectPool(const Object& object);
   void LoadWordFromPoolOffset(Register dst, Register pp, int32_t offset);
 
   inline void EmitUint8(uint8_t value);
   inline void EmitInt32(int32_t value);
   inline void EmitInt64(int64_t value);
@@ skipping 109 matching lines @@
 }
 
 
 inline void Assembler::EmitOperandSizeOverride() {
   EmitUint8(0x66);
 }
 
 }  // namespace dart
 
 #endif  // VM_ASSEMBLER_X64_H_