Eliminates more large immediates from x64 code.

runtime/vm/intermediate_language_x64.cc

 // 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.
 
 #include "vm/globals.h"  // Needed here to get TARGET_ARCH_X64.
 #if defined(TARGET_ARCH_X64)
 
 #include "vm/intermediate_language.h"
 
 #include "vm/dart_entry.h"
@@ skipping 34 matching lines @@
 
 
 void PushArgumentInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   // In SSA mode, we need an explicit push. Nothing to do in non-SSA mode
   // where PushArgument is handled by BindInstr::EmitNativeCode.
   if (compiler->is_optimizing()) {
     Location value = locs()->in(0);
     if (value.IsRegister()) {
       __ pushq(value.reg());
     } else if (value.IsConstant()) {
-      __ PushObject(value.constant());
+      __ PushObject(value.constant(), PP);
     } else {
       ASSERT(value.IsStackSlot());
       __ pushq(value.ToStackSlotAddress());
     }
   }
 }
 
 
 LocationSummary* ReturnInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
@@ skipping 17 matching lines @@
   // has its own return instruction. Method that have finally are currently
   // not optimized.
   if (!compiler->HasFinally()) {
     __ Comment("Stack Check");
     Label done;
     const intptr_t fp_sp_dist =
         (kFirstLocalSlotFromFp + 1 - compiler->StackSize()) * kWordSize;
     ASSERT(fp_sp_dist <= 0);
     __ movq(RDI, RSP);
     __ subq(RDI, RBP);
-    __ cmpq(RDI, Immediate(fp_sp_dist));
+    __ CompareImmediate(RDI, Immediate(fp_sp_dist), PP);
     __ j(EQUAL, &done, Assembler::kNearJump);
     __ int3();
     __ Bind(&done);
   }
 #endif
 
   __ ReturnPatchable();
   compiler->AddCurrentDescriptor(PcDescriptors::kReturn,
                                  Isolate::kNoDeoptId,
                                  token_pos());
@@ skipping 85 matching lines @@
   ASSERT(Token::IsEqualityOperator(kind()));
 
   Location left = locs()->in(0);
   Location right = locs()->in(1);
   if (left.IsConstant() && right.IsConstant()) {
     // TODO(srdjan): Determine why this instruction was not eliminated.
     bool result = (left.constant().raw() == right.constant().raw());
     if ((kind_ == Token::kNE_STRICT) || (kind_ == Token::kNE)) {
       result = !result;
     }
-    __ movq(locs()->out().reg(),
+    __ LoadImmediate(locs()->out().reg(),
             Immediate(reinterpret_cast<int64_t>(
-                Smi::New(result ? if_true_ : if_false_))));
+                Smi::New(result ? if_true_ : if_false_))), PP);
     return;
   }
 
   ASSERT(!left.IsConstant() || !right.IsConstant());
 
   // Clear upper part of the out register. We are going to use setcc on it
   // which is a byte move.
   __ xorq(RDX, RDX);
 
   // Compare left and right. For now only equality comparison is supported.
   // TODO(vegorov): reuse code from the other comparison instructions instead of
   // generating it inline here.
   if (left.IsConstant()) {
-    __ CompareObject(right.reg(), left.constant());
+    __ CompareObject(right.reg(), left.constant(), PP);
   } else if (right.IsConstant()) {
-    __ CompareObject(left.reg(), right.constant());
+    __ CompareObject(left.reg(), right.constant(), PP);
   } else {
     __ cmpq(left.reg(), right.reg());
   }
 
   Condition true_condition =
       ((kind_ == Token::kEQ_STRICT) || (kind_ == Token::kEQ)) ? EQUAL
                                                               : NOT_EQUAL;
 
   const bool is_power_of_two_kind = IsPowerOfTwoKind(if_true_, if_false_);
 
@@ skipping 16 matching lines @@
     }
   }
 
   __ setcc(true_condition, DL);
 
   if (is_power_of_two_kind) {
     const intptr_t shift =
         Utils::ShiftForPowerOfTwo(Utils::Maximum(true_value, false_value));
     __ shlq(RDX, Immediate(shift + kSmiTagSize));
   } else {
-    __ subq(RDX, Immediate(1));
-    __ andq(RDX, Immediate(
-        Smi::RawValue(true_value) - Smi::RawValue(false_value)));
+    __ AddImmediate(RDX, Immediate(-1), PP);
+    __ AndImmediate(RDX,
+        Immediate(Smi::RawValue(true_value) - Smi::RawValue(false_value)), PP);
     if (false_value != 0) {
-      __ addq(RDX, Immediate(Smi::RawValue(false_value)));
+      __ AddImmediate(RDX, Immediate(Smi::RawValue(false_value)), PP);
     }
   }
 }
 
 
 LocationSummary* LoadLocalInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 0;
   return LocationSummary::Make(kNumInputs,
                                Location::RequiresRegister(),
                                LocationSummary::kNoCall);
@@ skipping 65 matching lines @@
 
 static void EmitAssertBoolean(Register reg,
                               intptr_t token_pos,
                               intptr_t deopt_id,
                               LocationSummary* locs,
                               FlowGraphCompiler* compiler) {
   // Check that the type of the value is allowed in conditional context.
   // Call the runtime if the object is not bool::true or bool::false.
   ASSERT(locs->always_calls());
   Label done;
-  __ CompareObject(reg, Bool::True());
+  __ CompareObject(reg, Bool::True(), PP);
   __ j(EQUAL, &done, Assembler::kNearJump);
-  __ CompareObject(reg, Bool::False());
+  __ CompareObject(reg, Bool::False(), PP);
   __ j(EQUAL, &done, Assembler::kNearJump);
 
   __ pushq(reg);  // Push the source object.
   compiler->GenerateCallRuntime(token_pos,
                                 deopt_id,
                                 kConditionTypeErrorRuntimeEntry,
                                 1,
                                 locs);
   // We should never return here.
   __ int3();
@@ skipping 158 matching lines @@
     compiler->GenerateCall(token_pos,
                            &StubCode::EqualityWithNullArgLabel(),
                            PcDescriptors::kRuntimeCall,
                            locs);
     __ Drop(2);
   }
   __ Bind(&check_ne);
   if (kind == Token::kNE) {
     Label true_label, done;
     // Negate the condition: true label returns false and vice versa.
-    __ CompareObject(RAX, Bool::True());
+    __ CompareObject(RAX, Bool::True(), PP);
     __ j(EQUAL, &true_label, Assembler::kNearJump);
     __ LoadObject(RAX, Bool::True(), PP);
     __ jmp(&done, Assembler::kNearJump);
     __ Bind(&true_label);
     __ LoadObject(RAX, Bool::False(), PP);
     __ Bind(&done);
   }
   __ Bind(&equality_done);
 }
 
 
 static void LoadValueCid(FlowGraphCompiler* compiler,
                          Register value_cid_reg,
                          Register value_reg,
                          Label* value_is_smi = NULL) {
   Label done;
   if (value_is_smi == NULL) {
-    __ movq(value_cid_reg, Immediate(kSmiCid));
+    __ LoadImmediate(value_cid_reg, Immediate(kSmiCid), PP);
   }
   __ testq(value_reg, Immediate(kSmiTagMask));
   if (value_is_smi == NULL) {
     __ j(ZERO, &done, Assembler::kNearJump);
   } else {
     __ j(ZERO, value_is_smi);
   }
   __ LoadClassId(value_cid_reg, value_reg);
   __ Bind(&done);
 }
