runtime/vm/intermediate_language_x64.cc - Issue 1268783003: Simplify constant pool usage in x64 code generator (by removing extra argument

Unified Diff: runtime/vm/intermediate_language_x64.cc

Issue 1268783003: Simplify constant pool usage in x64 code generator (by removing extra argument (Closed) Base URL: git@github.com:dart-lang/sdk.git@master

Patch Set: Make PP implicit in LoadPoolPointer Created 5 years, 5 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

Index: runtime/vm/intermediate_language_x64.cc

diff --git a/runtime/vm/intermediate_language_x64.cc b/runtime/vm/intermediate_language_x64.cc

index 05d7833628b607200f8b42cf4b5dbadf6acbeee0..29a70d78920d1d8f9d9edd67247b33c5f5262910 100644

--- a/runtime/vm/intermediate_language_x64.cc

+++ b/runtime/vm/intermediate_language_x64.cc

@@ -56,7 +56,7 @@ void PushArgumentInstr::EmitNativeCode(FlowGraphCompiler* compiler) {

if (value.IsRegister()) {

__ pushq(value.reg());

} else if (value.IsConstant()) {

- __ PushObject(value.constant(), PP);

+ __ PushObject(value.constant());

} else {

ASSERT(value.IsStackSlot());

__ pushq(value.ToStackSlotAddress());

@@ -97,13 +97,16 @@ void ReturnInstr::EmitNativeCode(FlowGraphCompiler* compiler) {

ASSERT(fp_sp_dist <= 0);

__ movq(RDI, RSP);

__ subq(RDI, RBP);

- __ CompareImmediate(RDI, Immediate(fp_sp_dist), PP);

+ __ CompareImmediate(RDI, Immediate(fp_sp_dist));

__ j(EQUAL, &done, Assembler::kNearJump);

__ int3();

__ Bind(&done);

#endif

- __ LeaveDartFrame();

+ __ LeaveDartFrame(); // Disallows constant pool use.

__ ret();

+ // This ReturnInstr may be emitted out of order by the optimizer. The next

+ // block may be a target expecting a properly set constant pool pointer.

+ __ set_constant_pool_allowed(true);

zra 2015/07/31 17:37:28 I guess it's not possible for ReturnInstr to be em

regis 2015/07/31 19:33:59 Done.

}

@@ -183,9 +186,9 @@ void IfThenElseInstr::EmitNativeCode(FlowGraphCompiler* compiler) {

} else {

__ decq(RDX);

__ AndImmediate(RDX,

- Immediate(Smi::RawValue(true_value) - Smi::RawValue(false_value)), PP);

+ Immediate(Smi::RawValue(true_value) - Smi::RawValue(false_value)));

if (false_value != 0) {

- __ AddImmediate(RDX, Immediate(Smi::RawValue(false_value)), PP);

+ __ AddImmediate(RDX, Immediate(Smi::RawValue(false_value)));

}

@@ -242,7 +245,7 @@ void ConstantInstr::EmitNativeCode(FlowGraphCompiler* compiler) {

// The register allocator drops constant definitions that have no uses.

if (!locs()->out(0).IsInvalid()) {

- __ LoadObject(result, value(), PP);

+ __ LoadObject(result, value());

}

@@ -277,7 +280,7 @@ void UnboxedConstantInstr::EmitNativeCode(FlowGraphCompiler* compiler) {

if (Utils::DoublesBitEqual(Double::Cast(value()).value(), 0.0)) {

__ xorps(result, result);

} else {

- __ LoadObject(TMP, value(), PP);

+ __ LoadObject(TMP, value());

__ movsd(result, FieldAddress(TMP, Double::value_offset()));

}

break;

@@ -330,13 +333,13 @@ static void EmitAssertBoolean(Register reg,

Label done;

if (Isolate::Current()->flags().type_checks()) {

- __ CompareObject(reg, Bool::True(), PP);

+ __ CompareObject(reg, Bool::True());

__ j(EQUAL, &done, Assembler::kNearJump);

- __ CompareObject(reg, Bool::False(), PP);

+ __ CompareObject(reg, Bool::False());

__ j(EQUAL, &done, Assembler::kNearJump);

} else {

ASSERT(Isolate::Current()->flags().asserts());

- __ CompareObject(reg, Object::null_instance(), PP);

+ __ CompareObject(reg, Object::null_instance());

__ j(NOT_EQUAL, &done, Assembler::kNearJump);

}

@@ -422,7 +425,7 @@ static void LoadValueCid(FlowGraphCompiler* compiler,

Label* value_is_smi = NULL) {

Label done;

if (value_is_smi == NULL) {

- __ LoadImmediate(value_cid_reg, Immediate(kSmiCid), PP);

+ __ LoadImmediate(value_cid_reg, Immediate(kSmiCid));

}

__ testq(value_reg, Immediate(kSmiTagMask));

if (value_is_smi == NULL) {

@@ -484,10 +487,10 @@ static Condition EmitInt64ComparisonOp(FlowGraphCompiler* compiler,

Condition true_condition = TokenKindToIntCondition(kind);

if (left.IsConstant()) {

- __ CompareObject(right.reg(), left.constant(), PP);

+ __ CompareObject(right.reg(), left.constant());

true_condition = FlipCondition(true_condition);

} else if (right.IsConstant()) {

- __ CompareObject(left.reg(), right.constant(), PP);

+ __ CompareObject(left.reg(), right.constant());

} else if (right.IsStackSlot()) {

__ cmpq(left.reg(), right.ToStackSlotAddress());

} else {

@@ -551,10 +554,10 @@ void EqualityCompareInstr::EmitNativeCode(FlowGraphCompiler* compiler) {

Label done;

__ Bind(&is_false);

- __ LoadObject(result, Bool::False(), PP);

+ __ LoadObject(result, Bool::False());

__ jmp(&done);

__ Bind(&is_true);

- __ LoadObject(result, Bool::True(), PP);

+ __ LoadObject(result, Bool::True());

__ Bind(&done);

}

@@ -591,7 +594,7 @@ Condition TestSmiInstr::EmitComparisonCode(FlowGraphCompiler* compiler,

ASSERT(right.constant().IsSmi());

const int64_t imm =

reinterpret_cast<int64_t>(right.constant().raw());

- __ TestImmediate(left_reg, Immediate(imm), PP);

+ __ TestImmediate(left_reg, Immediate(imm));

} else {

__ testq(left_reg, right.reg());

}

@@ -679,10 +682,10 @@ void TestCidsInstr::EmitNativeCode(FlowGraphCompiler* compiler) {

BranchLabels labels = { &is_true, &is_false, &is_false };

EmitComparisonCode(compiler, labels);

__ Bind(&is_false);

- __ LoadObject(result_reg, Bool::False(), PP);

+ __ LoadObject(result_reg, Bool::False());

__ jmp(&done, Assembler::kNearJump);

__ Bind(&is_true);

- __ LoadObject(result_reg, Bool::True(), PP);

+ __ LoadObject(result_reg, Bool::True());

__ Bind(&done);

}

@@ -740,10 +743,10 @@ void RelationalOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {

Label done;

__ Bind(&is_false);

- __ LoadObject(result, Bool::False(), PP);

+ __ LoadObject(result, Bool::False());

__ jmp(&done);

__ Bind(&is_true);

- __ LoadObject(result, Bool::True(), PP);

+ __ LoadObject(result, Bool::True());

__ Bind(&done);

}

@@ -769,19 +772,17 @@ void NativeCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) {

(argc_tag & NativeArguments::AutoSetupScopeMask()) == 0;

// Push the result place holder initialized to NULL.

- __ PushObject(Object::null_object(), PP);

+ __ PushObject(Object::null_object());

// 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));

+ __ leaq(RAX, Address(RBP, kFirstLocalSlotFromFp * kWordSize));

}

__ LoadImmediate(

- RBX, Immediate(reinterpret_cast<uword>(native_c_function())), PP);

- __ LoadImmediate(

- R10, Immediate(argc_tag), PP);

+ RBX, Immediate(reinterpret_cast<uword>(native_c_function())));

+ __ LoadImmediate(R10, Immediate(argc_tag));

const ExternalLabel* stub_entry = (is_bootstrap_native() || is_leaf_call) ?

&StubCode::CallBootstrapCFunctionLabel() :

&StubCode::CallNativeCFunctionLabel();

@@ -821,7 +822,7 @@ void StringFromCharCodeInstr::EmitNativeCode(FlowGraphCompiler* compiler) {

__ LoadImmediate(result,

- Immediate(reinterpret_cast<uword>(Symbols::PredefinedAddress())), PP);

+ Immediate(reinterpret_cast<uword>(Symbols::PredefinedAddress())));

__ movq(result, Address(result,

char_code,

TIMES_HALF_WORD_SIZE, // Char code is a smi.

@@ -926,7 +927,7 @@ void LoadClassIdInstr::EmitNativeCode(FlowGraphCompiler* compiler) {

// branch prediction usually working just fine in this case.

__ testq(object, Immediate(kSmiTagMask));

__ j(NOT_ZERO, &load, Assembler::kNearJump);

- __ LoadImmediate(result, Immediate(Smi::RawValue(kSmiCid)), PP);

+ __ LoadImmediate(result, Immediate(Smi::RawValue(kSmiCid)));

__ jmp(&done);

__ Bind(&load);

__ LoadClassId(result, object);

@@ -1319,7 +1320,7 @@ void StoreIndexedInstr::EmitNativeCode(FlowGraphCompiler* compiler) {

__ StoreIntoObject(array, element_address, value);

} else if (locs()->in(2).IsConstant()) {

const Object& constant = locs()->in(2).constant();

- __ StoreIntoObjectNoBarrier(array, element_address, constant, PP);

+ __ StoreIntoObjectNoBarrier(array, element_address, constant);

} else {

__ StoreIntoObjectNoBarrier(array, element_address, value);

@@ -1356,14 +1357,14 @@ void StoreIndexedInstr::EmitNativeCode(FlowGraphCompiler* compiler) {

ASSERT(locs()->in(2).reg() == RAX);

Label store_value, store_0xff;

__ SmiUntag(RAX);

- __ CompareImmediate(RAX, Immediate(0xFF), PP);

+ __ CompareImmediate(RAX, Immediate(0xFF));

__ 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);

- __ LoadImmediate(RAX, Immediate(0xFF), PP);

+ __ LoadImmediate(RAX, Immediate(0xFF));

__ Bind(&store_value);

__ movb(element_address, RAX);

}

@@ -1472,7 +1473,7 @@ void GuardFieldClassInstr::EmitNativeCode(FlowGraphCompiler* compiler) {

Label* fail = (deopt != NULL) ? deopt : &fail_label;

if (emit_full_guard) {

- __ LoadObject(field_reg, Field::ZoneHandle(field().raw()), PP);

+ __ LoadObject(field_reg, Field::ZoneHandle(field().raw()));

FieldAddress field_cid_operand(field_reg, Field::guarded_cid_offset());

FieldAddress field_nullability_operand(

@@ -1541,12 +1542,12 @@ void GuardFieldClassInstr::EmitNativeCode(FlowGraphCompiler* compiler) {

if (field_cid != kSmiCid) {

__ j(ZERO, fail);

__ LoadClassId(value_cid_reg, value_reg);

- __ CompareImmediate(value_cid_reg, Immediate(field_cid), PP);

+ __ CompareImmediate(value_cid_reg, Immediate(field_cid));

}

if (field().is_nullable() && (field_cid != kNullCid)) {

__ j(EQUAL, &ok);

- __ CompareObject(value_reg, Object::null_object(), PP);

+ __ CompareObject(value_reg, Object::null_object());

}

__ j(NOT_EQUAL, fail);

@@ -1602,7 +1603,7 @@ void GuardFieldLengthInstr::EmitNativeCode(FlowGraphCompiler* compiler) {

Label ok;

- __ LoadObject(field_reg, Field::ZoneHandle(field().raw()), PP);

+ __ LoadObject(field_reg, Field::ZoneHandle(field().raw()));

__ movsxb(offset_reg, FieldAddress(field_reg,

Field::guarded_list_length_in_object_offset_offset()));

@@ -1639,8 +1640,7 @@ void GuardFieldLengthInstr::EmitNativeCode(FlowGraphCompiler* compiler) {

__ CompareImmediate(

FieldAddress(value_reg,

field().guarded_list_length_in_object_offset()),

- Immediate(Smi::RawValue(field().guarded_list_length())),

- PP);

+ Immediate(Smi::RawValue(field().guarded_list_length())));

__ j(NOT_EQUAL, deopt);

}

@@ -1690,8 +1690,7 @@ class BoxAllocationSlowPath : public SlowPathCode {

__ TryAllocate(cls,

compiler->intrinsic_slow_path_label(),

Assembler::kFarJump,

- result,

- PP);

+ result);

} else {

BoxAllocationSlowPath* slow_path =

new BoxAllocationSlowPath(instruction, cls, result);

@@ -1700,8 +1699,7 @@ class BoxAllocationSlowPath : public SlowPathCode {

__ TryAllocate(cls,

slow_path->entry_label(),

Assembler::kFarJump,

- result,

- PP);

+ result);

__ Bind(slow_path->exit_label());

}

@@ -1757,7 +1755,7 @@ static void EnsureMutableBox(FlowGraphCompiler* compiler,

Label done;

__ movq(box_reg, FieldAddress(instance_reg, offset));

- __ CompareObject(box_reg, Object::null_object(), PP);

+ __ CompareObject(box_reg, Object::null_object());

__ j(NOT_EQUAL, &done);

BoxAllocationSlowPath::Allocate(compiler, instruction, cls, box_reg);

__ movq(temp, box_reg);

@@ -1841,7 +1839,7 @@ void StoreInstanceFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) {

Label store_float32x4;

Label store_float64x2;

- __ LoadObject(temp, Field::ZoneHandle(field().raw()), PP);

+ __ LoadObject(temp, Field::ZoneHandle(field().raw()));

__ cmpl(FieldAddress(temp, Field::is_nullable_offset()),

Immediate(kNullCid));

@@ -1927,7 +1925,6 @@ void StoreInstanceFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) {

__ StoreIntoObjectNoBarrier(instance_reg,

FieldAddress(instance_reg, offset_in_bytes_),

locs()->in(1).constant(),

- PP,

is_object_reference_initialization_ ?

Assembler::kEmptyOrSmiOrNull :

Assembler::kHeapObjectOrSmi);

@@ -1984,7 +1981,7 @@ void StoreStaticFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) {

- __ LoadObject(temp, field(), PP);

+ __ LoadObject(temp, field());

if (this->value()->NeedsStoreBuffer()) {

__ StoreIntoObject(temp,

FieldAddress(temp, Field::value_offset()), value, CanValueBeSmi());

@@ -2070,7 +2067,7 @@ static void InlineArrayAllocation(FlowGraphCompiler* compiler,

// data area to be initialized.

if (num_elements > 0) {

const intptr_t array_size = instance_size - sizeof(RawArray);

- __ LoadObject(R12, Object::null_object(), PP);

+ __ LoadObject(R12, Object::null_object());

__ leaq(RDI, FieldAddress(RAX, sizeof(RawArray)));

if (array_size < (kInlineArraySize * kWordSize)) {

intptr_t current_offset = 0;

@@ -2108,7 +2105,7 @@ void CreateArrayInstr::EmitNativeCode(FlowGraphCompiler* compiler) {

Label slow_path, done;

InlineArrayAllocation(compiler, length, &slow_path, &done);

__ Bind(&slow_path);

- __ PushObject(Object::null_object(), PP); // Make room for the result.

+ __ PushObject(Object::null_object()); // Make room for the result.

__ pushq(kLengthReg);

__ pushq(kElemTypeReg);

compiler->GenerateRuntimeCall(token_pos(),

@@ -2198,7 +2195,7 @@ void LoadFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) {

Label load_float32x4;

Label load_float64x2;

- __ LoadObject(result, Field::ZoneHandle(field()->raw()), PP);

+ __ LoadObject(result, Field::ZoneHandle(field()->raw()));

__ cmpl(FieldAddress(result, Field::is_nullable_offset()),

Immediate(kNullCid));

@@ -2278,8 +2275,8 @@ void InstantiateTypeInstr::EmitNativeCode(FlowGraphCompiler* compiler) {

// 'instantiator_reg' is the instantiator TypeArguments object (or null).

// A runtime call to instantiate the type is required.

- __ PushObject(Object::null_object(), PP); // Make room for the result.

- __ PushObject(type(), PP);

+ __ PushObject(Object::null_object()); // Make room for the result.

+ __ PushObject(type());

__ pushq(instantiator_reg); // Push instantiator type arguments.

compiler->GenerateRuntimeCall(token_pos(),

deopt_id(),

@@ -2321,14 +2318,14 @@ void InstantiateTypeArgumentsInstr::EmitNativeCode(

Label type_arguments_instantiated;

const intptr_t len = type_arguments().Length();

if (type_arguments().IsRawInstantiatedRaw(len)) {

- __ CompareObject(instantiator_reg, Object::null_object(), PP);

+ __ CompareObject(instantiator_reg, Object::null_object());

__ j(EQUAL, &type_arguments_instantiated, Assembler::kNearJump);

}

// Lookup cache before calling runtime.

// TODO(fschneider): Consider moving this into a shared stub to reduce

// generated code size.

- __ LoadObject(RDI, type_arguments(), PP);

+ __ LoadObject(RDI, type_arguments());

__ movq(RDI, FieldAddress(RDI, TypeArguments::instantiations_offset()));

__ leaq(RDI, FieldAddress(RDI, Array::data_offset()));

// The instantiations cache is initialized with Object::zero_array() and is

@@ -2349,8 +2346,8 @@ void InstantiateTypeArgumentsInstr::EmitNativeCode(

__ Bind(&slow_case);

// Instantiate non-null type arguments.

// A runtime call to instantiate the type arguments is required.

- __ PushObject(Object::null_object(), PP); // Make room for the result.

- __ PushObject(type_arguments(), PP);

+ __ PushObject(Object::null_object()); // Make room for the result.

+ __ PushObject(type_arguments());

__ pushq(instantiator_reg); // Push instantiator type arguments.

compiler->GenerateRuntimeCall(token_pos(),

deopt_id(),

@@ -2393,7 +2390,7 @@ class AllocateContextSlowPath : public SlowPathCode {

compiler->SaveLiveRegisters(locs);

- __ LoadImmediate(R10, Immediate(instruction_->num_context_variables()), PP);

+ __ LoadImmediate(R10, Immediate(instruction_->num_context_variables()));

const ExternalLabel label(StubCode::AllocateContextEntryPoint());

compiler->GenerateCall(instruction_->token_pos(),

&label,

@@ -2448,7 +2445,7 @@ void AllocateContextInstr::EmitNativeCode(FlowGraphCompiler* compiler) {

ASSERT(locs()->temp(0).reg() == R10);

ASSERT(locs()->out(0).reg() == RAX);

- __ LoadImmediate(R10, Immediate(num_context_variables()), PP);

+ __ LoadImmediate(R10, Immediate(num_context_variables()));

const ExternalLabel label(StubCode::AllocateContextEntryPoint());

compiler->GenerateCall(token_pos(),

&label,

@@ -2476,14 +2473,14 @@ void InitStaticFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) {

Label call_runtime, no_call;

__ movq(temp, FieldAddress(field, Field::value_offset()));

- __ CompareObject(temp, Object::sentinel(), PP);

+ __ CompareObject(temp, Object::sentinel());

__ j(EQUAL, &call_runtime);

- __ CompareObject(temp, Object::transition_sentinel(), PP);

+ __ CompareObject(temp, Object::transition_sentinel());

__ j(NOT_EQUAL, &no_call);

__ Bind(&call_runtime);

- __ PushObject(Object::null_object(), PP); // Make room for (unused) result.

+ __ PushObject(Object::null_object()); // Make room for (unused) result.

__ pushq(field);

compiler->GenerateRuntimeCall(token_pos(),

deopt_id(),

@@ -2511,7 +2508,7 @@ void CloneContextInstr::EmitNativeCode(FlowGraphCompiler* compiler) {

- __ PushObject(Object::null_object(), PP); // Make room for the result.

+ __ PushObject(Object::null_object()); // Make room for the result.

__ pushq(context_value);

compiler->GenerateRuntimeCall(token_pos(),

deopt_id(),

@@ -2539,7 +2536,7 @@ void CatchBlockEntryInstr::EmitNativeCode(FlowGraphCompiler* compiler) {

needs_stacktrace());

// Restore the pool pointer.

- __ LoadPoolPointer(PP);

+ __ LoadPoolPointer();

if (HasParallelMove()) {

compiler->parallel_move_resolver()->EmitNativeCode(parallel_move());

@@ -2585,7 +2582,7 @@ class CheckStackOverflowSlowPath : public SlowPathCode {

__ Comment("CheckStackOverflowSlowPathOsr");

__ Bind(osr_entry_label());

- __ LoadImmediate(temp, Immediate(flags_address), PP);

+ __ LoadImmediate(temp, Immediate(flags_address));

__ movq(Address(temp, 0), Immediate(Isolate::kOsrRequest));

}

__ Comment("CheckStackOverflowSlowPath");

@@ -2633,7 +2630,7 @@ void CheckStackOverflowInstr::EmitNativeCode(FlowGraphCompiler* compiler) {

// Generate stack overflow check.

if (compiler->is_optimizing()) {

__ LoadImmediate(

- temp, Immediate(Isolate::Current()->stack_limit_address()), PP);

+ temp, Immediate(Isolate::Current()->stack_limit_address()));

__ cmpq(RSP, Address(temp, 0));

} else {

__ LoadIsolate(temp);

@@ -2644,7 +2641,7 @@ void CheckStackOverflowInstr::EmitNativeCode(FlowGraphCompiler* compiler) {

// 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);

+ __ LoadObject(temp, compiler->parsed_function().function());

int32_t threshold =

FLAG_optimization_counter_threshold * (loop_depth() + 1);

__ cmpl(FieldAddress(temp, Function::usage_counter_offset()),

@@ -2666,9 +2663,9 @@ static void EmitJavascriptOverflowCheck(FlowGraphCompiler* compiler,

ASSERT(overflow != NULL);

// TODO(zra): This can be tightened to one compare/branch using:

// overflow = (result + 2^52) > 2^53 with an unsigned comparison.

- __ CompareImmediate(result, Immediate(-0x20000000000000LL), PP);

+ __ CompareImmediate(result, Immediate(-0x20000000000000LL));

__ j(LESS, overflow);

- __ CompareImmediate(result, Immediate(0x20000000000000LL), PP);

+ __ CompareImmediate(result, Immediate(0x20000000000000LL));

__ j(GREATER, overflow);

}

@@ -2717,7 +2714,7 @@ static void EmitSmiShiftLeft(FlowGraphCompiler* compiler,

if (obj.IsSmi()) {

const intptr_t left_int = Smi::Cast(obj).Value();

if (left_int == 0) {

- __ CompareImmediate(right, Immediate(0), PP);

+ __ CompareImmediate(right, Immediate(0));

__ j(NEGATIVE, deopt);

return;

}

@@ -2726,7 +2723,7 @@ static void EmitSmiShiftLeft(FlowGraphCompiler* compiler,

!RangeUtils::IsWithin(right_range, 0, max_right - 1);

if (right_needs_check) {

__ CompareImmediate(right,

- Immediate(reinterpret_cast<int64_t>(Smi::New(max_right))), PP);

+ Immediate(reinterpret_cast<int64_t>(Smi::New(max_right))));

__ j(ABOVE_EQUAL, deopt);

}

__ SmiUntag(right);

@@ -2747,12 +2744,12 @@ static void EmitSmiShiftLeft(FlowGraphCompiler* compiler,

(right_range == NULL) || !right_range->IsPositive();

if (right_may_be_negative) {

ASSERT(shift_left->CanDeoptimize());

- __ CompareImmediate(right, Immediate(0), PP);

+ __ CompareImmediate(right, Immediate(0));

__ j(NEGATIVE, deopt);

}

Label done, is_not_zero;

__ CompareImmediate(right,

- Immediate(reinterpret_cast<int64_t>(Smi::New(Smi::kBits))), PP);

+ Immediate(reinterpret_cast<int64_t>(Smi::New(Smi::kBits))));

__ j(BELOW, &is_not_zero, Assembler::kNearJump);

__ xorq(left, left);

__ jmp(&done, Assembler::kNearJump);

@@ -2768,7 +2765,7 @@ static void EmitSmiShiftLeft(FlowGraphCompiler* compiler,

if (right_needs_check) {

ASSERT(shift_left->CanDeoptimize());

__ CompareImmediate(right,

- Immediate(reinterpret_cast<int64_t>(Smi::New(Smi::kBits))), PP);

+ Immediate(reinterpret_cast<int64_t>(Smi::New(Smi::kBits))));

__ j(ABOVE_EQUAL, deopt);

}

// Left is not a constant.

@@ -2901,19 +2898,19 @@ void BinarySmiOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {

const int64_t imm = reinterpret_cast<int64_t>(constant.raw());

switch (op_kind()) {

case Token::kADD: {

- __ AddImmediate(left, Immediate(imm), PP);

+ __ AddImmediate(left, Immediate(imm));

if (deopt != NULL) __ j(OVERFLOW, deopt);

break;

}

case Token::kSUB: {

- __ SubImmediate(left, Immediate(imm), PP);

+ __ SubImmediate(left, Immediate(imm));

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();

- __ MulImmediate(left, Immediate(value), PP);

+ __ MulImmediate(left, Immediate(value));

if (deopt != NULL) __ j(OVERFLOW, deopt);

break;

}

@@ -2939,17 +2936,17 @@ void BinarySmiOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {

}

case Token::kBIT_AND: {

// No overflow check.

- __ AndImmediate(left, Immediate(imm), PP);

+ __ AndImmediate(left, Immediate(imm));

break;

}

case Token::kBIT_OR: {

// No overflow check.

- __ OrImmediate(left, Immediate(imm), PP);

+ __ OrImmediate(left, Immediate(imm));

break;

}

case Token::kBIT_XOR: {

// No overflow check.

- __ XorImmediate(left, Immediate(imm), PP);

+ __ XorImmediate(left, Immediate(imm));

break;

}

@@ -3094,7 +3091,7 @@ void BinarySmiOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {

__ 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.

- __ CompareImmediate(result, Immediate(0x4000000000000000), PP);

+ __ CompareImmediate(result, Immediate(0x4000000000000000));

__ j(EQUAL, deopt);

__ Bind(&done);

__ SmiTag(result);

@@ -3174,7 +3171,7 @@ void BinarySmiOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {

}

case Token::kSHR: {

if (CanDeoptimize()) {

- __ CompareImmediate(right, Immediate(0), PP);

+ __ CompareImmediate(right, Immediate(0));

__ j(LESS, deopt);

}

__ SmiUntag(right);

@@ -3182,10 +3179,10 @@ void BinarySmiOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {

const intptr_t kCountLimit = 0x3F;

if ((right_range == NULL) ||

!right_range->OnlyLessThanOrEqualTo(kCountLimit)) {

- __ CompareImmediate(right, Immediate(kCountLimit), PP);

+ __ CompareImmediate(right, Immediate(kCountLimit));

Label count_ok;

__ j(LESS, &count_ok, Assembler::kNearJump);

- __ LoadImmediate(right, Immediate(kCountLimit), PP);

+ __ LoadImmediate(right, Immediate(kCountLimit));

__ Bind(&count_ok);

}

ASSERT(right == RCX); // Count must be in RCX

@@ -3735,7 +3732,7 @@ void Float32x4ConstructorInstr::EmitNativeCode(FlowGraphCompiler* compiler) {

XmmRegister v2 = locs()->in(2).fpu_reg();

XmmRegister v3 = locs()->in(3).fpu_reg();

ASSERT(v0 == locs()->out(0).fpu_reg());

- __ AddImmediate(RSP, Immediate(-16), PP);

+ __ AddImmediate(RSP, Immediate(-16));

__ cvtsd2ss(v0, v0);

__ movss(Address(RSP, 0), v0);

__ movsd(v0, v1);

@@ -3748,7 +3745,7 @@ void Float32x4ConstructorInstr::EmitNativeCode(FlowGraphCompiler* compiler) {

__ cvtsd2ss(v0, v0);

__ movss(Address(RSP, 12), v0);

__ movups(v0, Address(RSP, 0));

- __ AddImmediate(RSP, Immediate(16), PP);

+ __ AddImmediate(RSP, Immediate(16));

}

@@ -4002,47 +3999,47 @@ void Float32x4WithInstr::EmitNativeCode(FlowGraphCompiler* compiler) {

switch (op_kind()) {

case MethodRecognizer::kFloat32x4WithX:

__ cvtsd2ss(replacement, replacement);

- __ AddImmediate(RSP, Immediate(-16), PP);

+ __ AddImmediate(RSP, Immediate(-16));

// 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));

- __ AddImmediate(RSP, Immediate(16), PP);

+ __ AddImmediate(RSP, Immediate(16));

break;

case MethodRecognizer::kFloat32x4WithY:

__ cvtsd2ss(replacement, replacement);

- __ AddImmediate(RSP, Immediate(-16), PP);

+ __ AddImmediate(RSP, Immediate(-16));

// 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));

- __ AddImmediate(RSP, Immediate(16), PP);

+ __ AddImmediate(RSP, Immediate(16));

break;

case MethodRecognizer::kFloat32x4WithZ:

__ cvtsd2ss(replacement, replacement);

- __ AddImmediate(RSP, Immediate(-16), PP);

+ __ AddImmediate(RSP, Immediate(-16));

// 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));

- __ AddImmediate(RSP, Immediate(16), PP);

+ __ AddImmediate(RSP, Immediate(16));

break;

case MethodRecognizer::kFloat32x4WithW:

__ cvtsd2ss(replacement, replacement);

- __ AddImmediate(RSP, Immediate(-16), PP);

+ __ AddImmediate(RSP, Immediate(-16));

// 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));

- __ AddImmediate(RSP, Immediate(16), PP);

+ __ AddImmediate(RSP, Immediate(16));

break;

default: UNREACHABLE();

}

@@ -4307,13 +4304,13 @@ void Int32x4ConstructorInstr::EmitNativeCode(FlowGraphCompiler* compiler) {

XmmRegister result = locs()->out(0).fpu_reg();

- __ AddImmediate(RSP, Immediate(-4 * kInt32Size), PP);

+ __ AddImmediate(RSP, Immediate(-4 * kInt32Size));

__ movl(Address(RSP, 0 * kInt32Size), v0);

__ movl(Address(RSP, 1 * kInt32Size), v1);

__ movl(Address(RSP, 2 * kInt32Size), v2);

__ movl(Address(RSP, 3 * kInt32Size), v3);

__ movups(result, Address(RSP, 0));

- __ AddImmediate(RSP, Immediate(4 * kInt32Size), PP);

+ __ AddImmediate(RSP, Immediate(4 * kInt32Size));

}

@@ -4344,46 +4341,46 @@ void Int32x4BoolConstructorInstr::EmitNativeCode(FlowGraphCompiler* compiler) {

Label y_false, y_done;

Label z_false, z_done;

Label w_false, w_done;

- __ AddImmediate(RSP, Immediate(-16), PP);

+ __ AddImmediate(RSP, Immediate(-16));

- __ CompareObject(v0, Bool::True(), PP);

+ __ CompareObject(v0, Bool::True());

__ j(NOT_EQUAL, &x_false);

- __ LoadImmediate(temp, Immediate(0xFFFFFFFF), PP);

+ __ LoadImmediate(temp, Immediate(0xFFFFFFFF));

__ jmp(&x_done);

__ Bind(&x_false);

- __ LoadImmediate(temp, Immediate(0x0), PP);

+ __ LoadImmediate(temp, Immediate(0x0));

__ Bind(&x_done);

__ movl(Address(RSP, 0), temp);

- __ CompareObject(v1, Bool::True(), PP);

+ __ CompareObject(v1, Bool::True());

__ j(NOT_EQUAL, &y_false);

- __ LoadImmediate(temp, Immediate(0xFFFFFFFF), PP);

+ __ LoadImmediate(temp, Immediate(0xFFFFFFFF));

__ jmp(&y_done);

__ Bind(&y_false);

- __ LoadImmediate(temp, Immediate(0x0), PP);

+ __ LoadImmediate(temp, Immediate(0x0));

__ Bind(&y_done);

__ movl(Address(RSP, 4), temp);

- __ CompareObject(v2, Bool::True(), PP);

+ __ CompareObject(v2, Bool::True());

__ j(NOT_EQUAL, &z_false);

- __ LoadImmediate(temp, Immediate(0xFFFFFFFF), PP);

+ __ LoadImmediate(temp, Immediate(0xFFFFFFFF));

__ jmp(&z_done);

__ Bind(&z_false);

- __ LoadImmediate(temp, Immediate(0x0), PP);

+ __ LoadImmediate(temp, Immediate(0x0));

__ Bind(&z_done);

__ movl(Address(RSP, 8), temp);

- __ CompareObject(v3, Bool::True(), PP);

+ __ CompareObject(v3, Bool::True());

__ j(NOT_EQUAL, &w_false);

- __ LoadImmediate(temp, Immediate(0xFFFFFFFF), PP);

+ __ LoadImmediate(temp, Immediate(0xFFFFFFFF));

__ jmp(&w_done);

__ Bind(&w_false);

- __ LoadImmediate(temp, Immediate(0x0), PP);

+ __ LoadImmediate(temp, Immediate(0x0));

__ Bind(&w_done);

__ movl(Address(RSP, 12), temp);

__ movups(result, Address(RSP, 0));

- __ AddImmediate(RSP, Immediate(16), PP);

+ __ AddImmediate(RSP, Immediate(16));

}

@@ -4404,7 +4401,7 @@ void Int32x4GetFlagInstr::EmitNativeCode(FlowGraphCompiler* compiler) {

Label done;

Label non_zero;

- __ AddImmediate(RSP, Immediate(-16), PP);

+ __ AddImmediate(RSP, Immediate(-16));

// Move value to stack.

__ movups(Address(RSP, 0), value);

switch (op_kind()) {

@@ -4422,13 +4419,13 @@ void Int32x4GetFlagInstr::EmitNativeCode(FlowGraphCompiler* compiler) {

break;

default: UNREACHABLE();

}

- __ AddImmediate(RSP, Immediate(16), PP);

+ __ AddImmediate(RSP, Immediate(16));

__ testl(result, result);

__ j(NOT_ZERO, &non_zero, Assembler::kNearJump);

- __ LoadObject(result, Bool::False(), PP);

+ __ LoadObject(result, Bool::False());

__ jmp(&done);

__ Bind(&non_zero);

- __ LoadObject(result, Bool::True(), PP);

+ __ LoadObject(result, Bool::True());

__ Bind(&done);

}

@@ -4487,43 +4484,43 @@ void Int32x4SetFlagInstr::EmitNativeCode(FlowGraphCompiler* compiler) {

ASSERT(mask == locs()->out(0).fpu_reg());

- __ AddImmediate(RSP, Immediate(-16), PP);

+ __ AddImmediate(RSP, Immediate(-16));

// Copy mask to stack.

__ movups(Address(RSP, 0), mask);

Label falsePath, exitPath;

- __ CompareObject(flag, Bool::True(), PP);

+ __ CompareObject(flag, Bool::True());

__ j(NOT_EQUAL, &falsePath);

switch (op_kind()) {

case MethodRecognizer::kInt32x4WithFlagX:

- __ LoadImmediate(temp, Immediate(0xFFFFFFFF), PP);

+ __ LoadImmediate(temp, Immediate(0xFFFFFFFF));

__ movl(Address(RSP, 0), temp);

__ jmp(&exitPath);

__ Bind(&falsePath);

- __ LoadImmediate(temp, Immediate(0x0), PP);

+ __ LoadImmediate(temp, Immediate(0x0));

__ movl(Address(RSP, 0), temp);

break;

case MethodRecognizer::kInt32x4WithFlagY:

- __ LoadImmediate(temp, Immediate(0xFFFFFFFF), PP);

+ __ LoadImmediate(temp, Immediate(0xFFFFFFFF));

__ movl(Address(RSP, 4), temp);

__ jmp(&exitPath);

__ Bind(&falsePath);

- __ LoadImmediate(temp, Immediate(0x0), PP);

+ __ LoadImmediate(temp, Immediate(0x0));

__ movl(Address(RSP, 4), temp);

break;

case MethodRecognizer::kInt32x4WithFlagZ:

- __ LoadImmediate(temp, Immediate(0xFFFFFFFF), PP);

+ __ LoadImmediate(temp, Immediate(0xFFFFFFFF));

__ movl(Address(RSP, 8), temp);

__ jmp(&exitPath);

__ Bind(&falsePath);

- __ LoadImmediate(temp, Immediate(0x0), PP);

+ __ LoadImmediate(temp, Immediate(0x0));

__ movl(Address(RSP, 8), temp);

break;

case MethodRecognizer::kInt32x4WithFlagW:

- __ LoadImmediate(temp, Immediate(0xFFFFFFFF), PP);

+ __ LoadImmediate(temp, Immediate(0xFFFFFFFF));

__ movl(Address(RSP, 12), temp);

__ jmp(&exitPath);

__ Bind(&falsePath);

- __ LoadImmediate(temp, Immediate(0x0), PP);

+ __ LoadImmediate(temp, Immediate(0x0));

__ movl(Address(RSP, 12), temp);

break;

default: UNREACHABLE();

@@ -4531,7 +4528,7 @@ void Int32x4SetFlagInstr::EmitNativeCode(FlowGraphCompiler* compiler) {

__ Bind(&exitPath);

// Copy mask back to register.

__ movups(mask, Address(RSP, 0));

- __ AddImmediate(RSP, Immediate(16), PP);

+ __ AddImmediate(RSP, Immediate(16));

}

@@ -4706,7 +4703,7 @@ void UnarySmiOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {

case Token::kBIT_NOT:

__ notq(value);

// Remove inverted smi-tag.

- __ AndImmediate(value, Immediate(~kSmiTagMask), PP);

+ __ AndImmediate(value, Immediate(~kSmiTagMask));

break;

default:

UNREACHABLE();

@@ -4783,7 +4780,7 @@ void MathMinMaxInstr::EmitNativeCode(FlowGraphCompiler* compiler) {

__ Bind(&returns_nan);

static double kNaN = NAN;

- __ LoadImmediate(temp, Immediate(reinterpret_cast<intptr_t>(&kNaN)), PP);

+ __ LoadImmediate(temp, Immediate(reinterpret_cast<intptr_t>(&kNaN)));

__ movsd(result, Address(temp, 0));

__ jmp(&done, Assembler::kNearJump);

@@ -5084,7 +5081,7 @@ static void InvokeDoublePow(FlowGraphCompiler* compiler,

locs->temp(InvokeMathCFunctionInstr::kDoubleTempIndex).fpu_reg();

__ xorps(zero_temp, zero_temp);

- __ LoadObject(temp, Double::ZoneHandle(Double::NewCanonical(1)), PP);

+ __ LoadObject(temp, Double::ZoneHandle(Double::NewCanonical(1)));

__ movsd(result, FieldAddress(temp, Double::value_offset()));

Label check_base, skip_call;

@@ -5099,14 +5096,14 @@ static void InvokeDoublePow(FlowGraphCompiler* compiler,

__ j(EQUAL, &return_base, Assembler::kNearJump);

// exponent == 2.0 ?

- __ LoadObject(temp, Double::ZoneHandle(Double::NewCanonical(2.0)), PP);

+ __ LoadObject(temp, Double::ZoneHandle(Double::NewCanonical(2.0)));

__ movsd(XMM0, FieldAddress(temp, Double::value_offset()));

__ comisd(exp, XMM0);

Label return_base_times_2;

__ j(EQUAL, &return_base_times_2, Assembler::kNearJump);

// exponent == 3.0 ?

- __ LoadObject(temp, Double::ZoneHandle(Double::NewCanonical(3.0)), PP);

+ __ LoadObject(temp, Double::ZoneHandle(Double::NewCanonical(3.0)));

__ movsd(XMM0, FieldAddress(temp, Double::value_offset()));

__ comisd(exp, XMM0);

__ j(NOT_EQUAL, &check_base);

@@ -5141,7 +5138,7 @@ static void InvokeDoublePow(FlowGraphCompiler* compiler,

__ j(PARITY_ODD, &try_sqrt, Assembler::kNearJump);

// Return NaN.

__ Bind(&return_nan);

- __ LoadObject(temp, Double::ZoneHandle(Double::NewCanonical(NAN)), PP);

+ __ LoadObject(temp, Double::ZoneHandle(Double::NewCanonical(NAN)));

__ movsd(result, FieldAddress(temp, Double::value_offset()));

__ jmp(&skip_call);

@@ -5149,14 +5146,14 @@ static void InvokeDoublePow(FlowGraphCompiler* compiler,

__ Bind(&try_sqrt);

// Before calling pow, check if we could use sqrt instead of pow.

__ LoadObject(temp,

- Double::ZoneHandle(Double::NewCanonical(kNegInfinity)), PP);

+ Double::ZoneHandle(Double::NewCanonical(kNegInfinity)));

__ movsd(result, FieldAddress(temp, Double::value_offset()));

// base == -Infinity -> call pow;

__ comisd(base, result);

__ j(EQUAL, &do_pow, Assembler::kNearJump);

// exponent == 0.5 ?

- __ LoadObject(temp, Double::ZoneHandle(Double::NewCanonical(0.5)), PP);

+ __ LoadObject(temp, Double::ZoneHandle(Double::NewCanonical(0.5)));

__ movsd(result, FieldAddress(temp, Double::value_offset()));

__ comisd(exp, result);

__ j(NOT_EQUAL, &do_pow, Assembler::kNearJump);

@@ -5353,7 +5350,7 @@ void MergedMathInstr::EmitNativeCode(FlowGraphCompiler* compiler) {

__ 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.

- __ CompareImmediate(RAX, Immediate(0x4000000000000000), PP);

+ __ CompareImmediate(RAX, Immediate(0x4000000000000000));

__ j(EQUAL, deopt);

__ Bind(&done);

@@ -5477,7 +5474,7 @@ void CheckClassInstr::EmitNativeCode(FlowGraphCompiler* compiler) {

licm_hoisted_ ? ICData::kHoisted : 0);

if (IsNullCheck()) {

__ CompareObject(locs()->in(0).reg(),

- Object::null_object(), PP);

+ Object::null_object());

Condition cond = DeoptIfNull() ? EQUAL : NOT_EQUAL;

__ j(cond, deopt);

return;

@@ -5572,7 +5569,7 @@ LocationSummary* CheckClassIdInstr::MakeLocationSummary(Zone* zone,

void CheckClassIdInstr::EmitNativeCode(FlowGraphCompiler* compiler) {

Label* deopt = compiler->AddDeoptStub(deopt_id(), ICData::kDeoptCheckClass);

- __ CompareImmediate(value, Immediate(Smi::RawValue(cid_)), PP);

+ __ CompareImmediate(value, Immediate(Smi::RawValue(cid_)));

__ j(NOT_ZERO, deopt);

}

@@ -5614,7 +5611,7 @@ void CheckArrayBoundInstr::EmitNativeCode(FlowGraphCompiler* compiler) {

const Smi& index = Smi::Cast(index_loc.constant());

__ CompareImmediate(

- length, Immediate(reinterpret_cast<int64_t>(index.raw())), PP);

+ length, Immediate(reinterpret_cast<int64_t>(index.raw())));

__ j(BELOW_EQUAL, deopt);

} else if (length_loc.IsConstant()) {

const Smi& length = Smi::Cast(length_loc.constant());

@@ -5624,7 +5621,7 @@ void CheckArrayBoundInstr::EmitNativeCode(FlowGraphCompiler* compiler) {

__ j(NEGATIVE, deopt);

} else {

__ CompareImmediate(

- index, Immediate(reinterpret_cast<int64_t>(length.raw())), PP);

+ index, Immediate(reinterpret_cast<int64_t>(length.raw())));

__ j(ABOVE_EQUAL, deopt);

}

} else {

@@ -6281,10 +6278,10 @@ void StrictCompareInstr::EmitNativeCode(FlowGraphCompiler* compiler) {

Label done;

__ Bind(&is_false);

- __ LoadObject(result, Bool::False(), PP);

+ __ LoadObject(result, Bool::False());

__ jmp(&done);

__ Bind(&is_true);

- __ LoadObject(result, Bool::True(), PP);

+ __ LoadObject(result, Bool::True());

__ Bind(&done);

}

@@ -6317,7 +6314,7 @@ void ClosureCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) {

const Array& arguments_descriptor =

Array::ZoneHandle(ArgumentsDescriptor::New(argument_count,

argument_names()));

- __ LoadObject(R10, arguments_descriptor, PP);

+ __ LoadObject(R10, arguments_descriptor);

// Function in RAX.

ASSERT(locs()->in(0).reg() == RAX);

@@ -6360,10 +6357,10 @@ void BooleanNegateInstr::EmitNativeCode(FlowGraphCompiler* compiler) {

Label done;

- __ LoadObject(result, Bool::True(), PP);

+ __ LoadObject(result, Bool::True());

__ CompareRegisters(result, value);

__ j(NOT_EQUAL, &done, Assembler::kNearJump);

- __ LoadObject(result, Bool::False(), PP);

+ __ LoadObject(result, Bool::False());

__ Bind(&done);

}

@@ -6412,7 +6409,7 @@ LocationSummary* GrowRegExpStackInstr::MakeLocationSummary(

void GrowRegExpStackInstr::EmitNativeCode(FlowGraphCompiler* compiler) {

const Register typed_data = locs()->in(0).reg();

const Register result = locs()->out(0).reg();

- __ PushObject(Object::null_object(), PP);

+ __ PushObject(Object::null_object());

__ pushq(typed_data);

compiler->GenerateRuntimeCall(Scanner::kNoSourcePos, // No token position.

deopt_id(),

« no previous file with comments | « runtime/vm/instructions_x64_test.cc ('k') | runtime/vm/intrinsifier_x64.cc » ('j') | no next file with comments »