Expands the use of Immediate and Operand wrappers.

runtime/vm/assembler_x64.h

Index: runtime/vm/assembler_x64.h
===================================================================
--- runtime/vm/assembler_x64.h	(revision 40623)
+++ runtime/vm/assembler_x64.h	(working copy)
@@ -185,6 +185,10 @@
     }
   }
 
+  Address(Register base, Register r) {
+    UNREACHABLE();
+  }
+
   Address(Register index, ScaleFactor scale, int32_t disp) {
     ASSERT(index != RSP);  // Illegal addressing mode.
     SetModRM(0, RSP);
@@ -192,6 +196,10 @@
     SetDisp32(disp);
   }
 
+  Address(Register index, ScaleFactor scale, Register r) {
+    UNREACHABLE();
+  }
+
   Address(Register base, Register index, ScaleFactor scale, int32_t disp) {
     ASSERT(index != RSP);  // Illegal addressing mode.
     if ((disp == 0) && ((base & 7) != RBP)) {
@@ -208,6 +216,10 @@
     }
   }
 
+  Address(Register base, Register index, ScaleFactor scale, Register r) {
+    UNREACHABLE();
+  }
+
   Address(const Address& other) : Operand(other) { }
 
   Address& operator=(const Address& other) {
@@ -219,6 +231,11 @@
     return Address(base, disp, true);
   }
 
+  static Address AddressBaseImm32(Register base, Register r) {
+    UNREACHABLE();
+    return Address(base, 0, true);
+  }
+
  private:
   Address(Register base, int32_t disp, bool fixed) {
     ASSERT(fixed);
@@ -236,9 +253,18 @@
   FieldAddress(Register base, int32_t disp)
       : Address(base, disp - kHeapObjectTag) { }
 
+  FieldAddress(Register base, Register r) : Address(base, 0) {
+    UNREACHABLE();
+  }
+
   FieldAddress(Register base, Register index, ScaleFactor scale, int32_t disp)
       : Address(base, index, scale, disp - kHeapObjectTag) { }
 
+  FieldAddress(Register base, Register index, ScaleFactor scale, Register r)
+      : Address(base, index, scale, 0) {
+    UNREACHABLE();
+  }
+
   FieldAddress(const FieldAddress& other) : Address(other) { }
 
   FieldAddress& operator=(const FieldAddress& other) {
@@ -1007,6 +1033,9 @@
                          Register pp);
   bool CanLoadFromObjectPool(const Object& object);
   void LoadWordFromPoolOffset(Register dst, Register pp, int32_t offset);
+  void LoadWordFromPoolOffset(Register dst, Register pp, Register r) {
+    UNREACHABLE();
+  }
 
   inline void EmitUint8(uint8_t value);
   inline void EmitInt32(int32_t value);