@@ skipping 18 matching lines @@
                (ic_data.GetReceiverClassIdAt(0) == kSmiCid) ? NULL : deopt);
   // 'temp' contains class-id of the left argument.
   ObjectStore* object_store = Isolate::Current()->object_store();
   Condition cond = TokenKindToSmiCondition(kind);
   Label done;
   const intptr_t len = ic_data.NumberOfChecks();
   for (intptr_t i = 0; i < len; i++) {
     // Assert that the Smi is at position 0, if at all.
     ASSERT((ic_data.GetReceiverClassIdAt(i) != kSmiCid) || (i == 0));
     Label next_test;
-    __ cmpq(temp, Immediate(ic_data.GetReceiverClassIdAt(i)));
+    __ CompareImmediate(temp, Immediate(ic_data.GetReceiverClassIdAt(i)), PP);
     if (i < len - 1) {
       __ j(NOT_EQUAL, &next_test);
     } else {
       __ j(NOT_EQUAL, deopt);
     }
     const Function& target = Function::ZoneHandle(ic_data.GetTargetAt(i));
     if (target.Owner() == object_store->object_class()) {
       // Object.== is same as ===.
       __ Drop(2);
       __ cmpq(left, right);
@@ skipping 14 matching lines @@
       const Array& kNoArgumentNames = Object::null_array();
       compiler->GenerateStaticCall(deopt_id,
                                    token_pos,
                                    target,
                                    kNumberOfArguments,
                                    kNoArgumentNames,
                                    locs);
       if (branch == NULL) {
         if (kind == Token::kNE) {
           Label false_label;
-          __ CompareObject(RAX, Bool::True());
+          __ CompareObject(RAX, Bool::True(), PP);
           __ j(EQUAL, &false_label, Assembler::kNearJump);
           __ LoadObject(RAX, Bool::True(), PP);
           __ jmp(&done);
           __ Bind(&false_label);
           __ LoadObject(RAX, Bool::False(), PP);
         }
       } else {
         if (branch->is_checked()) {
           EmitAssertBoolean(RAX, token_pos, deopt_id, locs, compiler);
         }
-        __ CompareObject(RAX, Bool::True());
+        __ CompareObject(RAX, Bool::True(), PP);
         branch->EmitBranchOnCondition(compiler, cond);
       }
     }
     if (i < len - 1) {
       __ jmp(&done);
       __ Bind(&next_test);
     }
   }
   __ Bind(&done);
 }
 
 
 // Emit code when ICData's targets are all Object == (which is ===).
 static void EmitCheckedStrictEqual(FlowGraphCompiler* compiler,
                                    const ICData& orig_ic_data,
                                    const LocationSummary& locs,
                                    Token::Kind kind,
                                    BranchInstr* branch,
                                    intptr_t deopt_id) {
   ASSERT((kind == Token::kEQ) || (kind == Token::kNE));
   Register left = locs.in(0).reg();
   Register right = locs.in(1).reg();
   Register temp = locs.temp(0).reg();
   Label* deopt = compiler->AddDeoptStub(deopt_id, kDeoptEquality);
   __ testq(left, Immediate(kSmiTagMask));
   __ j(ZERO, deopt);
   // 'left' is not Smi.
 
   Label identity_compare;
-  __ CompareObject(right, Object::null_object());
+  __ CompareObject(right, Object::null_object(), PP);
   __ j(EQUAL, &identity_compare);
-  __ CompareObject(left, Object::null_object());
+  __ CompareObject(left, Object::null_object(), PP);
   __ j(EQUAL, &identity_compare);
 
   __ LoadClassId(temp, left);
   const ICData& ic_data = ICData::Handle(orig_ic_data.AsUnaryClassChecks());
   const intptr_t len = ic_data.NumberOfChecks();
   for (intptr_t i = 0; i < len; i++) {
-    __ cmpq(temp, Immediate(ic_data.GetReceiverClassIdAt(i)));
+    __ CompareImmediate(temp, Immediate(ic_data.GetReceiverClassIdAt(i)), PP);
     if (i == (len - 1)) {
       __ j(NOT_EQUAL, deopt);
     } else {
       __ j(EQUAL, &identity_compare);
     }
   }
   __ Bind(&identity_compare);
   __ cmpq(left, right);
   if (branch == NULL) {
     Label done, is_equal;
@@ skipping 21 matching lines @@
                                        BranchInstr* branch,
                                        const ICData& ic_data,
                                        intptr_t deopt_id,
                                        intptr_t token_pos) {
   ASSERT((kind == Token::kEQ) || (kind == Token::kNE));
   ASSERT(!ic_data.IsNull() && (ic_data.NumberOfChecks() > 0));
   Register left = locs->in(0).reg();
   Register right = locs->in(1).reg();
 
   Label done, identity_compare, non_null_compare;
-  __ CompareObject(right, Object::null_object());
+  __ CompareObject(right, Object::null_object(), PP);
   __ j(EQUAL, &identity_compare, Assembler::kNearJump);
-  __ CompareObject(left, Object::null_object());
+  __ CompareObject(left, Object::null_object(), PP);
   __ j(NOT_EQUAL, &non_null_compare, Assembler::kNearJump);
   // Comparison with NULL is "===".
   __ Bind(&identity_compare);
   __ cmpq(left, right);
   Condition cond = TokenKindToSmiCondition(kind);
   if (branch != NULL) {
     branch->EmitBranchOnCondition(compiler, cond);
   } else {
     Register result = locs->out().reg();
     Label load_true;
@@ skipping 36 matching lines @@
                                 const LocationSummary& locs,
                                 Token::Kind kind,
                                 BranchInstr* branch) {
   Location left = locs.in(0);
   Location right = locs.in(1);
   ASSERT(!left.IsConstant() || !right.IsConstant());
 
   Condition true_condition = TokenKindToSmiCondition(kind);
 
   if (left.IsConstant()) {
-    __ CompareObject(right.reg(), left.constant());
+    __ CompareObject(right.reg(), left.constant(), PP);
     true_condition = FlipCondition(true_condition);
   } else if (right.IsConstant()) {
-    __ CompareObject(left.reg(), right.constant());
+    __ CompareObject(left.reg(), right.constant(), PP);
   } else if (right.IsStackSlot()) {
     __ cmpq(left.reg(), right.ToStackSlotAddress());
   } else {
     __ cmpq(left.reg(), right.reg());
   }
 
   if (branch != NULL) {
     branch->EmitBranchOnCondition(compiler, true_condition);
   } else {
     Register result = locs.out().reg();
@@ skipping 108 matching lines @@
   EmitEqualityAsInstanceCall(compiler,
                              deopt_id(),
                              token_pos(),
                              Token::kEQ,  // kNE reverse occurs at branch.
                              locs(),
                              *ic_data());
   if (branch->is_checked()) {
     EmitAssertBoolean(RAX, token_pos(), deopt_id(), locs(), compiler);
   }
   Condition branch_condition = (kind() == Token::kNE) ? NOT_EQUAL : EQUAL;
-  __ CompareObject(RAX, Bool::True());
+  __ CompareObject(RAX, Bool::True(), PP);
   branch->EmitBranchOnCondition(compiler, branch_condition);
 }
 
 
 LocationSummary* RelationalOpInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
   const intptr_t kNumTemps = 0;
   if (operation_cid() == kDoubleCid) {
     LocationSummary* summary =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
@@ skipping 50 matching lines @@
 }
 
 
 void NativeCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(locs()->temp(0).reg() == RAX);
   ASSERT(locs()->temp(1).reg() == RBX);
   ASSERT(locs()->temp(2).reg() == R10);
   Register result = locs()->out().reg();
 
   // Push the result place holder initialized to NULL.
-  __ PushObject(Object::ZoneHandle());
+  __ PushObject(Object::ZoneHandle(), PP);
   // Pass a pointer to the first argument in RAX.
   if (!function().HasOptionalParameters()) {
     __ leaq(RAX, Address(RBP, (kParamEndSlotFromFp +
                                function().NumParameters()) * kWordSize));
   } else {
     __ leaq(RAX,
             Address(RBP, kFirstLocalSlotFromFp * kWordSize));
   }
-  __ movq(RBX, Immediate(reinterpret_cast<uword>(native_c_function())));
-  __ movq(R10, Immediate(NativeArguments::ComputeArgcTag(function())));
+  __ LoadImmediate(
+      RBX, Immediate(reinterpret_cast<uword>(native_c_function())), PP);
+  __ LoadImmediate(
+      R10, Immediate(NativeArguments::ComputeArgcTag(function())), PP);
   const ExternalLabel* stub_entry =
       (is_bootstrap_native()) ? &StubCode::CallBootstrapCFunctionLabel() :
                                 &StubCode::CallNativeCFunctionLabel();
   compiler->GenerateCall(token_pos(),
                          stub_entry,
                          PcDescriptors::kOther,
                          locs());
   __ popq(result);
 }
 
@@ skipping 15 matching lines @@
   // TODO(fschneider): Allow immediate operands for the char code.
   return LocationSummary::Make(kNumInputs,
                                Location::RequiresRegister(),
                                LocationSummary::kNoCall);
 }
 
 
 void StringFromCharCodeInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register char_code = locs()->in(0).reg();
   Register result = locs()->out().reg();
-  __ movq(result,
-          Immediate(reinterpret_cast<uword>(Symbols::PredefinedAddress())));
+  __ LoadImmediate(result,
+          Immediate(reinterpret_cast<uword>(Symbols::PredefinedAddress())), PP);
   __ movq(result, Address(result,
                           char_code,
                           TIMES_HALF_WORD_SIZE,  // Char code is a smi.
                           Symbols::kNullCharCodeSymbolOffset * kWordSize));
 }
 
 
 LocationSummary* LoadUntaggedInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   return LocationSummary::Make(kNumInputs,
@@ skipping 16 matching lines @@
                                LocationSummary::kNoCall);
 }
 
 
 void LoadClassIdInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register object = locs()->in(0).reg();
   Register result = locs()->out().reg();
   Label load, done;
   __ testq(object, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, &load, Assembler::kNearJump);
