Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(173)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: runtime/vm/intermediate_language_x64.cc

Issue 25118002: Eliminates more large immediates from x64 code. (Closed) Base URL: http://dart.googlecode.com/svn/branches/bleeding_edge/dart/
Patch Set: Created 7 years, 3 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« runtime/vm/assembler_x64.cc ('K') | « runtime/vm/flow_graph_compiler_x64.cc ('k') | runtime/vm/intrinsifier_x64.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: runtime/vm/intermediate_language_x64.cc
===================================================================
--- runtime/vm/intermediate_language_x64.cc (revision 28026)
+++ runtime/vm/intermediate_language_x64.cc (working copy)
@@ -52,7 +52,7 @@
if (value.IsRegister()) {
__ pushq(value.reg());
} else if (value.IsConstant()) {
- __ PushObject(value.constant());
+ __ PushObject(value.constant(), PP);
} else {
ASSERT(value.IsStackSlot());
__ pushq(value.ToStackSlotAddress());
@@ -90,7 +90,7 @@
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);
@@ -196,9 +196,9 @@
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;
}
@@ -212,9 +212,9 @@
// 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());
}
@@ -251,11 +251,11 @@
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);
}
}
}
@@ -341,9 +341,9 @@
// 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.
@@ -522,7 +522,7 @@
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);
@@ -540,7 +540,7 @@
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) {
@@ -579,7 +579,7 @@
// 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 {
@@ -614,7 +614,7 @@
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);
@@ -625,7 +625,7 @@
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);
}
}
@@ -655,16 +655,16 @@
// '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 {
@@ -706,9 +706,9 @@
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);
@@ -765,10 +765,10 @@
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 {
@@ -897,7 +897,7 @@
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);
}
@@ -968,7 +968,7 @@
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 +
@@ -977,8 +977,10 @@
__ 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();
@@ -1014,8 +1016,8 @@
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.
@@ -1052,7 +1054,7 @@
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);
@@ -1360,7 +1362,7 @@
__ 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);
@@ -1397,14 +1399,14 @@
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);
}
@@ -1538,13 +1540,15 @@
__ 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);
@@ -1558,15 +1562,18 @@
// 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);
@@ -1577,9 +1584,9 @@
__ 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,
@@ -1596,21 +1603,22 @@
__ 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);
@@ -1629,7 +1637,7 @@
}
__ j(EQUAL, &ok);
- __ cmpq(field_cid_operand, Immediate(kIllegalCid));
+ __ CompareImmediate(field_cid_operand, Immediate(kIllegalCid), PP);
__ j(NOT_EQUAL, fail);
if (value_cid == kDynamicCid) {
@@ -1637,13 +1645,15 @@
__ 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).
@@ -1654,9 +1664,9 @@
__ 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,
@@ -1665,14 +1675,14 @@
// 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)) {
@@ -1686,8 +1696,8 @@
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);
}
}
}
@@ -1706,7 +1716,7 @@
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) {
@@ -1732,7 +1742,7 @@
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) {
@@ -1757,7 +1767,8 @@
__ 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);
}
@@ -1773,8 +1784,8 @@
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);
@@ -1811,7 +1822,7 @@
} 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,
@@ -1909,7 +1920,7 @@
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,
@@ -1970,8 +1981,8 @@
// '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(),
@@ -2011,13 +2022,13 @@
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(),
@@ -2060,7 +2071,7 @@
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
@@ -2102,12 +2113,12 @@
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.
}
@@ -2128,7 +2139,7 @@
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(),
@@ -2153,7 +2164,7 @@
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(),
@@ -2255,7 +2266,8 @@
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()) {
@@ -2265,8 +2277,8 @@
__ 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());
@@ -2279,9 +2291,9 @@
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);
}
}
@@ -2342,7 +2354,7 @@
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;
}
@@ -2351,8 +2363,8 @@
(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);
@@ -2374,12 +2386,12 @@
!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);
@@ -2394,8 +2406,8 @@
} 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.
@@ -2518,12 +2530,12 @@
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;
}
@@ -2533,7 +2545,7 @@
if (value == 2) {
__ shlq(left, Immediate(1));
} else {
- __ imulq(left, Immediate(value));
+ __ MulImmediate(left, Immediate(value), PP);
}
if (deopt != NULL) __ j(OVERFLOW, deopt);
break;
@@ -2546,7 +2558,7 @@
} 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;
@@ -2572,17 +2584,17 @@
}
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;
}
@@ -2738,7 +2750,7 @@
__ 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);
@@ -2746,7 +2758,7 @@
}
case Token::kSHR: {
if (CanDeoptimize()) {
- __ cmpq(right, Immediate(0));
+ __ CompareImmediate(right, Immediate(0), PP);
__ j(LESS, deopt);
}
__ SmiUntag(right);
@@ -2755,10 +2767,10 @@
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
@@ -2886,7 +2898,8 @@
__ 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);
}
@@ -2988,7 +3001,8 @@
__ 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);
}
@@ -3073,7 +3087,8 @@
__ 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);
}
@@ -3243,7 +3258,7 @@
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);
@@ -3256,7 +3271,7 @@
__ cvtsd2ss(v0, v0);
__ movss(Address(RSP, 12), v0);
__ movups(v0, Address(RSP, 0));
- __ addq(RSP, Immediate(16));
+ __ AddImmediate(RSP, Immediate(16), PP);
}
@@ -3501,47 +3516,47 @@
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();
}
@@ -3629,46 +3644,46 @@
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);
}
@@ -3688,7 +3703,7 @@
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()) {
@@ -3706,7 +3721,7 @@
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);
@@ -3769,43 +3784,43 @@
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();
@@ -3813,7 +3828,7 @@
__ Bind(&exitPath);
// Copy mask back to register.
__ movups(mask, Address(RSP, 0));
- __ addq(RSP, Immediate(16));
+ __ AddImmediate(RSP, Immediate(16), PP);
}
@@ -3936,7 +3951,8 @@
}
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();
@@ -4011,7 +4027,7 @@
__ 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);
@@ -4337,7 +4353,7 @@
Label* deopt = compiler->AddDeoptStub(deopt_id(),
kDeoptCheckClass);
__ CompareObject(locs()->in(0).reg(),
- Object::null_object());
+ Object::null_object(), PP);
__ j(EQUAL, deopt);
return;
}
@@ -4434,12 +4450,14 @@
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();
@@ -4555,11 +4573,11 @@
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()) {
@@ -4586,11 +4604,11 @@
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()) {
« runtime/vm/assembler_x64.cc ('K') | « runtime/vm/flow_graph_compiler_x64.cc ('k') | runtime/vm/intrinsifier_x64.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698