{
FrameScope scope(masm, StackFrame::MANUAL);
__ Push(x0, x1, fp, lr);
- __ Mov(x1, Operand(ExternalReference::isolate_address(masm->isolate())));
+ __ Mov(x1, ExternalReference::isolate_address(masm->isolate()));
__ CallCFunction(
ExternalReference::get_make_code_young_function(masm->isolate()), 2);
__ Pop(lr, fp, x1, x0);
{
FrameScope scope(masm, StackFrame::MANUAL);
__ Push(x0, x1, fp, lr);
- __ Mov(x1, Operand(ExternalReference::isolate_address(masm->isolate())));
+ __ Mov(x1, ExternalReference::isolate_address(masm->isolate()));
__ CallCFunction(
ExternalReference::get_mark_code_as_executed_function(
masm->isolate()), 2);
{
FrameScope scope(masm, StackFrame::INTERNAL);
// Pass the deoptimization type to the runtime system.
- __ Mov(x0, Operand(Smi::FromInt(static_cast<int>(type))));
+ __ Mov(x0, Smi::FromInt(static_cast<int>(type)));
__ Push(x0);
__ CallRuntime(Runtime::kNotifyDeoptimized, 1);
}
// If the code object is null, just return to the unoptimized code.
Label skip;
- __ CompareAndBranch(x0, Operand(Smi::FromInt(0)), ne, &skip);
+ __ CompareAndBranch(x0, Smi::FromInt(0), ne, &skip);
__ Ret();
__ Bind(&skip);
// Use inline caching to access the arguments.
__ Ldr(current, MemOperand(fp, kIndexOffset));
- __ Add(current, current, Operand(Smi::FromInt(1)));
+ __ Add(current, current, Smi::FromInt(1));
__ Str(current, MemOperand(fp, kIndexOffset));
// Test if the copy loop has finished copying all the elements from the
static void EnterArgumentsAdaptorFrame(MacroAssembler* masm) {
__ SmiTag(x10, x0);
- __ Mov(x11, Operand(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
+ __ Mov(x11, Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR));
__ Push(lr, fp);
__ Push(x11, x1, x10);
__ Add(fp, jssp,
ASSERT((cond == gt) || (cond == ge)); // remaining cases
ncr = LESS;
}
- __ Mov(x10, Operand(Smi::FromInt(ncr)));
+ __ Mov(x10, Smi::FromInt(ncr));
__ Push(x10);
}
}
AllowExternalCallThatCantCauseGC scope(masm);
- __ Mov(x0, Operand(ExternalReference::isolate_address(masm->isolate())));
+ __ Mov(x0, ExternalReference::isolate_address(masm->isolate()));
__ CallCFunction(
ExternalReference::store_buffer_overflow_function(masm->isolate()),
1, 0);
if (do_gc) {
// Call Runtime::PerformGC, passing x0 (the result parameter for
// PerformGC) and x1 (the isolate).
- __ Mov(x1, Operand(ExternalReference::isolate_address(masm->isolate())));
+ __ Mov(x1, ExternalReference::isolate_address(masm->isolate()));
__ CallCFunction(
ExternalReference::perform_gc_function(isolate), 2, 0);
}
// Prepare AAPCS64 arguments to pass to the builtin.
__ Mov(x0, argc);
__ Mov(x1, argv);
- __ Mov(x2, Operand(ExternalReference::isolate_address(isolate)));
+ __ Mov(x2, ExternalReference::isolate_address(isolate));
// Store the return address on the stack, in the space previously allocated
// by EnterExitFrame. The return address is queried by
int marker = is_construct ? StackFrame::ENTRY_CONSTRUCT : StackFrame::ENTRY;
int64_t bad_frame_pointer = -1L; // Bad frame pointer to fail if it is used.
__ Mov(x13, bad_frame_pointer);
- __ Mov(x12, Operand(Smi::FromInt(marker)));
- __ Mov(x11, Operand(ExternalReference(Isolate::kCEntryFPAddress, isolate)));
+ __ Mov(x12, Smi::FromInt(marker));
+ __ Mov(x11, ExternalReference(Isolate::kCEntryFPAddress, isolate));
__ Ldr(x10, MemOperand(x11));
__ Push(x13, xzr, x12, x10);
// outermost JS call.
Label non_outermost_js, done;
ExternalReference js_entry_sp(Isolate::kJSEntrySPAddress, isolate);
- __ Mov(x10, Operand(ExternalReference(js_entry_sp)));
+ __ Mov(x10, ExternalReference(js_entry_sp));
__ Ldr(x11, MemOperand(x10));
__ Cbnz(x11, &non_outermost_js);
__ Str(fp, MemOperand(x10));
- __ Mov(x12, Operand(Smi::FromInt(StackFrame::OUTERMOST_JSENTRY_FRAME)));
+ __ Mov(x12, Smi::FromInt(StackFrame::OUTERMOST_JSENTRY_FRAME));
__ Push(x12);
__ B(&done);
__ Bind(&non_outermost_js);
ExternalReference entry(is_construct ? Builtins::kJSConstructEntryTrampoline
: Builtins::kJSEntryTrampoline,
isolate);
- __ Mov(x10, Operand(entry));
+ __ Mov(x10, entry);
// Call the JSEntryTrampoline.
__ Ldr(x11, MemOperand(x10)); // Dereference the address.
// Check if the current stack frame is marked as the outermost JS frame.
Label non_outermost_js_2;
__ Pop(x10);
- __ Cmp(x10, Operand(Smi::FromInt(StackFrame::OUTERMOST_JSENTRY_FRAME)));
+ __ Cmp(x10, Smi::FromInt(StackFrame::OUTERMOST_JSENTRY_FRAME));
__ B(ne, &non_outermost_js_2);
- __ Mov(x11, Operand(ExternalReference(js_entry_sp)));
+ __ Mov(x11, ExternalReference(js_entry_sp));
__ Str(xzr, MemOperand(x11));
__ Bind(&non_outermost_js_2);
// Restore the top frame descriptors from the stack.
__ Pop(x10);
- __ Mov(x11, Operand(ExternalReference(Isolate::kCEntryFPAddress, isolate)));
+ __ Mov(x11, ExternalReference(Isolate::kCEntryFPAddress, isolate));
__ Str(x10, MemOperand(x11));
// Reset the stack to the callee saved registers.
__ LoadTrueFalseRoots(res_true, res_false);
} else {
// This is counter-intuitive, but correct.
- __ Mov(res_true, Operand(Smi::FromInt(0)));
- __ Mov(res_false, Operand(Smi::FromInt(1)));
+ __ Mov(res_true, Smi::FromInt(0));
+ __ Mov(res_false, Smi::FromInt(1));
}
// Check that the left hand side is a JS object and load its map as a side
__ Ldr(caller_fp, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
__ Ldr(caller_ctx, MemOperand(caller_fp,
StandardFrameConstants::kContextOffset));
- __ Cmp(caller_ctx, Operand(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
+ __ Cmp(caller_ctx, Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR));
__ Csel(local_fp, fp, caller_fp, ne);
__ B(ne, &skip_adaptor);
ArgumentsAdaptorFrameConstants::kLengthOffset));
__ Poke(x11, 0 * kXRegSize);
__ Add(x10, caller_fp, Operand::UntagSmiAndScale(x11, kPointerSizeLog2));
- __ Add(x10, x10, Operand(StandardFrameConstants::kCallerSPOffset));
+ __ Add(x10, x10, StandardFrameConstants::kCallerSPOffset);
__ Poke(x10, 1 * kXRegSize);
__ Bind(&runtime);
__ Ldr(caller_fp, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
__ Ldr(caller_ctx, MemOperand(caller_fp,
StandardFrameConstants::kContextOffset));
- __ Cmp(caller_ctx, Operand(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
+ __ Cmp(caller_ctx, Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR));
__ B(eq, &adaptor_frame);
// No adaptor, parameter count = argument count.
__ Str(index, MemOperand(elements, x10));
__ Sub(x10, x10, kParameterMapHeaderSize - FixedArray::kHeaderSize);
__ Str(the_hole, MemOperand(backing_store, x10));
- __ Add(index, index, Operand(Smi::FromInt(1)));
+ __ Add(index, index, Smi::FromInt(1));
__ Bind(¶meters_test);
__ Cbnz(loop_count, ¶meters_loop);
__ Ldr(caller_fp, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
__ Ldr(caller_ctx, MemOperand(caller_fp,
StandardFrameConstants::kContextOffset));
- __ Cmp(caller_ctx, Operand(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
+ __ Cmp(caller_ctx, Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR));
__ B(ne, &try_allocate);
// x1 param_count_smi number of parameters passed to function (smi)
ExternalReference::address_of_regexp_stack_memory_address(isolate);
ExternalReference address_of_regexp_stack_memory_size =
ExternalReference::address_of_regexp_stack_memory_size(isolate);
- __ Mov(x10, Operand(address_of_regexp_stack_memory_size));
+ __ Mov(x10, address_of_regexp_stack_memory_size);
__ Ldr(x10, MemOperand(x10));
__ Cbz(x10, &runtime);
// Check the type of the RegExp. Only continue if type is JSRegExp::IRREGEXP.
__ Ldr(x10, FieldMemOperand(regexp_data, JSRegExp::kDataTagOffset));
- __ Cmp(x10, Operand(Smi::FromInt(JSRegExp::IRREGEXP)));
+ __ Cmp(x10, Smi::FromInt(JSRegExp::IRREGEXP));
__ B(ne, &runtime);
// Check that the number of captures fit in the static offsets vector buffer.
// csp[0]: Space for the return address placed by DirectCEntryStub.
// csp[8]: Argument 9, the current isolate address.
- __ Mov(x10, Operand(ExternalReference::isolate_address(isolate)));
+ __ Mov(x10, ExternalReference::isolate_address(isolate));
__ Poke(x10, kPointerSize);
Register length = w11;
__ Add(x3, x2, Operand(w10, UXTW));
// Argument 5 (x4): static offsets vector buffer.
- __ Mov(x4,
- Operand(ExternalReference::address_of_static_offsets_vector(isolate)));
+ __ Mov(x4, ExternalReference::address_of_static_offsets_vector(isolate));
// Argument 6 (x5): Set the number of capture registers to zero to force
// global regexps to behave as non-global. This stub is not used for global
__ Mov(x5, 0);
// Argument 7 (x6): Start (high end) of backtracking stack memory area.
- __ Mov(x10, Operand(address_of_regexp_stack_memory_address));
+ __ Mov(x10, address_of_regexp_stack_memory_address);
__ Ldr(x10, MemOperand(x10));
- __ Mov(x11, Operand(address_of_regexp_stack_memory_size));
+ __ Mov(x11, address_of_regexp_stack_memory_size);
__ Ldr(x11, MemOperand(x11));
__ Add(x6, x10, x11);
// and fill the last match info.
ExternalReference address_of_static_offsets_vector =
ExternalReference::address_of_static_offsets_vector(isolate);
- __ Mov(offsets_vector_index, Operand(address_of_static_offsets_vector));
+ __ Mov(offsets_vector_index, address_of_static_offsets_vector);
Label next_capture, done;
// Capture register counter starts from number of capture registers and
void StringCharFromCodeGenerator::GenerateFast(MacroAssembler* masm) {
__ JumpIfNotSmi(code_, &slow_case_);
- __ Cmp(code_, Operand(Smi::FromInt(String::kMaxOneByteCharCode)));
+ __ Cmp(code_, Smi::FromInt(String::kMaxOneByteCharCode));
__ B(hi, &slow_case_);
__ LoadRoot(result_, Heap::kSingleCharacterStringCacheRootIndex);
// Preserve some caller-saved registers.
__ Push(x1, x0, lr);
// Push the arguments.
- __ Mov(op, Operand(Smi::FromInt(op_)));
+ __ Mov(op, Smi::FromInt(op_));
__ Push(left, right, op);
// Call the miss handler. This also pops the arguments.
__ B(eq, &check_zero_length);
__ Bind(&strings_not_equal);
- __ Mov(result, Operand(Smi::FromInt(NOT_EQUAL)));
+ __ Mov(result, Smi::FromInt(NOT_EQUAL));
__ Ret();
// Check if the length is zero. If so, the strings must be equal (and empty.)
__ Bind(&check_zero_length);
STATIC_ASSERT(kSmiTag == 0);
__ Cbnz(left_length, &compare_chars);
- __ Mov(result, Operand(Smi::FromInt(EQUAL)));
+ __ Mov(result, Smi::FromInt(EQUAL));
__ Ret();
// Compare characters. Falls through if all characters are equal.
scratch3, &strings_not_equal);
// Characters in strings are equal.
- __ Mov(result, Operand(Smi::FromInt(EQUAL)));
+ __ Mov(result, Smi::FromInt(EQUAL));
__ Ret();
}
__ Bind(&result_not_equal);
Register greater = x10;
Register less = x11;
- __ Mov(greater, Operand(Smi::FromInt(GREATER)));
- __ Mov(less, Operand(Smi::FromInt(LESS)));
+ __ Mov(greater, Smi::FromInt(GREATER));
+ __ Mov(less, Smi::FromInt(LESS));
__ CmovX(result, greater, gt);
__ CmovX(result, less, lt);
__ Ret();
// Get the array's length and calculate new length.
__ Ldr(length, FieldMemOperand(receiver, JSArray::kLengthOffset));
STATIC_ASSERT(kSmiTag == 0);
- __ Add(length, length, Operand(Smi::FromInt(argc)));
+ __ Add(length, length, Smi::FromInt(argc));
// Check if we could survive without allocation.
__ Ldr(elements_length,
__ Add(end_elements, elements,
Operand::UntagSmiAndScale(length, kPointerSizeLog2));
__ Add(end_elements, end_elements, kEndElementsOffset);
- __ Mov(allocation_top_addr, Operand(new_space_allocation_top));
+ __ Mov(allocation_top_addr, new_space_allocation_top);
__ Ldr(allocation_top, MemOperand(allocation_top_addr));
__ Cmp(end_elements, allocation_top);
__ B(ne, &call_builtin);
- __ Mov(x10, Operand(new_space_allocation_limit));
+ __ Mov(x10, new_space_allocation_limit);
__ Ldr(x10, MemOperand(x10));
__ Add(allocation_top, allocation_top, kAllocationDelta * kPointerSize);
__ Cmp(allocation_top, x10);
// Update elements' and array's sizes.
__ Str(length, FieldMemOperand(receiver, JSArray::kLengthOffset));
- __ Add(elements_length,
- elements_length,
- Operand(Smi::FromInt(kAllocationDelta)));
+ __ Add(elements_length, elements_length, Smi::FromInt(kAllocationDelta));
__ Str(elements_length,
FieldMemOperand(elements, FixedArray::kLengthOffset));
__ Mov(address, regs_.address());
__ Mov(x0, regs_.object());
__ Mov(x1, address);
- __ Mov(x2, Operand(ExternalReference::isolate_address(masm->isolate())));
+ __ Mov(x2, ExternalReference::isolate_address(masm->isolate()));
AllowExternalCallThatCantCauseGC scope(masm);
ExternalReference function =
ExternalReference::BUILTIN_CALL,
masm->isolate())));
// It additionally takes an isolate as a third parameter
- __ Mov(x2, Operand(ExternalReference::isolate_address(masm->isolate())));
+ __ Mov(x2, ExternalReference::isolate_address(masm->isolate()));
#endif
// The caller's return address is above the saved temporaries.
STATIC_ASSERT(AllocationSite::ElementsKindBits::kShift == 0);
__ Ldr(x11, FieldMemOperand(allocation_site,
AllocationSite::kTransitionInfoOffset));
- __ Add(x11, x11, Operand(Smi::FromInt(kFastElementsKindPackedToHoley)));
+ __ Add(x11, x11, Smi::FromInt(kFastElementsKindPackedToHoley));
__ Str(x11, FieldMemOperand(allocation_site,
AllocationSite::kTransitionInfoOffset));
__ LoadRoot(call_data, Heap::kUndefinedValueRootIndex);
}
Register isolate_reg = x5;
- __ Mov(isolate_reg, Operand(ExternalReference::isolate_address(isolate)));
+ __ Mov(isolate_reg, ExternalReference::isolate_address(isolate));
// FunctionCallbackArguments:
// return value, return value default, isolate, holder.
// ExternalReference::InitializeMathExpData().
// Load the address of the start of the array.
- __ Mov(constants, Operand(ExternalReference::math_exp_constants(0)));
+ __ Mov(constants, ExternalReference::math_exp_constants(0));
// We have to do a four-way split here:
// - If input <= about -708.4, the output always rounds to zero.
__ Add(temp1, temp1, 0x3ff);
// Do the final table lookup.
- __ Mov(temp3, Operand(ExternalReference::math_exp_log_table()));
+ __ Mov(temp3, ExternalReference::math_exp_log_table());
__ Add(temp3, temp3, Operand(temp2, LSL, kDRegSizeLog2));
__ Ldp(temp2.W(), temp3.W(), MemOperand(temp3));
__ RecordComment("// Calling from debug break to runtime - come in - over");
#endif
__ Mov(x0, 0); // No arguments.
- __ Mov(x1, Operand(ExternalReference::debug_break(masm->isolate())));
+ __ Mov(x1, ExternalReference::debug_break(masm->isolate()));
CEntryStub stub(1);
__ CallStub(&stub);
// overwritten by the address of DebugBreakXXX.
ExternalReference after_break_target(Debug_Address::AfterBreakTarget(),
masm->isolate());
- __ Mov(scratch, Operand(after_break_target));
+ __ Mov(scratch, after_break_target);
__ Ldr(scratch, MemOperand(scratch));
__ Br(scratch);
}
// - x2: bailout id
// - x3: code object address
// - x4: fp-to-sp delta
- __ Mov(x5, Operand(ExternalReference::isolate_address(isolate())));
+ __ Mov(x5, ExternalReference::isolate_address(isolate()));
{
// Call Deoptimizer::New().
int num_parameters = info->scope()->num_parameters();
int offset = num_parameters * kPointerSize;
__ Add(x2, fp, StandardFrameConstants::kCallerSPOffset + offset);
- __ Mov(x1, Operand(Smi::FromInt(num_parameters)));
+ __ Mov(x1, Smi::FromInt(num_parameters));
__ Push(x3, x2, x1);
// Arguments to ArgumentsAccessStub:
void FullCodeGenerator::ClearAccumulator() {
- __ Mov(x0, Operand(Smi::FromInt(0)));
+ __ Mov(x0, Smi::FromInt(0));
}
void FullCodeGenerator::EmitProfilingCounterDecrement(int delta) {
__ Mov(x2, Operand(profiling_counter_));
__ Ldr(x3, FieldMemOperand(x2, Cell::kValueOffset));
- __ Subs(x3, x3, Operand(Smi::FromInt(delta)));
+ __ Subs(x3, x3, Smi::FromInt(delta));
__ Str(x3, FieldMemOperand(x2, Cell::kValueOffset));
}
reset_value = FLAG_interrupt_budget >> 4;
}
__ Mov(x2, Operand(profiling_counter_));
- __ Mov(x3, Operand(Smi::FromInt(reset_value)));
+ __ Mov(x3, Smi::FromInt(reset_value));
__ Str(x3, FieldMemOperand(x2, Cell::kValueOffset));
}
ASSERT(IsDeclaredVariableMode(mode));
PropertyAttributes attr = IsImmutableVariableMode(mode) ? READ_ONLY
: NONE;
- __ Mov(x1, Operand(Smi::FromInt(attr)));
+ __ Mov(x1, Smi::FromInt(attr));
// Push initial value, if any.
// Note: For variables we must not push an initial value (such as
// 'undefined') because we may have a (legal) redeclaration and we
case Variable::LOOKUP: {
Comment cmnt(masm_, "[ Function Declaration");
__ Mov(x2, Operand(variable->name()));
- __ Mov(x1, Operand(Smi::FromInt(NONE)));
+ __ Mov(x1, Smi::FromInt(NONE));
__ Push(cp, x2, x1);
// Push initial value for function declaration.
VisitForStackValue(declaration->fun());
Register flags = xzr;
if (Smi::FromInt(DeclareGlobalsFlags())) {
flags = x10;
- __ Mov(flags, Operand(Smi::FromInt(DeclareGlobalsFlags())));
+ __ Mov(flags, Smi::FromInt(DeclareGlobalsFlags()));
}
__ Push(cp, x11, flags);
__ CallRuntime(Runtime::kDeclareGlobals, 3);
// Set up the four remaining stack slots.
__ Push(x0); // Map.
- __ Mov(x0, Operand(Smi::FromInt(0)));
+ __ Mov(x0, Smi::FromInt(0));
// Push enumeration cache, enumeration cache length (as smi) and zero.
__ SmiTag(x1);
__ Push(x2, x1, x0);
isolate());
StoreFeedbackVectorSlot(slot, feedback);
__ LoadObject(x1, FeedbackVector());
- __ Mov(x10, Operand(Smi::FromInt(TypeFeedbackInfo::kForInSlowCaseMarker)));
+ __ Mov(x10, Smi::FromInt(TypeFeedbackInfo::kForInSlowCaseMarker));
__ Str(x10, FieldMemOperand(x1, FixedArray::OffsetOfElementAt(slot)));
- __ Mov(x1, Operand(Smi::FromInt(1))); // Smi indicates slow check.
+ __ Mov(x1, Smi::FromInt(1)); // Smi indicates slow check.
__ Peek(x10, 0); // Get enumerated object.
STATIC_ASSERT(FIRST_JS_PROXY_TYPE == FIRST_SPEC_OBJECT_TYPE);
// TODO(all): similar check was done already. Can we avoid it here?
__ Bind(loop_statement.continue_label());
// TODO(all): We could use a callee saved register to avoid popping.
__ Pop(x0);
- __ Add(x0, x0, Operand(Smi::FromInt(1)));
+ __ Add(x0, x0, Smi::FromInt(1));
__ Push(x0);
EmitBackEdgeBookkeeping(stmt, &loop);
// Create regexp literal using runtime function.
// Result will be in x0.
- __ Mov(x3, Operand(Smi::FromInt(expr->literal_index())));
+ __ Mov(x3, Smi::FromInt(expr->literal_index()));
__ Mov(x2, Operand(expr->pattern()));
__ Mov(x1, Operand(expr->flags()));
__ Push(x4, x3, x2, x1);
__ B(&allocated);
__ Bind(&runtime_allocate);
- __ Mov(x10, Operand(Smi::FromInt(size)));
+ __ Mov(x10, Smi::FromInt(size));
__ Push(x5, x10);
__ CallRuntime(Runtime::kAllocateInNewSpace, 1);
__ Pop(x5);
Handle<FixedArray> constant_properties = expr->constant_properties();
__ Ldr(x3, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
__ Ldr(x3, FieldMemOperand(x3, JSFunction::kLiteralsOffset));
- __ Mov(x2, Operand(Smi::FromInt(expr->literal_index())));
+ __ Mov(x2, Smi::FromInt(expr->literal_index()));
__ Mov(x1, Operand(constant_properties));
int flags = expr->fast_elements()
? ObjectLiteral::kFastElements
flags |= expr->has_function()
? ObjectLiteral::kHasFunction
: ObjectLiteral::kNoFlags;
- __ Mov(x0, Operand(Smi::FromInt(flags)));
+ __ Mov(x0, Smi::FromInt(flags));
int properties_count = constant_properties->length() / 2;
const int max_cloned_properties =
FastCloneShallowObjectStub::kMaximumClonedProperties;
__ Push(x0);
VisitForStackValue(key);
VisitForStackValue(value);
- __ Mov(x0, Operand(Smi::FromInt(NONE))); // PropertyAttributes
+ __ Mov(x0, Smi::FromInt(NONE)); // PropertyAttributes
__ Push(x0);
__ CallRuntime(Runtime::kSetProperty, 4);
} else {
VisitForStackValue(it->first);
EmitAccessor(it->second->getter);
EmitAccessor(it->second->setter);
- __ Mov(x10, Operand(Smi::FromInt(NONE)));
+ __ Mov(x10, Smi::FromInt(NONE));
__ Push(x10);
__ CallRuntime(Runtime::kDefineOrRedefineAccessorProperty, 5);
}
__ Ldr(x3, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
__ Ldr(x3, FieldMemOperand(x3, JSFunction::kLiteralsOffset));
- // TODO(jbramley): Can these Operand constructors be implicit?
- __ Mov(x2, Operand(Smi::FromInt(expr->literal_index())));
+ __ Mov(x2, Smi::FromInt(expr->literal_index()));
__ Mov(x1, Operand(constant_elements));
if (has_fast_elements && constant_elements_values->map() ==
isolate()->heap()->fixed_cow_array_map()) {
isolate()->counters()->cow_arrays_created_stub(), 1, x10, x11);
} else if ((expr->depth() > 1) || Serializer::enabled() ||
length > FastCloneShallowArrayStub::kMaximumClonedLength) {
- __ Mov(x0, Operand(Smi::FromInt(flags)));
+ __ Mov(x0, Smi::FromInt(flags));
__ Push(x3, x2, x1, x0);
__ CallRuntime(Runtime::kCreateArrayLiteral, 4);
} else {
kLRHasBeenSaved, kDontSaveFPRegs,
EMIT_REMEMBERED_SET, INLINE_SMI_CHECK);
} else {
- __ Mov(x3, Operand(Smi::FromInt(i)));
+ __ Mov(x3, Smi::FromInt(i));
StoreArrayLiteralElementStub stub;
__ CallStub(&stub);
}
void FullCodeGenerator::EmitCallStoreContextSlot(
Handle<String> name, StrictMode strict_mode) {
__ Mov(x11, Operand(name));
- __ Mov(x10, Operand(Smi::FromInt(strict_mode)));
+ __ Mov(x10, Smi::FromInt(strict_mode));
// jssp[0] : mode.
// jssp[8] : name.
// jssp[16] : context.
TypeFeedbackInfo::UninitializedSentinel(isolate());
StoreFeedbackVectorSlot(expr->CallFeedbackSlot(), uninitialized);
__ LoadObject(x2, FeedbackVector());
- __ Mov(x3, Operand(Smi::FromInt(expr->CallFeedbackSlot())));
+ __ Mov(x3, Smi::FromInt(expr->CallFeedbackSlot()));
// Record call targets in unoptimized code.
CallFunctionStub stub(arg_count, RECORD_CALL_TARGET);
__ Push(x10, x11);
// Prepare to push the language mode.
- __ Mov(x10, Operand(Smi::FromInt(strict_mode())));
+ __ Mov(x10, Smi::FromInt(strict_mode()));
// Prepare to push the start position of the scope the calls resides in.
- __ Mov(x11, Operand(Smi::FromInt(scope()->start_position())));
+ __ Mov(x11, Smi::FromInt(scope()->start_position()));
// Push.
__ Push(x10, x11);
}
__ LoadObject(x2, FeedbackVector());
- __ Mov(x3, Operand(Smi::FromInt(expr->CallNewFeedbackSlot())));
+ __ Mov(x3, Smi::FromInt(expr->CallNewFeedbackSlot()));
CallConstructStub stub(RECORD_CALL_TARGET);
__ Call(stub.GetCode(isolate()), RelocInfo::CONSTRUCT_CALL);
// Skip the arguments adaptor frame if it exists.
Label check_frame_marker;
__ Ldr(x1, MemOperand(x2, StandardFrameConstants::kContextOffset));
- __ Cmp(x1, Operand(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
+ __ Cmp(x1, Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR));
__ B(ne, &check_frame_marker);
__ Ldr(x2, MemOperand(x2, StandardFrameConstants::kCallerFPOffset));
// Check the marker in the calling frame.
__ Bind(&check_frame_marker);
__ Ldr(x1, MemOperand(x2, StandardFrameConstants::kMarkerOffset));
- __ Cmp(x1, Operand(Smi::FromInt(StackFrame::CONSTRUCT)));
+ __ Cmp(x1, Smi::FromInt(StackFrame::CONSTRUCT));
PrepareForBailoutBeforeSplit(expr, true, if_true, if_false);
Split(eq, if_true, if_false, fall_through);
// ArgumentsAccessStub expects the key in x1.
VisitForAccumulatorValue(args->at(0));
__ Mov(x1, x0);
- __ Mov(x0, Operand(Smi::FromInt(info_->scope()->num_parameters())));
+ __ Mov(x0, Smi::FromInt(info_->scope()->num_parameters()));
ArgumentsAccessStub stub(ArgumentsAccessStub::READ_ELEMENT);
__ CallStub(&stub);
context()->Plug(x0);
ASSERT(expr->arguments()->length() == 0);
Label exit;
// Get the number of formal parameters.
- __ Mov(x0, Operand(Smi::FromInt(info_->scope()->num_parameters())));
+ __ Mov(x0, Smi::FromInt(info_->scope()->num_parameters()));
// Check if the calling frame is an arguments adaptor frame.
__ Ldr(x12, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
__ Ldr(x13, MemOperand(x12, StandardFrameConstants::kContextOffset));
- __ Cmp(x13, Operand(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
+ __ Cmp(x13, Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR));
__ B(ne, &exit);
// Arguments adaptor case: Read the arguments length from the
} else {
if (index->value() < JSDate::kFirstUncachedField) {
ExternalReference stamp = ExternalReference::date_cache_stamp(isolate());
- __ Mov(x10, Operand(stamp));
+ __ Mov(x10, stamp);
__ Ldr(stamp_addr, MemOperand(x10));
__ Ldr(stamp_cache, FieldMemOperand(object, JSDate::kCacheStampOffset));
__ Cmp(stamp_addr, stamp_cache);
}
__ Bind(&runtime);
- __ Mov(x1, Operand(index));
+ __ Mov(x1, index);
__ CallCFunction(ExternalReference::get_date_field_function(isolate()), 2);
__ B(&done);
}
__ Bind(&need_conversion);
// Move smi zero into the result register, which will trigger conversion.
- __ Mov(result, Operand(Smi::FromInt(0)));
+ __ Mov(result, Smi::FromInt(0));
__ B(&done);
NopRuntimeCallHelper call_helper;
// element: Current array element.
// elements_end: Array end.
if (FLAG_debug_code) {
- __ Cmp(array_length, Operand(0));
+ __ Cmp(array_length, 0);
__ Assert(gt, kNoEmptyArraysHereInEmitFastAsciiArrayJoin);
}
__ Bind(&loop);
if (property != NULL) {
VisitForStackValue(property->obj());
VisitForStackValue(property->key());
- __ Mov(x10, Operand(Smi::FromInt(strict_mode())));
+ __ Mov(x10, Smi::FromInt(strict_mode()));
__ Push(x10);
__ InvokeBuiltin(Builtins::DELETE, CALL_FUNCTION);
context()->Plug(x0);
if (var->IsUnallocated()) {
__ Ldr(x12, GlobalObjectMemOperand());
__ Mov(x11, Operand(var->name()));
- __ Mov(x10, Operand(Smi::FromInt(SLOPPY)));
+ __ Mov(x10, Smi::FromInt(SLOPPY));
__ Push(x12, x11, x10);
__ InvokeBuiltin(Builtins::DELETE, CALL_FUNCTION);
context()->Plug(x0);
}
}
- __ Adds(x0, x0, Operand(Smi::FromInt(count_value)));
+ __ Adds(x0, x0, Smi::FromInt(count_value));
__ B(vc, &done);
// Call stub. Undo operation first.
- __ Sub(x0, x0, Operand(Smi::FromInt(count_value)));
+ __ Sub(x0, x0, Smi::FromInt(count_value));
__ B(&stub_call);
__ Bind(&slow);
}
__ Bind(&stub_call);
__ Mov(x1, x0);
- __ Mov(x0, Operand(Smi::FromInt(count_value)));
+ __ Mov(x0, Smi::FromInt(count_value));
// Record position before stub call.
SetSourcePosition(expr->position());
__ Bind(&suspend);
VisitForAccumulatorValue(expr->generator_object());
ASSERT((continuation.pos() > 0) && Smi::IsValid(continuation.pos()));
- __ Mov(x1, Operand(Smi::FromInt(continuation.pos())));
+ __ Mov(x1, Smi::FromInt(continuation.pos()));
__ Str(x1, FieldMemOperand(x0, JSGeneratorObject::kContinuationOffset));
__ Str(cp, FieldMemOperand(x0, JSGeneratorObject::kContextOffset));
__ Mov(x1, cp);
case Yield::FINAL: {
VisitForAccumulatorValue(expr->generator_object());
- __ Mov(x1, Operand(Smi::FromInt(JSGeneratorObject::kGeneratorClosed)));
+ __ Mov(x1, Smi::FromInt(JSGeneratorObject::kGeneratorClosed));
__ Str(x1, FieldMemOperand(result_register(),
JSGeneratorObject::kContinuationOffset));
// Pop value from top-of-stack slot, box result into result register.
__ Peek(x0, generator_object_depth);
__ Push(x0); // g
ASSERT((l_continuation.pos() > 0) && Smi::IsValid(l_continuation.pos()));
- __ Mov(x1, Operand(Smi::FromInt(l_continuation.pos())));
+ __ Mov(x1, Smi::FromInt(l_continuation.pos()));
__ Str(x1, FieldMemOperand(x0, JSGeneratorObject::kContinuationOffset));
__ Str(cp, FieldMemOperand(x0, JSGeneratorObject::kContextOffset));
__ Mov(x1, cp);
JSGeneratorObject::kContinuationOffset));
STATIC_ASSERT(JSGeneratorObject::kGeneratorExecuting < 0);
STATIC_ASSERT(JSGeneratorObject::kGeneratorClosed == 0);
- __ CompareAndBranch(x10, Operand(Smi::FromInt(0)), eq, &closed_state);
- __ CompareAndBranch(x10, Operand(Smi::FromInt(0)), lt, &wrong_state);
+ __ CompareAndBranch(x10, Smi::FromInt(0), eq, &closed_state);
+ __ CompareAndBranch(x10, Smi::FromInt(0), lt, &wrong_state);
// Load suspended function and context.
__ Ldr(cp, FieldMemOperand(generator_object,
UntagSmiFieldMemOperand(generator_object,
JSGeneratorObject::kContinuationOffset));
__ Add(x10, x10, x11);
- __ Mov(x12, Operand(Smi::FromInt(JSGeneratorObject::kGeneratorExecuting)));
+ __ Mov(x12, Smi::FromInt(JSGeneratorObject::kGeneratorExecuting));
__ Str(x12, FieldMemOperand(generator_object,
JSGeneratorObject::kContinuationOffset));
__ Br(x10);
// up the stack and the handlers.
__ PushMultipleTimes(the_hole, operand_stack_size);
- __ Mov(x10, Operand(Smi::FromInt(resume_mode)));
+ __ Mov(x10, Smi::FromInt(resume_mode));
__ Push(generator_object, result_register(), x10);
__ CallRuntime(Runtime::kResumeJSGeneratorObject, 3);
// Not reached: the runtime call returns elsewhere.
// Store pending message while executing finally block.
ExternalReference pending_message_obj =
ExternalReference::address_of_pending_message_obj(isolate());
- __ Mov(x10, Operand(pending_message_obj));
+ __ Mov(x10, pending_message_obj);
__ Ldr(x10, MemOperand(x10));
ExternalReference has_pending_message =
ExternalReference::address_of_has_pending_message(isolate());
- __ Mov(x11, Operand(has_pending_message));
+ __ Mov(x11, has_pending_message);
__ Ldr(x11, MemOperand(x11));
__ SmiTag(x11);
ExternalReference pending_message_script =
ExternalReference::address_of_pending_message_script(isolate());
- __ Mov(x10, Operand(pending_message_script));
+ __ Mov(x10, pending_message_script);
__ Ldr(x10, MemOperand(x10));
__ Push(x10);
}
__ Pop(x10, x11, x12);
ExternalReference pending_message_script =
ExternalReference::address_of_pending_message_script(isolate());
- __ Mov(x13, Operand(pending_message_script));
+ __ Mov(x13, pending_message_script);
__ Str(x10, MemOperand(x13));
__ SmiUntag(x11);
ExternalReference has_pending_message =
ExternalReference::address_of_has_pending_message(isolate());
- __ Mov(x13, Operand(has_pending_message));
+ __ Mov(x13, has_pending_message);
__ Str(x11, MemOperand(x13));
ExternalReference pending_message_obj =
ExternalReference::address_of_pending_message_obj(isolate());
- __ Mov(x13, Operand(pending_message_obj));
+ __ Mov(x13, pending_message_obj);
__ Str(x12, MemOperand(x13));
// Restore result register and cooked return address from the stack.
NameDictionary::kElementsStartIndex * kPointerSize;
static const int kDetailsOffset = kElementsStartOffset + 2 * kPointerSize;
__ Ldr(scratch1, FieldMemOperand(scratch2, kDetailsOffset));
- __ Tst(scratch1, Operand(Smi::FromInt(PropertyDetails::TypeField::kMask)));
+ __ Tst(scratch1, Smi::FromInt(PropertyDetails::TypeField::kMask));
__ B(ne, miss);
// Get the value at the masked, scaled index and return.
// Check if element is in the range of mapped arguments. If not, jump
// to the unmapped lookup.
__ Ldr(scratch1, FieldMemOperand(map, FixedArray::kLengthOffset));
- __ Sub(scratch1, scratch1, Operand(Smi::FromInt(2)));
+ __ Sub(scratch1, scratch1, Smi::FromInt(2));
__ Cmp(key, scratch1);
__ B(hs, unmapped_case);
ExternalReference cache_keys =
ExternalReference::keyed_lookup_cache_keys(isolate);
- __ Mov(scratch3, Operand(cache_keys));
+ __ Mov(scratch3, cache_keys);
__ Add(scratch3, scratch3, Operand(scratch2, LSL, kPointerSizeLog2 + 1));
for (int i = 0; i < kEntriesPerBucket - 1; i++) {
// Hit on nth entry.
for (int i = kEntriesPerBucket - 1; i >= 0; i--) {
__ Bind(&hit_on_nth_entry[i]);
- __ Mov(scratch3, Operand(cache_field_offsets));
+ __ Mov(scratch3, cache_field_offsets);
if (i != 0) {
__ Add(scratch2, scratch2, i);
}
// Push PropertyAttributes(NONE) and strict_mode for runtime call.
STATIC_ASSERT(NONE == 0);
- __ Mov(x10, Operand(Smi::FromInt(strict_mode)));
+ __ Mov(x10, Smi::FromInt(strict_mode));
__ Push(xzr, x10);
__ TailCallRuntime(Runtime::kSetProperty, 5, 1);
__ Bind(&finish_store);
if (increment_length == kIncrementLength) {
// Add 1 to receiver->length.
- __ Add(x10, key, Operand(Smi::FromInt(1)));
+ __ Add(x10, key, Smi::FromInt(1));
__ Str(x10, FieldMemOperand(receiver, JSArray::kLengthOffset));
}
&transition_double_elements);
if (increment_length == kIncrementLength) {
// Add 1 to receiver->length.
- __ Add(x10, key, Operand(Smi::FromInt(1)));
+ __ Add(x10, key, Smi::FromInt(1));
__ Str(x10, FieldMemOperand(receiver, JSArray::kLengthOffset));
}
__ Ret();
__ Push(x1, x2, x0);
- __ Mov(x11, Operand(Smi::FromInt(NONE))); // PropertyAttributes
- __ Mov(x10, Operand(Smi::FromInt(strict_mode)));
+ __ Mov(x11, Smi::FromInt(NONE)); // PropertyAttributes
+ __ Mov(x10, Smi::FromInt(strict_mode));
__ Push(x11, x10);
// Do tail-call to runtime routine.
ASSERT(info()->IsStub());
frame_is_built_ = true;
__ Push(lr, fp, cp);
- __ Mov(fp, Operand(Smi::FromInt(StackFrame::STUB)));
+ __ Mov(fp, Smi::FromInt(StackFrame::STUB));
__ Push(fp);
__ Add(fp, __ StackPointer(),
StandardFrameConstants::kFixedFrameSizeFromFp);
Register stub_deopt_entry = temps.AcquireX();
Register stub_marker = temps.AcquireX();
- __ Mov(stub_deopt_entry,
- Operand(ExternalReference::ForDeoptEntry(entry)));
+ __ Mov(stub_deopt_entry, ExternalReference::ForDeoptEntry(entry));
if (needs_frame.is_bound()) {
__ B(&needs_frame);
} else {
// have a function pointer to install in the stack frame that we're
// building, install a special marker there instead.
ASSERT(info()->IsStub());
- __ Mov(stub_marker, Operand(Smi::FromInt(StackFrame::STUB)));
+ __ Mov(stub_marker, Smi::FromInt(StackFrame::STUB));
__ Push(lr, fp, cp, stub_marker);
__ Add(fp, __ StackPointer(), 2 * kPointerSize);
__ Call(stub_deopt_entry);
__ Push(x0, x1, x2);
__ Mrs(x2, NZCV);
- __ Mov(x0, Operand(count));
+ __ Mov(x0, count);
__ Ldr(w1, MemOperand(x0));
__ Subs(x1, x1, 1);
__ B(gt, ¬_zero);
// TODO(3095996): Get rid of this. For now, we need to make the
// result register contain a valid pointer because it is already
// contained in the register pointer map.
- __ Mov(ToRegister(instr->result()), Operand(Smi::FromInt(0)));
+ __ Mov(ToRegister(instr->result()), Smi::FromInt(0));
PushSafepointRegistersScope scope(this, Safepoint::kWithRegisters);
// We're in a SafepointRegistersScope so we can use any scratch registers.
Register size = x0;
if (instr->size()->IsConstantOperand()) {
- __ Mov(size, Operand(ToSmi(LConstantOperand::cast(instr->size()))));
+ __ Mov(size, ToSmi(LConstantOperand::cast(instr->size())));
} else {
__ SmiTag(size, ToRegister32(instr->size()).X());
}
} else {
flags = AllocateTargetSpace::update(flags, NEW_SPACE);
}
- __ Mov(x10, Operand(Smi::FromInt(flags)));
+ __ Mov(x10, Smi::FromInt(flags));
__ Push(size, x10);
CallRuntimeFromDeferred(
MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
__ Ldr(result,
MemOperand(previous_fp, StandardFrameConstants::kContextOffset));
- __ Cmp(result, Operand(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
+ __ Cmp(result, Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR));
__ Csel(result, fp, previous_fp, ne);
}
}
ToInteger32(LConstantOperand::cast(instr->index()));
if (instr->hydrogen()->length()->representation().IsSmi()) {
- __ Cmp(length, Operand(Smi::FromInt(constant_index)));
+ __ Cmp(length, Smi::FromInt(constant_index));
} else {
- __ Cmp(length, Operand(constant_index));
+ __ Cmp(length, constant_index);
}
} else {
ASSERT(instr->hydrogen()->index()->representation().IsInteger32());
EmitBranch(instr, eq);
} else if (type.IsSmi()) {
ASSERT(!info()->IsStub());
- EmitCompareAndBranch(instr, ne, value, Operand(Smi::FromInt(0)));
+ EmitCompareAndBranch(instr, ne, value, Smi::FromInt(0));
} else if (type.IsJSArray()) {
ASSERT(!info()->IsStub());
EmitGoto(instr->TrueDestination(chunk()));
Handle<Cell> cell = factory()->NewCell(factory()->the_hole_value());
__ LoadRelocated(scratch, Operand(Handle<Object>(cell)));
__ ldr(scratch, FieldMemOperand(scratch, PropertyCell::kValueOffset));
- __ cmp(map, Operand(scratch));
+ __ cmp(map, scratch);
__ b(&cache_miss, ne);
// The address of this instruction is computed relative to the map check
// above, so check the size of the code generated.
// Skip the arguments adaptor frame if it exists.
Label check_frame_marker;
__ Ldr(temp2, MemOperand(temp1, StandardFrameConstants::kContextOffset));
- __ Cmp(temp2, Operand(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
+ __ Cmp(temp2, Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR));
__ B(ne, &check_frame_marker);
__ Ldr(temp1, MemOperand(temp1, StandardFrameConstants::kCallerFPOffset));
__ B(pl, ÷nd_is_not_negative);
// Note that this is correct even for kMinInt operands.
__ Neg(dividend, dividend);
- __ And(dividend, dividend, Operand(mask));
+ __ And(dividend, dividend, mask);
__ Negs(dividend, dividend);
if (hmod->CheckFlag(HValue::kBailoutOnMinusZero)) {
DeoptimizeIf(eq, instr->environment());
}
__ bind(÷nd_is_not_negative);
- __ And(dividend, dividend, Operand(mask));
+ __ And(dividend, dividend, mask);
__ bind(&done);
}
// TODO(all): if Mov could handle object in new space then it could be used
// here.
__ LoadHeapObject(scratch1, instr->hydrogen()->pairs());
- __ Mov(scratch2, Operand(Smi::FromInt(instr->hydrogen()->flags())));
+ __ Mov(scratch2, Smi::FromInt(instr->hydrogen()->flags()));
__ Push(cp, scratch1, scratch2); // The context is the first argument.
CallRuntime(Runtime::kDeclareGlobals, 3, instr);
}
__ B(&allocated);
__ Bind(&runtime_allocate);
- __ Mov(x0, Operand(Smi::FromInt(size)));
+ __ Mov(x0, Smi::FromInt(size));
__ Push(x1, x0);
CallRuntime(Runtime::kAllocateInNewSpace, 1, instr);
__ Pop(x1);
__ AssertSmi(index);
Label out_of_object, done;
- __ Cmp(index, Operand(Smi::FromInt(0)));
+ __ Cmp(index, Smi::FromInt(0));
__ B(lt, &out_of_object);
STATIC_ASSERT(kPointerSizeLog2 > kSmiTagSize);
if (destination->IsRegister()) {
Register dst = cgen_->ToRegister(destination);
if (cgen_->IsSmi(constant_source)) {
- __ Mov(dst, Operand(cgen_->ToSmi(constant_source)));
+ __ Mov(dst, cgen_->ToSmi(constant_source));
} else if (cgen_->IsInteger32Constant(constant_source)) {
__ Mov(dst, cgen_->ToInteger32(constant_source));
} else {
ASSERT(!in_cycle_); // Constant moves happen after all cycles are gone.
need_to_restore_root_ = true;
if (cgen_->IsSmi(constant_source)) {
- __ Mov(kSavedValue, Operand(cgen_->ToSmi(constant_source)));
+ __ Mov(kSavedValue, cgen_->ToSmi(constant_source));
} else if (cgen_->IsInteger32Constant(constant_source)) {
__ Mov(kSavedValue, cgen_->ToInteger32(constant_source));
} else {
void MacroAssembler::EnumLengthSmi(Register dst, Register map) {
STATIC_ASSERT(Map::EnumLengthBits::kShift == 0);
Ldr(dst, FieldMemOperand(map, Map::kBitField3Offset));
- And(dst, dst, Operand(Smi::FromInt(Map::EnumLengthBits::kMask)));
+ And(dst, dst, Smi::FromInt(Map::EnumLengthBits::kMask));
}
Add(scratch1, receiver,
JSArray::kSize + AllocationMemento::kSize - kHeapObjectTag);
- Cmp(scratch1, Operand(new_space_start));
+ Cmp(scratch1, new_space_start);
B(lt, no_memento_found);
- Mov(scratch2, Operand(new_space_allocation_top));
+ Mov(scratch2, new_space_allocation_top);
Ldr(scratch2, MemOperand(scratch2));
Cmp(scratch1, scratch2);
B(gt, no_memento_found);
ASSERT(cond == eq || cond == ne);
UseScratchRegisterScope temps(this);
Register temp = temps.AcquireX();
- And(temp, object, Operand(ExternalReference::new_space_mask(isolate())));
- Cmp(temp, Operand(ExternalReference::new_space_start(isolate())));
+ And(temp, object, ExternalReference::new_space_mask(isolate()));
+ Cmp(temp, ExternalReference::new_space_start(isolate()));
B(cond, branch);
}
RecordComment((msg != NULL) ? msg : "UNKNOWN");
#endif
- Mov(x0, Operand(Smi::FromInt(reason)));
+ Mov(x0, Smi::FromInt(reason));
Push(x0);
// Disable stub call restrictions to always allow calls to throw.
// Place the necessary arguments.
Mov(x0, num_arguments);
- Mov(x1, Operand(ExternalReference(f, isolate())));
+ Mov(x1, ExternalReference(f, isolate()));
CEntryStub stub(1, save_doubles);
CallStub(&stub);
Mov(x10, reinterpret_cast<uintptr_t>(is_profiling_flag));
Ldrb(w10, MemOperand(x10));
Cbz(w10, &profiler_disabled);
- Mov(x3, Operand(thunk_ref));
+ Mov(x3, thunk_ref);
B(&end_profiler_check);
Bind(&profiler_disabled);
Register limit_reg = x20;
Register level_reg = w21;
- Mov(handle_scope_base, Operand(next_address));
+ Mov(handle_scope_base, next_address);
Ldr(next_address_reg, MemOperand(handle_scope_base, kNextOffset));
Ldr(limit_reg, MemOperand(handle_scope_base, kLimitOffset));
Ldr(level_reg, MemOperand(handle_scope_base, kLevelOffset));
if (FLAG_log_timer_events) {
FrameScope frame(this, StackFrame::MANUAL);
PushSafepointRegisters();
- Mov(x0, Operand(ExternalReference::isolate_address(isolate())));
+ Mov(x0, ExternalReference::isolate_address(isolate()));
CallCFunction(ExternalReference::log_enter_external_function(isolate()), 1);
PopSafepointRegisters();
}
if (FLAG_log_timer_events) {
FrameScope frame(this, StackFrame::MANUAL);
PushSafepointRegisters();
- Mov(x0, Operand(ExternalReference::isolate_address(isolate())));
+ Mov(x0, ExternalReference::isolate_address(isolate()));
CallCFunction(ExternalReference::log_leave_external_function(isolate()), 1);
PopSafepointRegisters();
}
Peek(x22, (spill_offset + 3) * kXRegSize);
// Check if the function scheduled an exception.
- Mov(x5, Operand(ExternalReference::scheduled_exception_address(isolate())));
+ Mov(x5, ExternalReference::scheduled_exception_address(isolate()));
Ldr(x5, MemOperand(x5));
JumpIfNotRoot(x5, Heap::kTheHoleValueRootIndex, &promote_scheduled_exception);
Bind(&exception_handled);
// Save the return value in a callee-save register.
Register saved_result = x19;
Mov(saved_result, x0);
- Mov(x0, Operand(ExternalReference::isolate_address(isolate())));
+ Mov(x0, ExternalReference::isolate_address(isolate()));
CallCFunction(
ExternalReference::delete_handle_scope_extensions(isolate()), 1);
Mov(x0, saved_result);
void MacroAssembler::CallExternalReference(const ExternalReference& ext,
int num_arguments) {
Mov(x0, num_arguments);
- Mov(x1, Operand(ext));
+ Mov(x1, ext);
CEntryStub stub(1);
CallStub(&stub);
void MacroAssembler::JumpToExternalReference(const ExternalReference& builtin) {
- Mov(x1, Operand(builtin));
+ Mov(x1, builtin);
CEntryStub stub(1);
Jump(stub.GetCode(isolate()), RelocInfo::CODE_TARGET);
}
int num_of_double_args) {
UseScratchRegisterScope temps(this);
Register temp = temps.AcquireX();
- Mov(temp, Operand(function));
+ Mov(temp, function);
CallCFunction(temp, num_of_reg_args, num_of_double_args);
}
ASSERT(StackPointer().Is(jssp));
UseScratchRegisterScope temps(this);
Register temp = temps.AcquireX();
- __ Mov(temp, Operand(Smi::FromInt(StackFrame::STUB)));
+ __ Mov(temp, Smi::FromInt(StackFrame::STUB));
// Compiled stubs don't age, and so they don't need the predictable code
// ageing sequence.
__ Push(lr, fp, cp, temp);
Register code_reg = temps.AcquireX();
Push(lr, fp, cp);
- Mov(type_reg, Operand(Smi::FromInt(type)));
+ Mov(type_reg, Smi::FromInt(type));
Mov(code_reg, Operand(CodeObject()));
Push(type_reg, code_reg);
// jssp[4] : lr
Register scratch1, Register scratch2) {
if (FLAG_native_code_counters && counter->Enabled()) {
Mov(scratch1, value);
- Mov(scratch2, Operand(ExternalReference(counter)));
+ Mov(scratch2, ExternalReference(counter));
Str(scratch1, MemOperand(scratch2));
}
}
Register scratch1, Register scratch2) {
ASSERT(value != 0);
if (FLAG_native_code_counters && counter->Enabled()) {
- Mov(scratch2, Operand(ExternalReference(counter)));
+ Mov(scratch2, ExternalReference(counter));
Ldr(scratch1, MemOperand(scratch2));
Add(scratch1, scratch1, value);
Str(scratch1, MemOperand(scratch2));
#ifdef ENABLE_DEBUGGER_SUPPORT
void MacroAssembler::DebugBreak() {
Mov(x0, 0);
- Mov(x1, Operand(ExternalReference(Runtime::kDebugBreak, isolate())));
+ Mov(x1, ExternalReference(Runtime::kDebugBreak, isolate()));
CEntryStub ces(1);
ASSERT(AllowThisStubCall(&ces));
Call(ces.GetCode(isolate()), RelocInfo::DEBUG_BREAK);
}
// Link the current handler as the next handler.
- Mov(x11, Operand(ExternalReference(Isolate::kHandlerAddress, isolate())));
+ Mov(x11, ExternalReference(Isolate::kHandlerAddress, isolate()));
Ldr(x10, MemOperand(x11));
Push(x10);
// Set this new handler as the current one.
void MacroAssembler::PopTryHandler() {
STATIC_ASSERT(StackHandlerConstants::kNextOffset == 0);
Pop(x10);
- Mov(x11, Operand(ExternalReference(Isolate::kHandlerAddress, isolate())));
+ Mov(x11, ExternalReference(Isolate::kHandlerAddress, isolate()));
Drop(StackHandlerConstants::kSize - kXRegSize, kByteSizeInBytes);
Str(x10, MemOperand(x11));
}
// Set up allocation top address and object size registers.
Register top_address = scratch1;
Register allocation_limit = scratch2;
- Mov(top_address, Operand(heap_allocation_top));
+ Mov(top_address, heap_allocation_top);
if ((flags & RESULT_CONTAINS_TOP) == 0) {
// Load allocation top into result and the allocation limit.
Bic(object, object, kHeapObjectTagMask);
#ifdef DEBUG
// Check that the object un-allocated is below the current top.
- Mov(scratch, Operand(new_space_allocation_top));
+ Mov(scratch, new_space_allocation_top);
Ldr(scratch, MemOperand(scratch));
Cmp(object, scratch);
Check(lt, kUndoAllocationOfNonAllocatedMemory);
#endif
// Write the address of the object to un-allocate as the current top.
- Mov(scratch, Operand(new_space_allocation_top));
+ Mov(scratch, new_space_allocation_top);
Str(object, MemOperand(scratch));
}
ExternalReference high_promotion_mode = ExternalReference::
new_space_high_promotion_mode_active_address(isolate());
- Mov(scratch1, Operand(high_promotion_mode));
+ Mov(scratch1, high_promotion_mode);
Ldr(scratch1, MemOperand(scratch1));
Cbz(scratch1, &allocate_new_space);
Register scratch2 = temps.AcquireX();
// Load store buffer top.
- Mov(scratch2, Operand(ExternalReference::store_buffer_top(isolate())));
+ Mov(scratch2, ExternalReference::store_buffer_top(isolate()));
Ldr(scratch1, MemOperand(scratch2));
// Store pointer to buffer and increment buffer top.
Str(address, MemOperand(scratch1, kPointerSize, PostIndex));
UseScratchRegisterScope temps(this);
Register temp = temps.AcquireX();
STATIC_ASSERT(kSmiTag == 0);
- Tst(object, Operand(kSmiTagMask));
+ Tst(object, kSmiTagMask);
Check(ne, kOperandIsNotAString);
Ldr(temp, FieldMemOperand(object, HeapObject::kMapOffset));
CompareInstanceType(temp, temp, FIRST_NONSTRING_TYPE);
// Avoid infinite recursion; Push contains some assertions that use Abort.
NoUseRealAbortsScope no_real_aborts(this);
- Mov(x0, Operand(Smi::FromInt(reason)));
+ Mov(x0, Smi::FromInt(reason));
Push(x0);
if (!has_frame_) {
ASSERT(!AreAliased(result, dividend));
ASSERT(result.Is32Bits() && dividend.Is32Bits());
MultiplierAndShift ms(divisor);
- Mov(result, Operand(ms.multiplier()));
+ Mov(result, ms.multiplier());
Smull(result.X(), dividend, result);
Asr(result.X(), result.X(), 32);
if (divisor > 0 && ms.multiplier() < 0) Add(result, result, dividend);
// Address of current input position.
__ Add(x1, input_end(), Operand(current_input_offset(), SXTW));
// Isolate.
- __ Mov(x3, Operand(ExternalReference::isolate_address(isolate())));
+ __ Mov(x3, ExternalReference::isolate_address(isolate()));
{
AllowExternalCallThatCantCauseGC scope(masm_);
CompareAndBranchOrBacktrack(current_character(), 'z', hi, on_no_match);
}
ExternalReference map = ExternalReference::re_word_character_map();
- __ Mov(x10, Operand(map));
+ __ Mov(x10, map);
__ Ldrb(w10, MemOperand(x10, current_character(), UXTW));
CompareAndBranchOrBacktrack(w10, 0, eq, on_no_match);
return true;
__ B(hi, &done);
}
ExternalReference map = ExternalReference::re_word_character_map();
- __ Mov(x10, Operand(map));
+ __ Mov(x10, map);
__ Ldrb(w10, MemOperand(x10, current_character(), UXTW));
CompareAndBranchOrBacktrack(w10, 0, ne, on_no_match);
__ Bind(&done);
ExternalReference stack_limit =
ExternalReference::address_of_stack_limit(isolate());
- __ Mov(x10, Operand(stack_limit));
+ __ Mov(x10, stack_limit);
__ Ldr(x10, MemOperand(x10));
__ Subs(x10, csp, x10);
// The cached registers need to be retained.
__ PushCPURegList(cached_registers);
// Call GrowStack(backtrack_stackpointer(), &stack_base)
- __ Mov(x2, Operand(ExternalReference::isolate_address(isolate())));
+ __ Mov(x2, ExternalReference::isolate_address(isolate()));
__ Add(x1, frame_pointer(), kStackBase);
__ Mov(x0, backtrack_stackpointer());
ExternalReference grow_stack =
ExternalReference check_stack_guard_state =
ExternalReference::re_check_stack_guard_state(isolate());
- __ Mov(scratch, Operand(check_stack_guard_state));
+ __ Mov(scratch, check_stack_guard_state);
DirectCEntryStub stub;
stub.GenerateCall(masm_, scratch);
// Check for preemption.
ExternalReference stack_limit =
ExternalReference::address_of_stack_limit(isolate());
- __ Mov(x10, Operand(stack_limit));
+ __ Mov(x10, stack_limit);
__ Ldr(x10, MemOperand(x10));
ASSERT(csp.Is(__ StackPointer()));
__ Cmp(csp, x10);
void RegExpMacroAssemblerA64::CheckStackLimit() {
ExternalReference stack_limit =
ExternalReference::address_of_regexp_stack_limit(isolate());
- __ Mov(x10, Operand(stack_limit));
+ __ Mov(x10, stack_limit);
__ Ldr(x10, MemOperand(x10));
__ Cmp(backtrack_stackpointer(), x10);
CallIf(&stack_overflow_label_, ls);
__ Add(scratch3, offset, Operand(offset, LSL, 1));
// Calculate the base address of the entry.
- __ Mov(scratch, Operand(key_offset));
+ __ Mov(scratch, key_offset);
__ Add(scratch, scratch, Operand(scratch3, LSL, kPointerSizeLog2));
// Check that the key in the entry matches the name.
ExternalReference ref = ExternalReference(&fun,
ExternalReference::DIRECT_API_CALL,
masm->isolate());
- __ Mov(api_function_address, Operand(ref));
+ __ Mov(api_function_address, ref);
// Jump to stub.
CallApiFunctionStub stub(is_store, call_data_undefined, argc);
// together. Can we use scratch1() here?
__ LoadRoot(scratch4(), Heap::kUndefinedValueRootIndex);
__ Push(scratch3(), scratch4());
- __ Mov(scratch3(), Operand(ExternalReference::isolate_address(isolate())));
+ __ Mov(scratch3(), ExternalReference::isolate_address(isolate()));
__ Push(scratch4(), scratch3(), reg, name());
Register args_addr = scratch2();
ApiFunction fun(getter_address);
ExternalReference::Type type = ExternalReference::DIRECT_GETTER_CALL;
ExternalReference ref = ExternalReference(&fun, type, isolate());
- __ Mov(getter_address_reg, Operand(ref));
+ __ Mov(getter_address_reg, ref);
CallApiGetterStub stub;
__ TailCallStub(&stub);
projects / platform / upstream / v8.git / commitdiff