-  __ movq(result, Immediate(Smi::RawValue(kSmiCid)));
+  __ LoadImmediate(result, Immediate(Smi::RawValue(kSmiCid)), PP);
   __ jmp(&done);
   __ Bind(&load);
   __ LoadClassId(result, object);
   __ SmiTag(result);
   __ Bind(&done);
 }
 
 
 CompileType LoadIndexedInstr::ComputeType() const {
   switch (class_id_) {
@@ skipping 287 matching lines @@
   if ((index_scale() == 1) && index.IsRegister()) {
     __ SmiUntag(index.reg());
   }
   switch (class_id()) {
     case kArrayCid:
       if (ShouldEmitStoreBarrier()) {
         Register value = locs()->in(2).reg();
         __ StoreIntoObject(array, element_address, value);
       } else if (locs()->in(2).IsConstant()) {
         const Object& constant = locs()->in(2).constant();
-        __ StoreObject(element_address, constant);
+        __ StoreObject(element_address, constant, PP);
       } else {
         Register value = locs()->in(2).reg();
         __ StoreIntoObjectNoBarrier(array, element_address, value);
       }
       break;
     case kTypedDataInt8ArrayCid:
     case kTypedDataUint8ArrayCid:
     case kExternalTypedDataUint8ArrayCid:
     case kOneByteStringCid:
       if (locs()->in(2).IsConstant()) {
@@ skipping 16 matching lines @@
           value = 0xFF;
         } else if (value < 0) {
           value = 0;
         }
         __ movb(element_address,
                 Immediate(static_cast<int8_t>(value)));
       } else {
         ASSERT(locs()->in(2).reg() == RAX);
         Label store_value, store_0xff;
         __ SmiUntag(RAX);
-        __ cmpq(RAX, Immediate(0xFF));
+        __ CompareImmediate(RAX, Immediate(0xFF), PP);
         __ j(BELOW_EQUAL, &store_value, Assembler::kNearJump);
         // Clamp to 0x0 or 0xFF respectively.
         __ j(GREATER, &store_0xff);
         __ xorq(RAX, RAX);
         __ jmp(&store_value, Assembler::kNearJump);
         __ Bind(&store_0xff);
-        __ movq(RAX, Immediate(0xFF));
+        __ LoadImmediate(RAX, Immediate(0xFF), PP);
         __ Bind(&store_value);
         __ movb(element_address, RAX);
       }
       break;
     }
     case kTypedDataInt16ArrayCid:
     case kTypedDataUint16ArrayCid: {
       Register value = locs()->in(2).reg();
       __ SmiUntag(value);
       __ movw(element_address, value);
@@ skipping 113 matching lines @@
 
       Label skip_length_check;
       __ cmpq(value_cid_reg, field_cid_operand);
       __ j(NOT_EQUAL, &skip_length_check);
       if (field_has_length) {
         // Field guard may have remembered list length, check it.
         if ((field_cid == kArrayCid) || (field_cid == kImmutableArrayCid)) {
           __ pushq(value_cid_reg);
           __ movq(value_cid_reg,
                   FieldAddress(value_reg, Array::length_offset()));
-          __ cmpq(value_cid_reg, Immediate(Smi::RawValue(field_length)));
+          __ CompareImmediate(
+              value_cid_reg, Immediate(Smi::RawValue(field_length)), PP);
           __ popq(value_cid_reg);
         } else if (RawObject::IsTypedDataClassId(field_cid)) {
           __ pushq(value_cid_reg);
           __ movq(value_cid_reg,
                   FieldAddress(value_reg, TypedData::length_offset()));
-          __ cmpq(value_cid_reg, Immediate(Smi::RawValue(field_length)));
+          __ CompareImmediate(
+              value_cid_reg, Immediate(Smi::RawValue(field_length)), PP);
           __ popq(value_cid_reg);
         } else {
           ASSERT(field_cid == kIllegalCid);
           ASSERT(field_length == Field::kUnknownFixedLength);
           // At compile time we do not know the type of the field nor its
           // length. At execution time we may have set the class id and
           // list length so we compare the guarded length with the
           // list length here, without this check the list length could change
           // without triggering a deoptimization.
           Label check_array, length_compared, no_fixed_length;
           // If length is negative the length guard is either disabled or
           // has not been initialized, either way it is safe to skip the
           // length check.
-          __ cmpq(field_length_operand, Immediate(Smi::RawValue(0)));
+          __ CompareImmediate(
+              field_length_operand, Immediate(Smi::RawValue(0)), PP);
           __ j(LESS, &skip_length_check);
-          __ cmpq(value_cid_reg, Immediate(kNullCid));
+          __ CompareImmediate(value_cid_reg, Immediate(kNullCid), PP);
           __ j(EQUAL, &no_fixed_length, Assembler::kNearJump);
           // Check for typed data array.
-          __ cmpq(value_cid_reg, Immediate(kTypedDataFloat32x4ArrayCid));
+          __ CompareImmediate(
+              value_cid_reg, Immediate(kTypedDataFloat32x4ArrayCid), PP);
           // Not a typed array or a regular array.
           __ j(GREATER, &no_fixed_length, Assembler::kNearJump);
-          __ cmpq(value_cid_reg, Immediate(kTypedDataInt8ArrayCid));
+          __ CompareImmediate(
+              value_cid_reg, Immediate(kTypedDataInt8ArrayCid), PP);
           // Could still be a regular array.
           __ j(LESS, &check_array, Assembler::kNearJump);
           __ pushq(value_cid_reg);
           __ movq(value_cid_reg,
                   FieldAddress(value_reg, TypedData::length_offset()));
           __ cmpq(field_length_operand, value_cid_reg);
           __ popq(value_cid_reg);
           __ jmp(&length_compared, Assembler::kNearJump);
           // Check for regular array.
           __ Bind(&check_array);
-          __ cmpq(value_cid_reg, Immediate(kImmutableArrayCid));
+          __ CompareImmediate(value_cid_reg, Immediate(kImmutableArrayCid), PP);
           __ j(GREATER, &no_fixed_length, Assembler::kNearJump);
-          __ cmpq(value_cid_reg, Immediate(kArrayCid));
+          __ CompareImmediate(value_cid_reg, Immediate(kArrayCid), PP);
           __ j(LESS, &no_fixed_length, Assembler::kNearJump);
           __ pushq(value_cid_reg);
           __ movq(value_cid_reg,
                   FieldAddress(value_reg, Array::length_offset()));
           __ cmpq(field_length_operand, value_cid_reg);
           __ popq(value_cid_reg);
           __ jmp(&length_compared, Assembler::kNearJump);
           __ Bind(&no_fixed_length);
           __ jmp(fail);
           __ Bind(&length_compared);
         }
         __ j(NOT_EQUAL, fail);
       }
       __ Bind(&skip_length_check);
       __ cmpq(value_cid_reg, field_nullability_operand);
     } else if (value_cid == kNullCid) {
-      __ cmpq(field_nullability_operand, Immediate(value_cid));
+      __ CompareImmediate(field_nullability_operand, Immediate(value_cid), PP);
     } else {
       Label skip_length_check;
-      __ cmpq(field_cid_operand, Immediate(value_cid));
+      __ CompareImmediate(field_cid_operand, Immediate(value_cid), PP);
       // If not equal, skip over length check.
       __ j(NOT_EQUAL, &skip_length_check);
       // Insert length check.
       if (field_has_length) {
         ASSERT(value_cid_reg != kNoRegister);
         if ((value_cid == kArrayCid) || (value_cid == kImmutableArrayCid)) {
-          __ cmpq(FieldAddress(value_reg, Array::length_offset()),
-                  Immediate(Smi::RawValue(field_length)));
+          __ CompareImmediate(FieldAddress(value_reg, Array::length_offset()),
+                              Immediate(Smi::RawValue(field_length)), PP);
         } else if (RawObject::IsTypedDataClassId(value_cid)) {
-          __ cmpq(FieldAddress(value_reg, TypedData::length_offset()),
-                  Immediate(Smi::RawValue(field_length)));
+          __ CompareImmediate(
+            FieldAddress(value_reg, TypedData::length_offset()),
+            Immediate(Smi::RawValue(field_length)), PP);
         } else if (field_cid != kIllegalCid) {
           ASSERT(field_cid != value_cid);
           ASSERT(field_length >= 0);
           // Field has a known class id and length. At compile time it is
           // known that the value's class id is not a fixed length list.
           __ jmp(fail);
         } else {
           ASSERT(field_cid == kIllegalCid);
           ASSERT(field_length == Field::kUnknownFixedLength);
           // Following jump cannot not occur, fall through.
         }
         __ j(NOT_EQUAL, fail);
       }
       // Not identical, possibly null.
       __ Bind(&skip_length_check);
     }
     __ j(EQUAL, &ok);
 
-    __ cmpq(field_cid_operand, Immediate(kIllegalCid));
+    __ CompareImmediate(field_cid_operand, Immediate(kIllegalCid), PP);
     __ j(NOT_EQUAL, fail);
 
     if (value_cid == kDynamicCid) {
       __ movq(field_cid_operand, value_cid_reg);
       __ movq(field_nullability_operand, value_cid_reg);
       if (field_has_length) {
         Label check_array, length_set, no_fixed_length;
-        __ cmpq(value_cid_reg, Immediate(kNullCid));
+        __ CompareImmediate(value_cid_reg, Immediate(kNullCid), PP);
         __ j(EQUAL, &no_fixed_length, Assembler::kNearJump);
         // Check for typed data array.
-        __ cmpq(value_cid_reg, Immediate(kTypedDataFloat32x4ArrayCid));
+        __ CompareImmediate(value_cid_reg,
+                            Immediate(kTypedDataFloat32x4ArrayCid), PP);
         // Not a typed array or a regular array.
         __ j(GREATER, &no_fixed_length);
-        __ cmpq(value_cid_reg, Immediate(kTypedDataInt8ArrayCid));
+        __ CompareImmediate(
+            value_cid_reg, Immediate(kTypedDataInt8ArrayCid), PP);
         // Could still be a regular array.
         __ j(LESS, &check_array, Assembler::kNearJump);
         // Destroy value_cid_reg (safe because we are finished with it).
         __ movq(value_cid_reg,
                 FieldAddress(value_reg, TypedData::length_offset()));
         __ movq(field_length_operand, value_cid_reg);
         // Updated field length typed data array.
         __ jmp(&length_set);
         // Check for regular array.
         __ Bind(&check_array);
-        __ cmpq(value_cid_reg, Immediate(kImmutableArrayCid));
+        __ CompareImmediate(value_cid_reg, Immediate(kImmutableArrayCid), PP);
         __ j(GREATER, &no_fixed_length, Assembler::kNearJump);
-        __ cmpq(value_cid_reg, Immediate(kArrayCid));
+        __ CompareImmediate(value_cid_reg, Immediate(kArrayCid), PP);
         __ j(LESS, &no_fixed_length, Assembler::kNearJump);
         // Destroy value_cid_reg (safe because we are finished with it).
         __ movq(value_cid_reg,
                 FieldAddress(value_reg, Array::length_offset()));
         __ movq(field_length_operand, value_cid_reg);
         // Updated field length from regular array.
         __ jmp(&length_set, Assembler::kNearJump);
         __ Bind(&no_fixed_length);
-        __ movq(field_length_operand,
-                Immediate(Smi::RawValue(Field::kNoFixedLength)));
+        __ LoadImmediate(field_length_operand,
+            Immediate(Smi::RawValue(Field::kNoFixedLength)), PP);
         __ Bind(&length_set);
       }
     } else {
       ASSERT(field_reg != kNoRegister);
-      __ movq(field_cid_operand, Immediate(value_cid));
-      __ movq(field_nullability_operand, Immediate(value_cid));
+      __ LoadImmediate(field_cid_operand, Immediate(value_cid), PP);
+      __ LoadImmediate(field_nullability_operand, Immediate(value_cid), PP);
       if (field_has_length) {
         ASSERT(value_cid_reg != kNoRegister);
         if ((value_cid == kArrayCid) || (value_cid == kImmutableArrayCid)) {
           // Destroy value_cid_reg (safe because we are finished with it).
           __ movq(value_cid_reg,
                   FieldAddress(value_reg, Array::length_offset()));
           __ movq(field_length_operand, value_cid_reg);
         } else if (RawObject::IsTypedDataClassId(value_cid)) {
           // Destroy value_cid_reg (safe because we are finished with it).
           __ movq(value_cid_reg,
                   FieldAddress(value_reg, TypedData::length_offset()));
           __ movq(field_length_operand, value_cid_reg);
         } else {
-          __ movq(field_length_operand,
-                  Immediate(Smi::RawValue(Field::kNoFixedLength)));
+          __ LoadImmediate(field_length_operand,
+                  Immediate(Smi::RawValue(Field::kNoFixedLength)), PP);
         }
       }
     }
     if (!ok_is_fall_through) {
       __ jmp(&ok);
     }
   } else {
     if (field_reg != kNoRegister) {
       __ LoadObject(field_reg, Field::ZoneHandle(field().raw()), PP);
     }
 
     if (value_cid == kDynamicCid) {
       // Field's guarded class id is fixed but value's class id is not known.
       __ testq(value_reg, Immediate(kSmiTagMask));
 
       if (field_cid != kSmiCid) {
         __ j(ZERO, fail);
         __ LoadClassId(value_cid_reg, value_reg);
-        __ cmpq(value_cid_reg, Immediate(field_cid));
+        __ CompareImmediate(value_cid_reg, Immediate(field_cid), PP);
       }
 
       if (field_has_length) {
         // Jump when Value CID != Field guard CID
         __ j(NOT_EQUAL, fail);
 
         // Classes are same, perform guarded list length check.
         ASSERT(field_reg != kNoRegister);
         ASSERT(value_cid_reg != kNoRegister);
         FieldAddress field_length_operand(
             field_reg, Field::guarded_list_length_offset());
         if ((field_cid == kArrayCid) || (field_cid == kImmutableArrayCid)) {
           // Destroy value_cid_reg (safe because we are finished with it).
           __ movq(value_cid_reg,
                   FieldAddress(value_reg, Array::length_offset()));
         } else if (RawObject::IsTypedDataClassId(field_cid)) {
           // Destroy value_cid_reg (safe because we are finished with it).
           __ movq(value_cid_reg,
                   FieldAddress(value_reg, TypedData::length_offset()));
         }
         __ cmpq(value_cid_reg, field_length_operand);
       }
 
       if (field().is_nullable() && (field_cid != kNullCid)) {
         __ j(EQUAL, &ok);
-        __ CompareObject(value_reg, Object::null_object());
+        __ CompareObject(value_reg, Object::null_object(), PP);
       }
 
       if (ok_is_fall_through) {
         __ j(NOT_EQUAL, fail);
       } else {
         __ j(EQUAL, &ok);
       }
     } else {
       // Both value's and field's class id is known.
       if ((value_cid != field_cid) && (value_cid != nullability)) {
         if (ok_is_fall_through) {
           __ jmp(fail);
         }
       } else if (field_has_length && (value_cid == field_cid)) {
         ASSERT(value_cid_reg != kNoRegister);
         if ((field_cid == kArrayCid) || (field_cid == kImmutableArrayCid)) {
           // Destroy value_cid_reg (safe because we are finished with it).
           __ movq(value_cid_reg,
                   FieldAddress(value_reg, Array::length_offset()));
         } else if (RawObject::IsTypedDataClassId(field_cid)) {
           // Destroy value_cid_reg (safe because we are finished with it).
           __ movq(value_cid_reg,
                   FieldAddress(value_reg, TypedData::length_offset()));
         }
-        __ cmpq(value_cid_reg, Immediate(Smi::RawValue(field_length)));
+        __ CompareImmediate(
+            value_cid_reg, Immediate(Smi::RawValue(field_length)), PP);
         if (ok_is_fall_through) {
           __ j(NOT_EQUAL, fail);
         }
       } else {
         // Nothing to emit.
         ASSERT(!compiler->is_optimizing());
         return;
       }
     }
   }
 
   if (deopt == NULL) {
     ASSERT(!compiler->is_optimizing());
     __ Bind(fail);
 
-    __ cmpq(FieldAddress(field_reg, Field::guarded_cid_offset()),
-            Immediate(kDynamicCid));
+    __ CompareImmediate(FieldAddress(field_reg, Field::guarded_cid_offset()),
+                        Immediate(kDynamicCid), PP);
     __ j(EQUAL, &ok);
 
     __ pushq(field_reg);
     __ pushq(value_reg);
     __ CallRuntime(kUpdateFieldCidRuntimeEntry, 2);
     __ Drop(2);  // Drop the field and the value.
   }
 
   __ Bind(&ok);
 }
@@ skipping 16 matching lines @@
   Register instance_reg = locs()->in(0).reg();
   if (ShouldEmitStoreBarrier()) {
     Register value_reg = locs()->in(1).reg();
     __ StoreIntoObject(instance_reg,
                        FieldAddress(instance_reg, field().Offset()),
                        value_reg,
                        CanValueBeSmi());
   } else {
     if (locs()->in(1).IsConstant()) {
       __ StoreObject(FieldAddress(instance_reg, field().Offset()),
-                     locs()->in(1).constant());
+                     locs()->in(1).constant(), PP);
     } else {
       Register value_reg = locs()->in(1).reg();
       __ StoreIntoObjectNoBarrier(instance_reg,
           FieldAddress(instance_reg, field().Offset()), value_reg);
     }
   }
 }
 
 
 LocationSummary* LoadStaticFieldInstr::MakeLocationSummary() const {
@@ skipping 77 matching lines @@
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
   locs->set_in(0, Location::RegisterLocation(RBX));
   locs->set_out(Location::RegisterLocation(RAX));
   return locs;
 }
 
 
 void CreateArrayInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   // Allocate the array.  R10 = length, RBX = element type.
   ASSERT(locs()->in(0).reg() == RBX);
-  __ movq(R10, Immediate(Smi::RawValue(num_elements())));
+  __ LoadImmediate(R10, Immediate(Smi::RawValue(num_elements())), PP);
   compiler->GenerateCall(token_pos(),
                          &StubCode::AllocateArrayLabel(),
                          PcDescriptors::kOther,
                          locs());
   ASSERT(locs()->out().reg() == RAX);
 }
 
 
 LocationSummary*
 AllocateObjectWithBoundsCheckInstr::MakeLocationSummary() const {
@@ skipping 40 matching lines @@
 }
 
 
 void InstantiateTypeInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register instantiator_reg = locs()->in(0).reg();
   Register result_reg = locs()->out().reg();
 
   // 'instantiator_reg' is the instantiator AbstractTypeArguments object
   // (or null).
   // A runtime call to instantiate the type is required.
-  __ PushObject(Object::ZoneHandle());  // Make room for the result.
-  __ PushObject(type());
+  __ PushObject(Object::ZoneHandle(), PP);  // Make room for the result.
+  __ PushObject(type(), PP);
   __ pushq(instantiator_reg);  // Push instantiator type arguments.
   compiler->GenerateCallRuntime(token_pos(),
                                 deopt_id(),
                                 kInstantiateTypeRuntimeEntry,
                                 2,
                                 locs());
   __ Drop(2);  // Drop instantiator and uninstantiated type.
   __ popq(result_reg);  // Pop instantiated type.
   ASSERT(instantiator_reg == result_reg);
 }
@@ skipping 19 matching lines @@
   // (or null).
   ASSERT(!type_arguments().IsUninstantiatedIdentity() &&
          !type_arguments().CanShareInstantiatorTypeArguments(
              instantiator_class()));
   // If the instantiator is null and if the type argument vector
   // instantiated from null becomes a vector of dynamic, then use null as
   // the type arguments.
   Label type_arguments_instantiated;
   const intptr_t len = type_arguments().Length();
   if (type_arguments().IsRawInstantiatedRaw(len)) {
-    __ CompareObject(instantiator_reg, Object::null_object());
+    __ CompareObject(instantiator_reg, Object::null_object(), PP);
     __ j(EQUAL, &type_arguments_instantiated, Assembler::kNearJump);
   }
   // Instantiate non-null type arguments.
   // A runtime call to instantiate the type arguments is required.
-  __ PushObject(Object::ZoneHandle());  // Make room for the result.
-  __ PushObject(type_arguments());
+  __ PushObject(Object::ZoneHandle(), PP);  // Make room for the result.
+  __ PushObject(type_arguments(), PP);
   __ pushq(instantiator_reg);  // Push instantiator type arguments.
   compiler->GenerateCallRuntime(token_pos(),
                                 deopt_id(),
                                 kInstantiateTypeArgumentsRuntimeEntry,
                                 2,
                                 locs());
   __ Drop(2);  // Drop instantiator and uninstantiated type arguments.
   __ popq(result_reg);  // Pop instantiated type arguments.
   __ Bind(&type_arguments_instantiated);
   ASSERT(instantiator_reg == result_reg);
@@ skipping 22 matching lines @@
   // AbstractTypeArguments object (or null).
   ASSERT(!type_arguments().IsUninstantiatedIdentity() &&
          !type_arguments().CanShareInstantiatorTypeArguments(
              instantiator_class()));
   // If the instantiator is null and if the type argument vector
   // instantiated from null becomes a vector of dynamic, then use null as
   // the type arguments.
   Label type_arguments_instantiated;
   ASSERT(type_arguments().IsRawInstantiatedRaw(type_arguments().Length()));
 
-  __ CompareObject(instantiator_reg, Object::null_object());
+  __ CompareObject(instantiator_reg, Object::null_object(), PP);
   __ j(EQUAL, &type_arguments_instantiated, Assembler::kNearJump);
   // Instantiate non-null type arguments.
   // In the non-factory case, we rely on the allocation stub to
   // instantiate the type arguments.
   __ LoadObject(result_reg, type_arguments(), PP);
   // result_reg: uninstantiated type arguments.
 
   __ Bind(&type_arguments_instantiated);
   // result_reg: uninstantiated or instantiated type arguments.
 }
@@ skipping 21 matching lines @@
   ASSERT(!type_arguments().IsUninstantiatedIdentity() &&
          !type_arguments().CanShareInstantiatorTypeArguments(
              instantiator_class()));
 
   // If the instantiator is null and if the type argument vector
   // instantiated from null becomes a vector of dynamic, then use null as
   // the type arguments and do not pass the instantiator.
   ASSERT(type_arguments().IsRawInstantiatedRaw(type_arguments().Length()));
 
   Label instantiator_not_null;
-  __ CompareObject(instantiator_reg, Object::null_object());
+  __ CompareObject(instantiator_reg, Object::null_object(), PP);
   __ j(NOT_EQUAL, &instantiator_not_null, Assembler::kNearJump);
   // Null was used in VisitExtractConstructorTypeArguments as the
   // instantiated type arguments, no proper instantiator needed.
-  __ movq(instantiator_reg,
-          Immediate(Smi::RawValue(StubCode::kNoInstantiator)));
+  __ LoadImmediate(instantiator_reg,
+          Immediate(Smi::RawValue(StubCode::kNoInstantiator)), PP);
   __ Bind(&instantiator_not_null);
   // instantiator_reg: instantiator or kNoInstantiator.
 }
 
 
 LocationSummary* AllocateContextInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 0;
   const intptr_t kNumTemps = 1;
   LocationSummary* locs =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
   locs->set_temp(0, Location::RegisterLocation(R10));
   locs->set_out(Location::RegisterLocation(RAX));
   return locs;
 }
 
 
 void AllocateContextInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(locs()->temp(0).reg() == R10);
   ASSERT(locs()->out().reg() == RAX);
 
-  __ movq(R10, Immediate(num_context_variables()));
+  __ LoadImmediate(R10, Immediate(num_context_variables()), PP);
   const ExternalLabel label("alloc_context",
                             StubCode::AllocateContextEntryPoint());
   compiler->GenerateCall(token_pos(),
                          &label,
                          PcDescriptors::kOther,
                          locs());
 }
 
 
 LocationSummary* CloneContextInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* locs =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
   locs->set_in(0, Location::RegisterLocation(RAX));
   locs->set_out(Location::RegisterLocation(RAX));
   return locs;
 }
 
 
 void CloneContextInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register context_value = locs()->in(0).reg();
   Register result = locs()->out().reg();
 
-  __ PushObject(Object::ZoneHandle());  // Make room for the result.
+  __ PushObject(Object::ZoneHandle(), PP);  // Make room for the result.
   __ pushq(context_value);
   compiler->GenerateCallRuntime(token_pos(),
                                 deopt_id(),
                                 kCloneContextRuntimeEntry,
                                 1,
                                 locs());
   __ popq(result);  // Remove argument.
   __ popq(result);  // Get result (cloned context).
 }
 
@@ skipping 81 matching lines @@
   CheckStackOverflowInstr* instruction_;
 };
 
 
 void CheckStackOverflowInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   CheckStackOverflowSlowPath* slow_path = new CheckStackOverflowSlowPath(this);
   compiler->AddSlowPathCode(slow_path);
 
   Register temp = locs()->temp(0).reg();
   // Generate stack overflow check.
-  __ movq(temp, Immediate(Isolate::Current()->stack_limit_address()));
+  __ LoadImmediate(
+      temp, Immediate(Isolate::Current()->stack_limit_address()), PP);
   __ cmpq(RSP, Address(temp, 0));
   __ j(BELOW_EQUAL, slow_path->entry_label());
   if (compiler->CanOSRFunction() && in_loop()) {
     // In unoptimized code check the usage counter to trigger OSR at loop
     // stack checks.  Use progressively higher thresholds for more deeply
     // nested loops to attempt to hit outer loops with OSR when possible.
     __ LoadObject(temp, compiler->parsed_function().function(), PP);
     intptr_t threshold =
         FLAG_optimization_counter_threshold * (loop_depth() + 1);
-    __ cmpq(FieldAddress(temp, Function::usage_counter_offset()),
-            Immediate(threshold));
+    __ CompareImmediate(FieldAddress(temp, Function::usage_counter_offset()),
+                        Immediate(threshold), PP);
     __ j(GREATER_EQUAL, slow_path->entry_label());
   }
   __ Bind(slow_path->exit_label());
 }
 
 
 static void EmitJavascriptOverflowCheck(FlowGraphCompiler* compiler,
                                         Range* range,
                                         Label* overflow,
                                         Register result) {
   if (!range->IsWithin(-0x20000000000000LL, 0x20000000000000LL)) {
     ASSERT(overflow != NULL);
-    __ cmpq(result, Immediate(-0x20000000000000LL));
+    __ CompareImmediate(result, Immediate(-0x20000000000000LL), PP);
     __ j(LESS, overflow);
-    __ cmpq(result, Immediate(0x20000000000000LL));
+    __ CompareImmediate(result, Immediate(0x20000000000000LL), PP);
     __ j(GREATER, overflow);
   }
 }
 
 
 static void EmitSmiShiftLeft(FlowGraphCompiler* compiler,
                              BinarySmiOpInstr* shift_left) {
   const bool is_truncating = shift_left->is_truncating();
   const LocationSummary& locs = *shift_left->locs();
   Register left = locs.in(0).reg();
@@ skipping 40 matching lines @@
   // Right (locs.in(1)) is not constant.
   Register right = locs.in(1).reg();
   Range* right_range = shift_left->right()->definition()->range();
   if (shift_left->left()->BindsToConstant() && !is_truncating) {
     // TODO(srdjan): Implement code below for is_truncating().
     // If left is constant, we know the maximal allowed size for right.
     const Object& obj = shift_left->left()->BoundConstant();
     if (obj.IsSmi()) {
       const intptr_t left_int = Smi::Cast(obj).Value();
       if (left_int == 0) {
-        __ cmpq(right, Immediate(0));
+        __ CompareImmediate(right, Immediate(0), PP);
         __ j(NEGATIVE, deopt);
         return;
       }
       const intptr_t max_right = kSmiBits - Utils::HighestBit(left_int);
       const bool right_needs_check =
           (right_range == NULL) ||
           !right_range->IsWithin(0, max_right - 1);
       if (right_needs_check) {
-        __ cmpq(right,
-          Immediate(reinterpret_cast<int64_t>(Smi::New(max_right))));
+        __ CompareImmediate(right,
+            Immediate(reinterpret_cast<int64_t>(Smi::New(max_right))), PP);
         __ j(ABOVE_EQUAL, deopt);
       }
       __ SmiUntag(right);
       __ shlq(left, right);
     }
     if (FLAG_throw_on_javascript_int_overflow) {
       EmitJavascriptOverflowCheck(compiler, shift_left->range(), deopt, result);
     }
     return;
   }
 
   const bool right_needs_check =
       (right_range == NULL) || !right_range->IsWithin(0, (Smi::kBits - 1));
   ASSERT(right == RCX);  // Count must be in RCX
   if (is_truncating) {
     if (right_needs_check) {
       const bool right_may_be_negative =
           (right_range == NULL) ||
           !right_range->IsWithin(0, RangeBoundary::kPlusInfinity);
       if (right_may_be_negative) {
         ASSERT(shift_left->CanDeoptimize());
-        __ cmpq(right, Immediate(0));
+        __ CompareImmediate(right, Immediate(0), PP);
         __ j(NEGATIVE, deopt);
       }
       Label done, is_not_zero;
-      __ cmpq(right,
-          Immediate(reinterpret_cast<int64_t>(Smi::New(Smi::kBits))));
+      __ CompareImmediate(right,
+          Immediate(reinterpret_cast<int64_t>(Smi::New(Smi::kBits))), PP);
       __ j(BELOW, &is_not_zero, Assembler::kNearJump);
       __ xorq(left, left);
       __ jmp(&done, Assembler::kNearJump);
       __ Bind(&is_not_zero);
       __ SmiUntag(right);
       __ shlq(left, right);
       __ Bind(&done);
     } else {
       __ SmiUntag(right);
       __ shlq(left, right);
     }
   } else {
     if (right_needs_check) {
       ASSERT(shift_left->CanDeoptimize());
-      __ cmpq(right,
-          Immediate(reinterpret_cast<int64_t>(Smi::New(Smi::kBits))));
+      __ CompareImmediate(right,
+          Immediate(reinterpret_cast<int64_t>(Smi::New(Smi::kBits))), PP);
       __ j(ABOVE_EQUAL, deopt);
     }
     // Left is not a constant.
     Register temp = locs.temp(0).reg();
     // Check if count too large for handling it inlined.
     __ movq(temp, left);
     __ SmiUntag(right);
     // Overflow test (preserve temp and right);
     __ shlq(left, right);
     __ sarq(left, right);
@@ skipping 102 matching lines @@
                                    kDeoptBinarySmiOp);
   }
 
   if (locs()->in(1).IsConstant()) {
     const Object& constant = locs()->in(1).constant();
     ASSERT(constant.IsSmi());
     const int64_t imm =
         reinterpret_cast<int64_t>(constant.raw());
     switch (op_kind()) {
       case Token::kADD: {
-        __ addq(left, Immediate(imm));
+        __ AddImmediate(left, Immediate(imm), PP);
         if (deopt != NULL) __ j(OVERFLOW, deopt);
         break;
       }
       case Token::kSUB: {
-        __ subq(left, Immediate(imm));
+        __ AddImmediate(left, Immediate(-imm), PP);
         if (deopt != NULL) __ j(OVERFLOW, deopt);
         break;
       }
       case Token::kMUL: {
         // Keep left value tagged and untag right value.
         const intptr_t value = Smi::Cast(constant).Value();
         if (value == 2) {
           __ shlq(left, Immediate(1));
         } else {
-          __ imulq(left, Immediate(value));
+          __ MulImmediate(left, Immediate(value), PP);
         }
         if (deopt != NULL) __ j(OVERFLOW, deopt);
         break;
       }
       case Token::kTRUNCDIV: {
         const intptr_t value = Smi::Cast(constant).Value();
         if (value == 1) {
           // Do nothing.
           break;
         } else if (value == -1) {
           // Check the corner case of dividing the 'MIN_SMI' with -1, in which
           // case we cannot negate the result.
-          __ cmpq(left, Immediate(0x8000000000000000));
+          __ CompareImmediate(left, Immediate(0x8000000000000000), PP);
           __ j(EQUAL, deopt);
           __ negq(left);
           break;
         }
 
         ASSERT(Utils::IsPowerOfTwo(Utils::Abs(value)));
         const intptr_t shift_count =
             Utils::ShiftForPowerOfTwo(Utils::Abs(value)) + kSmiTagSize;
         ASSERT(kSmiTagSize == 1);
         Register temp = locs()->temp(0).reg();
         __ movq(temp, left);
         __ sarq(temp, Immediate(63));
         ASSERT(shift_count > 1);  // 1, -1 case handled above.
         __ shrq(temp, Immediate(64 - shift_count));
         __ addq(left, temp);
         ASSERT(shift_count > 0);
         __ sarq(left, Immediate(shift_count));
         if (value < 0) {
           __ negq(left);
         }
         __ SmiTag(left);
         break;
       }
       case Token::kBIT_AND: {
         // No overflow check.
-        __ andq(left, Immediate(imm));
+        __ AndImmediate(left, Immediate(imm), PP);
         break;
       }
       case Token::kBIT_OR: {
         // No overflow check.
-        __ orq(left, Immediate(imm));
+        __ OrImmediate(left, Immediate(imm), PP);
         break;
       }
       case Token::kBIT_XOR: {
         // No overflow check.
-        __ xorq(left, Immediate(imm));
+        __ XorImmediate(left, Immediate(imm), PP);
         break;
       }
 
       case Token::kSHR: {
         // sarq operation masks the count to 6 bits.
         const intptr_t kCountLimit = 0x3F;
         intptr_t value = Smi::Cast(constant).Value();
 
         if (value == 0) {
           // TODO(vegorov): should be handled outside.
@@ skipping 135 matching lines @@
       __ jmp(&done);
 
       // Divide using 64bit idiv.
       __ Bind(&not_32bit);
       __ SmiUntag(left);
       __ SmiUntag(right);
       __ cqo();  // Sign extend RAX -> RDX:RAX.
       __ idivq(right);  //  RAX: quotient, RDX: remainder.
       // Check the corner case of dividing the 'MIN_SMI' with -1, in which
       // case we cannot tag the result.
-      __ cmpq(result, Immediate(0x4000000000000000));
+      __ CompareImmediate(result, Immediate(0x4000000000000000), PP);
       __ j(EQUAL, deopt);
       __ Bind(&done);
       __ SmiTag(result);
       break;
     }
     case Token::kSHR: {
       if (CanDeoptimize()) {
-        __ cmpq(right, Immediate(0));
+        __ CompareImmediate(right, Immediate(0), PP);
         __ j(LESS, deopt);
       }
       __ SmiUntag(right);
       // sarq operation masks the count to 6 bits.
       const intptr_t kCountLimit = 0x3F;
       Range* right_range = this->right()->definition()->range();
       if ((right_range == NULL) ||
           !right_range->IsWithin(RangeBoundary::kMinusInfinity, kCountLimit)) {
-        __ cmpq(right, Immediate(kCountLimit));
+        __ CompareImmediate(right, Immediate(kCountLimit), PP);
         Label count_ok;
         __ j(LESS, &count_ok, Assembler::kNearJump);
-        __ movq(right, Immediate(kCountLimit));
+        __ LoadImmediate(right, Immediate(kCountLimit), PP);
         __ Bind(&count_ok);
       }
       ASSERT(right == RCX);  // Count must be in RCX
       __ SmiUntag(left);
       __ sarq(left, right);
       __ SmiTag(left);
       break;
     }
     case Token::kDIV: {
       // Dispatches to 'Double./'.
@@ skipping 107 matching lines @@
 void BoxDoubleInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   BoxDoubleSlowPath* slow_path = new BoxDoubleSlowPath(this);
   compiler->AddSlowPathCode(slow_path);
 
   Register out_reg = locs()->out().reg();
   XmmRegister value = locs()->in(0).fpu_reg();
 
   __ TryAllocate(compiler->double_class(),
                  slow_path->entry_label(),
                  Assembler::kFarJump,
-                 out_reg);
+                 out_reg,
+                 PP);
   __ Bind(slow_path->exit_label());
   __ movsd(FieldAddress(out_reg, Double::value_offset()), value);
 }
 
 
 LocationSummary* UnboxDoubleInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
@@ skipping 81 matching lines @@
 void BoxFloat32x4Instr::EmitNativeCode(FlowGraphCompiler* compiler) {
   BoxFloat32x4SlowPath* slow_path = new BoxFloat32x4SlowPath(this);
   compiler->AddSlowPathCode(slow_path);
 
   Register out_reg = locs()->out().reg();
   XmmRegister value = locs()->in(0).fpu_reg();
 
   __ TryAllocate(compiler->float32x4_class(),
                  slow_path->entry_label(),
                  Assembler::kFarJump,
-                 out_reg);
+                 out_reg,
+                 PP);
   __ Bind(slow_path->exit_label());
   __ movups(FieldAddress(out_reg, Float32x4::value_offset()), value);
 }
 
 
 LocationSummary* UnboxFloat32x4Instr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   return LocationSummary::Make(kNumInputs,
                                Location::RequiresFpuRegister(),
                                LocationSummary::kNoCall);
@@ skipping 64 matching lines @@
 void BoxUint32x4Instr::EmitNativeCode(FlowGraphCompiler* compiler) {
   BoxUint32x4SlowPath* slow_path = new BoxUint32x4SlowPath(this);
   compiler->AddSlowPathCode(slow_path);
 
   Register out_reg = locs()->out().reg();
   XmmRegister value = locs()->in(0).fpu_reg();
 
   __ TryAllocate(compiler->uint32x4_class(),
                  slow_path->entry_label(),
                  Assembler::kFarJump,
-                 out_reg);
+                 out_reg,
+                 PP);
   __ Bind(slow_path->exit_label());
   __ movups(FieldAddress(out_reg, Uint32x4::value_offset()), value);
 }
 
 
 LocationSummary* UnboxUint32x4Instr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
@@ skipping 149 matching lines @@
   return summary;
 }
 
 
 void Float32x4ConstructorInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   XmmRegister v0 = locs()->in(0).fpu_reg();
   XmmRegister v1 = locs()->in(1).fpu_reg();
   XmmRegister v2 = locs()->in(2).fpu_reg();
   XmmRegister v3 = locs()->in(3).fpu_reg();
   ASSERT(v0 == locs()->out().fpu_reg());
-  __ subq(RSP, Immediate(16));
+  __ AddImmediate(RSP, Immediate(-16), PP);
   __ cvtsd2ss(v0, v0);
   __ movss(Address(RSP, 0), v0);
   __ movsd(v0, v1);
   __ cvtsd2ss(v0, v0);
   __ movss(Address(RSP, 4), v0);
   __ movsd(v0, v2);
   __ cvtsd2ss(v0, v0);
   __ movss(Address(RSP, 8), v0);
   __ movsd(v0, v3);
   __ cvtsd2ss(v0, v0);
   __ movss(Address(RSP, 12), v0);
   __ movups(v0, Address(RSP, 0));
-  __ addq(RSP, Immediate(16));
+  __ AddImmediate(RSP, Immediate(16), PP);
 }
 
 
 LocationSummary* Float32x4ZeroInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 0;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
   summary->set_out(Location::RequiresFpuRegister());
   return summary;
@@ skipping 224 matching lines @@
 
 void Float32x4WithInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   XmmRegister replacement = locs()->in(0).fpu_reg();
   XmmRegister value = locs()->in(1).fpu_reg();
 
   ASSERT(locs()->out().fpu_reg() == replacement);
 
   switch (op_kind()) {
     case MethodRecognizer::kFloat32x4WithX:
       __ cvtsd2ss(replacement, replacement);
-      __ subq(RSP, Immediate(16));
+      __ AddImmediate(RSP, Immediate(-16), PP);
       // Move value to stack.
       __ movups(Address(RSP, 0), value);
       // Write over X value.
       __ movss(Address(RSP, 0), replacement);
       // Move updated value into output register.
       __ movups(replacement, Address(RSP, 0));
-      __ addq(RSP, Immediate(16));
+      __ AddImmediate(RSP, Immediate(16), PP);
       break;
     case MethodRecognizer::kFloat32x4WithY:
       __ cvtsd2ss(replacement, replacement);
-      __ subq(RSP, Immediate(16));
+      __ AddImmediate(RSP, Immediate(-16), PP);
       // Move value to stack.
       __ movups(Address(RSP, 0), value);
       // Write over Y value.
       __ movss(Address(RSP, 4), replacement);
       // Move updated value into output register.
       __ movups(replacement, Address(RSP, 0));
-      __ addq(RSP, Immediate(16));
+      __ AddImmediate(RSP, Immediate(16), PP);
       break;
     case MethodRecognizer::kFloat32x4WithZ:
       __ cvtsd2ss(replacement, replacement);
-      __ subq(RSP, Immediate(16));
+      __ AddImmediate(RSP, Immediate(-16), PP);
       // Move value to stack.
       __ movups(Address(RSP, 0), value);
       // Write over Z value.
       __ movss(Address(RSP, 8), replacement);
       // Move updated value into output register.
       __ movups(replacement, Address(RSP, 0));
-      __ addq(RSP, Immediate(16));
+      __ AddImmediate(RSP, Immediate(16), PP);
       break;
     case MethodRecognizer::kFloat32x4WithW:
       __ cvtsd2ss(replacement, replacement);
-      __ subq(RSP, Immediate(16));
+      __ AddImmediate(RSP, Immediate(-16), PP);
       // Move value to stack.
       __ movups(Address(RSP, 0), value);
       // Write over W value.
       __ movss(Address(RSP, 12), replacement);
       // Move updated value into output register.
       __ movups(replacement, Address(RSP, 0));
-      __ addq(RSP, Immediate(16));
+      __ AddImmediate(RSP, Immediate(16), PP);
       break;
     default: UNREACHABLE();
   }
 }
 
 
 LocationSummary* Float32x4ToUint32x4Instr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary =
@@ skipping 67 matching lines @@
   Register v0 = locs()->in(0).reg();
   Register v1 = locs()->in(1).reg();
   Register v2 = locs()->in(2).reg();
   Register v3 = locs()->in(3).reg();
   Register temp = locs()->temp(0).reg();
   XmmRegister result = locs()->out().fpu_reg();
   Label x_false, x_done;
   Label y_false, y_done;
   Label z_false, z_done;
   Label w_false, w_done;
-  __ subq(RSP, Immediate(16));
+  __ AddImmediate(RSP, Immediate(-16), PP);
 
-  __ CompareObject(v0, Bool::True());
+  __ CompareObject(v0, Bool::True(), PP);
   __ j(NOT_EQUAL, &x_false);
-  __ movq(temp, Immediate(0xFFFFFFFF));
+  __ LoadImmediate(temp, Immediate(0xFFFFFFFF), PP);
   __ jmp(&x_done);
   __ Bind(&x_false);
-  __ movq(temp, Immediate(0x0));
+  __ LoadImmediate(temp, Immediate(0x0), PP);
   __ Bind(&x_done);
   __ movl(Address(RSP, 0), temp);
 
-  __ CompareObject(v1, Bool::True());
+  __ CompareObject(v1, Bool::True(), PP);
   __ j(NOT_EQUAL, &y_false);
-  __ movq(temp, Immediate(0xFFFFFFFF));
+  __ LoadImmediate(temp, Immediate(0xFFFFFFFF), PP);
   __ jmp(&y_done);
   __ Bind(&y_false);
-  __ movq(temp, Immediate(0x0));
+  __ LoadImmediate(temp, Immediate(0x0), PP);
   __ Bind(&y_done);
   __ movl(Address(RSP, 4), temp);
 
-  __ CompareObject(v2, Bool::True());
+  __ CompareObject(v2, Bool::True(), PP);
   __ j(NOT_EQUAL, &z_false);
-  __ movq(temp, Immediate(0xFFFFFFFF));
+  __ LoadImmediate(temp, Immediate(0xFFFFFFFF), PP);
   __ jmp(&z_done);
   __ Bind(&z_false);
-  __ movq(temp, Immediate(0x0));
+  __ LoadImmediate(temp, Immediate(0x0), PP);
   __ Bind(&z_done);
   __ movl(Address(RSP, 8), temp);
 
-  __ CompareObject(v3, Bool::True());
+  __ CompareObject(v3, Bool::True(), PP);
   __ j(NOT_EQUAL, &w_false);
-  __ movq(temp, Immediate(0xFFFFFFFF));
+  __ LoadImmediate(temp, Immediate(0xFFFFFFFF), PP);
   __ jmp(&w_done);
   __ Bind(&w_false);
-  __ movq(temp, Immediate(0x0));
+  __ LoadImmediate(temp, Immediate(0x0), PP);
   __ Bind(&w_done);
   __ movl(Address(RSP, 12), temp);
 
   __ movups(result, Address(RSP, 0));
-  __ addq(RSP, Immediate(16));
+  __ AddImmediate(RSP, Immediate(16), PP);
 }
 
 
 LocationSummary* Uint32x4GetFlagInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
   summary->set_in(0, Location::RequiresFpuRegister());
   summary->set_out(Location::RequiresRegister());
   return summary;
 }
 
 
 void Uint32x4GetFlagInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   XmmRegister value = locs()->in(0).fpu_reg();
   Register result = locs()->out().reg();
   Label done;
   Label non_zero;
-  __ subq(RSP, Immediate(16));
+  __ AddImmediate(RSP, Immediate(-16), PP);
   // Move value to stack.
   __ movups(Address(RSP, 0), value);
   switch (op_kind()) {
     case MethodRecognizer::kUint32x4GetFlagX:
       __ movl(result, Address(RSP, 0));
       break;
     case MethodRecognizer::kUint32x4GetFlagY:
       __ movl(result, Address(RSP, 4));
       break;
     case MethodRecognizer::kUint32x4GetFlagZ:
       __ movl(result, Address(RSP, 8));
       break;
     case MethodRecognizer::kUint32x4GetFlagW:
       __ movl(result, Address(RSP, 12));
       break;
     default: UNREACHABLE();
   }
-  __ addq(RSP, Immediate(16));
+  __ AddImmediate(RSP, Immediate(16), PP);
   __ testl(result, result);
   __ j(NOT_ZERO, &non_zero, Assembler::kNearJump);
   __ LoadObject(result, Bool::False(), PP);
   __ jmp(&done);
   __ Bind(&non_zero);
   __ LoadObject(result, Bool::True(), PP);
   __ Bind(&done);
 }
 
 
@@ skipping 42 matching lines @@
   summary->set_out(Location::SameAsFirstInput());
   return summary;
 }
 
 
 void Uint32x4SetFlagInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   XmmRegister mask = locs()->in(0).fpu_reg();
   Register flag = locs()->in(1).reg();
   Register temp = locs()->temp(0).reg();
   ASSERT(mask == locs()->out().fpu_reg());
-  __ subq(RSP, Immediate(16));
+  __ AddImmediate(RSP, Immediate(-16), PP);
   // Copy mask to stack.
   __ movups(Address(RSP, 0), mask);
   Label falsePath, exitPath;
-  __ CompareObject(flag, Bool::True());
+  __ CompareObject(flag, Bool::True(), PP);
   __ j(NOT_EQUAL, &falsePath);
   switch (op_kind()) {
     case MethodRecognizer::kUint32x4WithFlagX:
-      __ movq(temp, Immediate(0xFFFFFFFF));
+      __ LoadImmediate(temp, Immediate(0xFFFFFFFF), PP);
       __ movl(Address(RSP, 0), temp);
       __ jmp(&exitPath);
       __ Bind(&falsePath);
-      __ movq(temp, Immediate(0x0));
+      __ LoadImmediate(temp, Immediate(0x0), PP);
       __ movl(Address(RSP, 0), temp);
     break;
     case MethodRecognizer::kUint32x4WithFlagY:
-      __ movq(temp, Immediate(0xFFFFFFFF));
+      __ LoadImmediate(temp, Immediate(0xFFFFFFFF), PP);
       __ movl(Address(RSP, 4), temp);
       __ jmp(&exitPath);
       __ Bind(&falsePath);
-      __ movq(temp, Immediate(0x0));
+      __ LoadImmediate(temp, Immediate(0x0), PP);
       __ movl(Address(RSP, 4), temp);
     break;
     case MethodRecognizer::kUint32x4WithFlagZ:
-      __ movq(temp, Immediate(0xFFFFFFFF));
+      __ LoadImmediate(temp, Immediate(0xFFFFFFFF), PP);
       __ movl(Address(RSP, 8), temp);
       __ jmp(&exitPath);
       __ Bind(&falsePath);
-      __ movq(temp, Immediate(0x0));
+      __ LoadImmediate(temp, Immediate(0x0), PP);
       __ movl(Address(RSP, 8), temp);
     break;
     case MethodRecognizer::kUint32x4WithFlagW:
-      __ movq(temp, Immediate(0xFFFFFFFF));
+      __ LoadImmediate(temp, Immediate(0xFFFFFFFF), PP);
       __ movl(Address(RSP, 12), temp);
       __ jmp(&exitPath);
       __ Bind(&falsePath);
-      __ movq(temp, Immediate(0x0));
+      __ LoadImmediate(temp, Immediate(0x0), PP);
       __ movl(Address(RSP, 12), temp);
     break;
     default: UNREACHABLE();
   }
   __ Bind(&exitPath);
   // Copy mask back to register.
   __ movups(mask, Address(RSP, 0));
-  __ addq(RSP, Immediate(16));
+  __ AddImmediate(RSP, Immediate(16), PP);
 }
 
 
 LocationSummary* Uint32x4ToFloat32x4Instr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
   summary->set_in(0, Location::RequiresFpuRegister());
   summary->set_out(Location::SameAsFirstInput());
@@ skipping 102 matching lines @@
                                             kDeoptUnaryOp);
       __ negq(value);
       __ j(OVERFLOW, deopt);
       if (FLAG_throw_on_javascript_int_overflow) {
         EmitJavascriptOverflowCheck(compiler, range(), deopt, value);
       }
       break;
     }
     case Token::kBIT_NOT:
       __ notq(value);
-      __ andq(value, Immediate(~kSmiTagMask));  // Remove inverted smi-tag.
+      // Remove inverted smi-tag.
+      __ AndImmediate(value, Immediate(~kSmiTagMask), PP);
       break;
     default:
       UNREACHABLE();
   }
 }
 
 
 LocationSummary* UnaryDoubleOpInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
@@ skipping 54 matching lines @@
     const Condition double_condition =
         is_min ? TokenKindToDoubleCondition(Token::kLT)
                : TokenKindToDoubleCondition(Token::kGT);
     ASSERT(left == result);
     __ j(double_condition, &done, Assembler::kNearJump);
     __ movsd(result, right);
     __ jmp(&done, Assembler::kNearJump);
 
     __ Bind(&returns_nan);
     static double kNaN = NAN;
-    __ movq(temp, Immediate(reinterpret_cast<intptr_t>(&kNaN)));
+    __ LoadImmediate(temp, Immediate(reinterpret_cast<intptr_t>(&kNaN)), PP);
     __ movsd(result, Address(temp, 0));
     __ jmp(&done, Assembler::kNearJump);
 
     __ Bind(&are_equal);
     Label left_is_negative;
     // Check for negative zero: -0.0 is equal 0.0 but min or max must return
     // -0.0 or 0.0 respectively.
     // Check for negative left value (get the sign bit):
     // - min -> left is negative ? left : right.
     // - max -> left is negative ? right : left
@@ skipping 305 matching lines @@
   }
   return summary;
 }
 
 
 void CheckClassInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   if (IsNullCheck()) {
     Label* deopt = compiler->AddDeoptStub(deopt_id(),
                                           kDeoptCheckClass);
     __ CompareObject(locs()->in(0).reg(),
-                     Object::null_object());
+                     Object::null_object(), PP);
     __ j(EQUAL, deopt);
     return;
   }
 
   ASSERT((unary_checks().GetReceiverClassIdAt(0) != kSmiCid) ||
          (unary_checks().NumberOfChecks() > 1));
   Register value = locs()->in(0).reg();
   Register temp = locs()->temp(0).reg();
   Label* deopt = compiler->AddDeoptStub(deopt_id(),
                                         kDeoptCheckClass);
@@ skipping 76 matching lines @@
            (Smi::Cast(index_loc.constant()).Value() < 0));
     // Unconditionally deoptimize for constant bounds checks because they
     // only occur only when index is out-of-bounds.
     __ jmp(deopt);
     return;
   }
 
   if (index_loc.IsConstant()) {
     Register length = length_loc.reg();
     const Smi& index = Smi::Cast(index_loc.constant());
-    __ cmpq(length, Immediate(reinterpret_cast<int64_t>(index.raw())));
+    __ CompareImmediate(
+        length, Immediate(reinterpret_cast<int64_t>(index.raw())), PP);
     __ j(BELOW_EQUAL, deopt);
   } else if (length_loc.IsConstant()) {
     const Smi& length = Smi::Cast(length_loc.constant());
     Register index = index_loc.reg();
-    __ cmpq(index, Immediate(reinterpret_cast<int64_t>(length.raw())));
+    __ CompareImmediate(
+        index, Immediate(reinterpret_cast<int64_t>(length.raw())), PP);
     __ j(ABOVE_EQUAL, deopt);
   } else {
     Register length = length_loc.reg();
     Register index = index_loc.reg();
     __ cmpq(index, length);
     __ j(ABOVE_EQUAL, deopt);
   }
 }
 
 
@@ skipping 95 matching lines @@
   if (!compiler->is_optimizing()) {
     compiler->AddCurrentDescriptor(PcDescriptors::kDeopt,
                                    deopt_id_,
                                    Scanner::kDummyTokenIndex);
     // Add an edge counter.
     const Array& counter = Array::ZoneHandle(Array::New(1, Heap::kOld));
     counter.SetAt(0, Smi::Handle(Smi::New(0)));
     Label done;
     __ Comment("Edge counter");
     __ LoadObject(RAX, counter, PP);
-    __ addq(FieldAddress(RAX, Array::element_offset(0)),
-            Immediate(Smi::RawValue(1)));
+    __ AddImmediate(FieldAddress(RAX, Array::element_offset(0)),
+                    Immediate(Smi::RawValue(1)), PP);
     __ j(NO_OVERFLOW, &done);
-    __ movq(FieldAddress(RAX, Array::element_offset(0)),
-            Immediate(Smi::RawValue(Smi::kMaxValue)));
+    __ LoadImmediate(FieldAddress(RAX, Array::element_offset(0)),
+                     Immediate(Smi::RawValue(Smi::kMaxValue)), PP);
     __ Bind(&done);
   }
   if (HasParallelMove()) {
     compiler->parallel_move_resolver()->EmitNativeCode(parallel_move());
   }
 }
 
 
 LocationSummary* GotoInstr::MakeLocationSummary() const {
   return new LocationSummary(0, 0, LocationSummary::kNoCall);
 }
 
 
 void GotoInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   if (!compiler->is_optimizing()) {
     // Add deoptimization descriptor for deoptimizing instructions that may
     // be inserted before this instruction.
     compiler->AddCurrentDescriptor(PcDescriptors::kDeopt,
                                    GetDeoptId(),
                                    0);  // No token position.
     // Add an edge counter.
     const Array& counter = Array::ZoneHandle(Array::New(1, Heap::kOld));
     counter.SetAt(0, Smi::Handle(Smi::New(0)));
     Label done;
     __ Comment("Edge counter");
     __ LoadObject(RAX, counter, PP);
-    __ addq(FieldAddress(RAX, Array::element_offset(0)),
-            Immediate(Smi::RawValue(1)));
+    __ AddImmediate(FieldAddress(RAX, Array::element_offset(0)),
+                    Immediate(Smi::RawValue(1)), PP);
     __ j(NO_OVERFLOW, &done);
-    __ movq(FieldAddress(RAX, Array::element_offset(0)),
-            Immediate(Smi::RawValue(Smi::kMaxValue)));
+    __ LoadImmediate(FieldAddress(RAX, Array::element_offset(0)),
+                     Immediate(Smi::RawValue(Smi::kMaxValue)), PP);
     __ Bind(&done);
   }
   if (HasParallelMove()) {
     compiler->parallel_move_resolver()->EmitNativeCode(parallel_move());
   }
 
   // We can fall through if the successor is the next block in the list.
   // Otherwise, we need a jump.
   if (!compiler->CanFallThroughTo(successor())) {
     __ jmp(compiler->GetJumpLabel(successor()));
@@ skipping 238 matching lines @@
                          PcDescriptors::kOther,
                          locs());
   __ Drop(2);  // Discard type arguments and receiver.
 }
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64