blob: 12842230bf46ea0642a66fcd1926a59ec7be2c5a [file] [log] [blame]
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +00001// Copyright 2010 the V8 project authors. All rights reserved.
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002// Redistribution and use in source and binary forms, with or without
3// modification, are permitted provided that the following conditions are
4// met:
5//
6// * Redistributions of source code must retain the above copyright
7// notice, this list of conditions and the following disclaimer.
8// * Redistributions in binary form must reproduce the above
9// copyright notice, this list of conditions and the following
10// disclaimer in the documentation and/or other materials provided
11// with the distribution.
12// * Neither the name of Google Inc. nor the names of its
13// contributors may be used to endorse or promote products derived
14// from this software without specific prior written permission.
15//
16// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
28#include "v8.h"
29
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +000030#if defined(V8_TARGET_ARCH_ARM)
31
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +000032#include "bootstrapper.h"
ricow@chromium.orgd236f4d2010-09-01 06:52:08 +000033#include "code-stubs.h"
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +000034#include "codegen-inl.h"
ager@chromium.orgc4c92722009-11-18 14:12:51 +000035#include "compiler.h"
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +000036#include "debug.h"
ager@chromium.orgce5e87b2010-03-10 10:24:18 +000037#include "ic-inl.h"
ricow@chromium.orgc9c80822010-04-21 08:22:37 +000038#include "jsregexp.h"
kasperl@chromium.orga5551262010-12-07 12:49:48 +000039#include "jump-target-inl.h"
ager@chromium.orgbb29dc92009-03-24 13:25:23 +000040#include "parser.h"
ricow@chromium.orgc9c80822010-04-21 08:22:37 +000041#include "regexp-macro-assembler.h"
42#include "regexp-stack.h"
ager@chromium.orgbb29dc92009-03-24 13:25:23 +000043#include "register-allocator-inl.h"
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +000044#include "runtime.h"
ager@chromium.orgbb29dc92009-03-24 13:25:23 +000045#include "scopes.h"
erik.corry@gmail.com4a6c3272010-11-18 12:04:40 +000046#include "stub-cache.h"
sgjesse@chromium.org833cdd72010-02-26 10:06:16 +000047#include "virtual-frame-inl.h"
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +000048#include "virtual-frame-arm-inl.h"
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +000049
kasperl@chromium.org71affb52009-05-26 05:44:31 +000050namespace v8 {
51namespace internal {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +000052
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +000053
ricow@chromium.org30ce4112010-05-31 10:38:25 +000054#define __ ACCESS_MASM(masm_)
kasperl@chromium.org2abc4502009-07-02 07:00:29 +000055
ager@chromium.orge2902be2009-06-08 12:21:35 +000056// -------------------------------------------------------------------------
57// Platform-specific DeferredCode functions.
58
59void DeferredCode::SaveRegisters() {
ricow@chromium.org30ce4112010-05-31 10:38:25 +000060 // On ARM you either have a completely spilled frame or you
61 // handle it yourself, but at the moment there's no automation
62 // of registers and deferred code.
ager@chromium.orge2902be2009-06-08 12:21:35 +000063}
64
65
66void DeferredCode::RestoreRegisters() {
ricow@chromium.org30ce4112010-05-31 10:38:25 +000067}
68
69
70// -------------------------------------------------------------------------
71// Platform-specific RuntimeCallHelper functions.
72
73void VirtualFrameRuntimeCallHelper::BeforeCall(MacroAssembler* masm) const {
74 frame_state_->frame()->AssertIsSpilled();
75}
76
77
78void VirtualFrameRuntimeCallHelper::AfterCall(MacroAssembler* masm) const {
79}
80
81
kasperl@chromium.orga5551262010-12-07 12:49:48 +000082void StubRuntimeCallHelper::BeforeCall(MacroAssembler* masm) const {
ricow@chromium.org30ce4112010-05-31 10:38:25 +000083 masm->EnterInternalFrame();
84}
85
86
kasperl@chromium.orga5551262010-12-07 12:49:48 +000087void StubRuntimeCallHelper::AfterCall(MacroAssembler* masm) const {
ricow@chromium.org30ce4112010-05-31 10:38:25 +000088 masm->LeaveInternalFrame();
ager@chromium.orge2902be2009-06-08 12:21:35 +000089}
90
ager@chromium.org3bf7b912008-11-17 09:09:45 +000091
92// -------------------------------------------------------------------------
kasperl@chromium.orgb9123622008-09-17 14:05:56 +000093// CodeGenState implementation.
94
ager@chromium.org7c537e22008-10-16 08:43:32 +000095CodeGenState::CodeGenState(CodeGenerator* owner)
kasperl@chromium.orgb9123622008-09-17 14:05:56 +000096 : owner_(owner),
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +000097 previous_(owner->state()) {
98 owner->set_state(this);
kasperl@chromium.orgb9123622008-09-17 14:05:56 +000099}
100
101
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +0000102ConditionCodeGenState::ConditionCodeGenState(CodeGenerator* owner,
103 JumpTarget* true_target,
104 JumpTarget* false_target)
105 : CodeGenState(owner),
kasperl@chromium.orgb9123622008-09-17 14:05:56 +0000106 true_target_(true_target),
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +0000107 false_target_(false_target) {
108 owner->set_state(this);
109}
110
111
112TypeInfoCodeGenState::TypeInfoCodeGenState(CodeGenerator* owner,
113 Slot* slot,
114 TypeInfo type_info)
115 : CodeGenState(owner),
116 slot_(slot) {
117 owner->set_state(this);
118 old_type_info_ = owner->set_type_info(slot, type_info);
kasperl@chromium.orgb9123622008-09-17 14:05:56 +0000119}
120
121
kasperl@chromium.orgb9123622008-09-17 14:05:56 +0000122CodeGenState::~CodeGenState() {
123 ASSERT(owner_->state() == this);
124 owner_->set_state(previous_);
125}
126
127
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +0000128TypeInfoCodeGenState::~TypeInfoCodeGenState() {
129 owner()->set_type_info(slot_, old_type_info_);
130}
131
ager@chromium.org3bf7b912008-11-17 09:09:45 +0000132// -------------------------------------------------------------------------
ager@chromium.org7c537e22008-10-16 08:43:32 +0000133// CodeGenerator implementation
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000134
whesse@chromium.orgba5a61b2010-07-26 11:44:40 +0000135int CodeGenerator::inlined_write_barrier_size_ = -1;
136
ager@chromium.org5c838252010-02-19 08:53:10 +0000137CodeGenerator::CodeGenerator(MacroAssembler* masm)
138 : deferred_(8),
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +0000139 masm_(masm),
ager@chromium.org5c838252010-02-19 08:53:10 +0000140 info_(NULL),
ager@chromium.org3bf7b912008-11-17 09:09:45 +0000141 frame_(NULL),
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000142 allocator_(NULL),
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000143 cc_reg_(al),
144 state_(NULL),
ricow@chromium.orgc9c80822010-04-21 08:22:37 +0000145 loop_nesting_(0),
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +0000146 type_info_(NULL),
fschneider@chromium.org40b9da32010-06-28 11:29:21 +0000147 function_return_(JumpTarget::BIDIRECTIONAL),
christian.plesner.hansen@gmail.com5a6af922009-08-12 14:20:51 +0000148 function_return_is_shadowed_(false) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000149}
150
151
152// Calling conventions:
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000153// fp: caller's frame pointer
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000154// sp: stack pointer
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000155// r1: called JS function
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000156// cp: callee's context
157
fschneider@chromium.orgb95b98b2010-02-23 10:34:29 +0000158void CodeGenerator::Generate(CompilationInfo* info) {
ager@chromium.orgc4c92722009-11-18 14:12:51 +0000159 // Record the position for debugging purposes.
ager@chromium.org5c838252010-02-19 08:53:10 +0000160 CodeForFunctionPosition(info->function());
ager@chromium.orgce5e87b2010-03-10 10:24:18 +0000161 Comment cmnt(masm_, "[ function compiled by virtual frame code generator");
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000162
163 // Initialize state.
ager@chromium.org5c838252010-02-19 08:53:10 +0000164 info_ = info;
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +0000165
166 int slots = scope()->num_parameters() + scope()->num_stack_slots();
167 ScopedVector<TypeInfo> type_info_array(slots);
kasperl@chromium.orga5551262010-12-07 12:49:48 +0000168 for (int i = 0; i < slots; i++) {
169 type_info_array[i] = TypeInfo::Unknown();
170 }
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +0000171 type_info_ = &type_info_array;
172
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000173 ASSERT(allocator_ == NULL);
174 RegisterAllocator register_allocator(this);
175 allocator_ = &register_allocator;
ager@chromium.org3bf7b912008-11-17 09:09:45 +0000176 ASSERT(frame_ == NULL);
kasperl@chromium.org71affb52009-05-26 05:44:31 +0000177 frame_ = new VirtualFrame();
ager@chromium.org3bf7b912008-11-17 09:09:45 +0000178 cc_reg_ = al;
ricow@chromium.orgc9c80822010-04-21 08:22:37 +0000179
180 // Adjust for function-level loop nesting.
181 ASSERT_EQ(0, loop_nesting_);
ager@chromium.orgb61a0d12010-10-13 08:35:23 +0000182 loop_nesting_ = info->is_in_loop() ? 1 : 0;
ricow@chromium.orgc9c80822010-04-21 08:22:37 +0000183
ager@chromium.org3bf7b912008-11-17 09:09:45 +0000184 {
185 CodeGenState state(this);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000186
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000187 // Entry:
188 // Stack: receiver, arguments
189 // lr: return address
190 // fp: caller's frame pointer
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000191 // sp: stack pointer
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000192 // r1: called JS function
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000193 // cp: callee's context
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000194 allocator_->Initialize();
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +0000195
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000196#ifdef DEBUG
197 if (strlen(FLAG_stop_at) > 0 &&
ager@chromium.org5c838252010-02-19 08:53:10 +0000198 info->function()->name()->IsEqualTo(CStrVector(FLAG_stop_at))) {
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000199 frame_->SpillAll();
kasper.lund7276f142008-07-30 08:49:36 +0000200 __ stop("stop-at");
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000201 }
202#endif
203
ager@chromium.orgea4f62e2010-08-16 16:28:43 +0000204 frame_->Enter();
205 // tos: code slot
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +0000206
ager@chromium.orgea4f62e2010-08-16 16:28:43 +0000207 // Allocate space for locals and initialize them. This also checks
208 // for stack overflow.
209 frame_->AllocateStackSlots();
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +0000210
ager@chromium.orgea4f62e2010-08-16 16:28:43 +0000211 frame_->AssertIsSpilled();
ager@chromium.org0ee099b2011-01-25 14:06:47 +0000212 int heap_slots = scope()->num_heap_slots() - Context::MIN_CONTEXT_SLOTS;
ager@chromium.orgea4f62e2010-08-16 16:28:43 +0000213 if (heap_slots > 0) {
214 // Allocate local context.
215 // Get outer context and create a new context based on it.
216 __ ldr(r0, frame_->Function());
217 frame_->EmitPush(r0);
218 if (heap_slots <= FastNewContextStub::kMaximumSlots) {
219 FastNewContextStub stub(heap_slots);
220 frame_->CallStub(&stub, 1);
221 } else {
222 frame_->CallRuntime(Runtime::kNewContext, 1);
223 }
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +0000224
225#ifdef DEBUG
ager@chromium.orgea4f62e2010-08-16 16:28:43 +0000226 JumpTarget verified_true;
227 __ cmp(r0, cp);
228 verified_true.Branch(eq);
229 __ stop("NewContext: r0 is expected to be the same as cp");
230 verified_true.Bind();
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +0000231#endif
ager@chromium.orgea4f62e2010-08-16 16:28:43 +0000232 // Update context local.
233 __ str(cp, frame_->Context());
234 }
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +0000235
ager@chromium.orgea4f62e2010-08-16 16:28:43 +0000236 // TODO(1241774): Improve this code:
237 // 1) only needed if we have a context
238 // 2) no need to recompute context ptr every single time
239 // 3) don't copy parameter operand code from SlotOperand!
240 {
241 Comment cmnt2(masm_, "[ copy context parameters into .context");
242 // Note that iteration order is relevant here! If we have the same
243 // parameter twice (e.g., function (x, y, x)), and that parameter
244 // needs to be copied into the context, it must be the last argument
245 // passed to the parameter that needs to be copied. This is a rare
246 // case so we don't check for it, instead we rely on the copying
247 // order: such a parameter is copied repeatedly into the same
248 // context location and thus the last value is what is seen inside
249 // the function.
250 frame_->AssertIsSpilled();
251 for (int i = 0; i < scope()->num_parameters(); i++) {
252 Variable* par = scope()->parameter(i);
whesse@chromium.org4a1fe7d2010-09-27 12:32:04 +0000253 Slot* slot = par->AsSlot();
ager@chromium.orgea4f62e2010-08-16 16:28:43 +0000254 if (slot != NULL && slot->type() == Slot::CONTEXT) {
255 ASSERT(!scope()->is_global_scope()); // No params in global scope.
256 __ ldr(r1, frame_->ParameterAt(i));
257 // Loads r2 with context; used below in RecordWrite.
258 __ str(r1, SlotOperand(slot, r2));
259 // Load the offset into r3.
260 int slot_offset =
261 FixedArray::kHeaderSize + slot->index() * kPointerSize;
262 __ RecordWrite(r2, Operand(slot_offset), r3, r1);
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +0000263 }
264 }
ager@chromium.orgea4f62e2010-08-16 16:28:43 +0000265 }
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +0000266
ager@chromium.orgea4f62e2010-08-16 16:28:43 +0000267 // Store the arguments object. This must happen after context
268 // initialization because the arguments object may be stored in
269 // the context.
270 if (ArgumentsMode() != NO_ARGUMENTS_ALLOCATION) {
271 StoreArgumentsObject(true);
272 }
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +0000273
ager@chromium.orgea4f62e2010-08-16 16:28:43 +0000274 // Initialize ThisFunction reference if present.
275 if (scope()->is_function_scope() && scope()->function() != NULL) {
276 frame_->EmitPushRoot(Heap::kTheHoleValueRootIndex);
whesse@chromium.org4a1fe7d2010-09-27 12:32:04 +0000277 StoreToSlot(scope()->function()->AsSlot(), NOT_CONST_INIT);
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +0000278 }
279
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000280 // Initialize the function return target after the locals are set
281 // up, because it needs the expected frame height from the frame.
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +0000282 function_return_.SetExpectedHeight();
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000283 function_return_is_shadowed_ = false;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000284
ager@chromium.org3bf7b912008-11-17 09:09:45 +0000285 // Generate code to 'execute' declarations and initialize functions
286 // (source elements). In case of an illegal redeclaration we need to
287 // handle that instead of processing the declarations.
ager@chromium.org5c838252010-02-19 08:53:10 +0000288 if (scope()->HasIllegalRedeclaration()) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000289 Comment cmnt(masm_, "[ illegal redeclarations");
ager@chromium.org5c838252010-02-19 08:53:10 +0000290 scope()->VisitIllegalRedeclaration(this);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000291 } else {
292 Comment cmnt(masm_, "[ declarations");
ager@chromium.org5c838252010-02-19 08:53:10 +0000293 ProcessDeclarations(scope()->declarations());
ager@chromium.org3bf7b912008-11-17 09:09:45 +0000294 // Bail out if a stack-overflow exception occurred when processing
295 // declarations.
kasper.lund212ac232008-07-16 07:07:30 +0000296 if (HasStackOverflow()) return;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000297 }
298
mads.s.ager31e71382008-08-13 09:32:07 +0000299 if (FLAG_trace) {
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000300 frame_->CallRuntime(Runtime::kTraceEnter, 0);
ager@chromium.org3bf7b912008-11-17 09:09:45 +0000301 // Ignore the return value.
mads.s.ager31e71382008-08-13 09:32:07 +0000302 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000303
304 // Compile the body of the function in a vanilla state. Don't
305 // bother compiling all the code if the scope has an illegal
306 // redeclaration.
ager@chromium.org5c838252010-02-19 08:53:10 +0000307 if (!scope()->HasIllegalRedeclaration()) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000308 Comment cmnt(masm_, "[ function body");
309#ifdef DEBUG
310 bool is_builtin = Bootstrapper::IsActive();
311 bool should_trace =
312 is_builtin ? FLAG_trace_builtin_calls : FLAG_trace_calls;
mads.s.ager31e71382008-08-13 09:32:07 +0000313 if (should_trace) {
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000314 frame_->CallRuntime(Runtime::kDebugTrace, 0);
ager@chromium.org3bf7b912008-11-17 09:09:45 +0000315 // Ignore the return value.
mads.s.ager31e71382008-08-13 09:32:07 +0000316 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000317#endif
ricow@chromium.org30ce4112010-05-31 10:38:25 +0000318 VisitStatements(info->function()->body());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000319 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000320 }
321
whesse@chromium.org2c186ca2010-06-16 11:32:39 +0000322 // Handle the return from the function.
323 if (has_valid_frame()) {
324 // If there is a valid frame, control flow can fall off the end of
325 // the body. In that case there is an implicit return statement.
326 ASSERT(!function_return_is_shadowed_);
327 frame_->PrepareForReturn();
ager@chromium.orgab99eea2009-08-25 07:05:41 +0000328 __ LoadRoot(r0, Heap::kUndefinedValueRootIndex);
whesse@chromium.org2c186ca2010-06-16 11:32:39 +0000329 if (function_return_.is_bound()) {
330 function_return_.Jump();
331 } else {
332 function_return_.Bind();
333 GenerateReturnSequence();
334 }
335 } else if (function_return_.is_linked()) {
336 // If the return target has dangling jumps to it, then we have not
337 // yet generated the return sequence. This can happen when (a)
338 // control does not flow off the end of the body so we did not
339 // compile an artificial return statement just above, and (b) there
340 // are return statements in the body but (c) they are all shadowed.
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000341 function_return_.Bind();
whesse@chromium.org2c186ca2010-06-16 11:32:39 +0000342 GenerateReturnSequence();
mads.s.ager31e71382008-08-13 09:32:07 +0000343 }
344
ricow@chromium.orgc9c80822010-04-21 08:22:37 +0000345 // Adjust for function-level loop nesting.
ager@chromium.orgb61a0d12010-10-13 08:35:23 +0000346 ASSERT(loop_nesting_ == info->is_in_loop()? 1 : 0);
ricow@chromium.orgc9c80822010-04-21 08:22:37 +0000347 loop_nesting_ = 0;
348
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000349 // Code generation state must be reset.
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000350 ASSERT(!has_cc());
351 ASSERT(state_ == NULL);
fschneider@chromium.org013f3e12010-04-26 13:27:52 +0000352 ASSERT(loop_nesting() == 0);
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000353 ASSERT(!function_return_is_shadowed_);
354 function_return_.Unuse();
355 DeleteFrame();
356
357 // Process any deferred code using the register allocator.
sgjesse@chromium.org755c5b12009-05-29 11:04:38 +0000358 if (!HasStackOverflow()) {
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000359 ProcessDeferred();
360 }
361
362 allocator_ = NULL;
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +0000363 type_info_ = NULL;
364}
365
366
367int CodeGenerator::NumberOfSlot(Slot* slot) {
368 if (slot == NULL) return kInvalidSlotNumber;
369 switch (slot->type()) {
370 case Slot::PARAMETER:
371 return slot->index();
372 case Slot::LOCAL:
373 return slot->index() + scope()->num_parameters();
374 default:
375 break;
376 }
377 return kInvalidSlotNumber;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000378}
379
380
ager@chromium.org7c537e22008-10-16 08:43:32 +0000381MemOperand CodeGenerator::SlotOperand(Slot* slot, Register tmp) {
382 // Currently, this assertion will fail if we try to assign to
383 // a constant variable that is constant because it is read-only
384 // (such as the variable referring to a named function expression).
385 // We need to implement assignments to read-only variables.
386 // Ideally, we should do this during AST generation (by converting
387 // such assignments into expression statements); however, in general
388 // we may not be able to make the decision until past AST generation,
389 // that is when the entire program is known.
390 ASSERT(slot != NULL);
391 int index = slot->index();
392 switch (slot->type()) {
393 case Slot::PARAMETER:
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000394 return frame_->ParameterAt(index);
ager@chromium.org7c537e22008-10-16 08:43:32 +0000395
ager@chromium.org3bf7b912008-11-17 09:09:45 +0000396 case Slot::LOCAL:
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000397 return frame_->LocalAt(index);
ager@chromium.org7c537e22008-10-16 08:43:32 +0000398
399 case Slot::CONTEXT: {
400 // Follow the context chain if necessary.
401 ASSERT(!tmp.is(cp)); // do not overwrite context register
402 Register context = cp;
403 int chain_length = scope()->ContextChainLength(slot->var()->scope());
ager@chromium.org381abbb2009-02-25 13:23:22 +0000404 for (int i = 0; i < chain_length; i++) {
ager@chromium.org7c537e22008-10-16 08:43:32 +0000405 // Load the closure.
406 // (All contexts, even 'with' contexts, have a closure,
407 // and it is the same for all contexts inside a function.
408 // There is no need to go to the function context first.)
409 __ ldr(tmp, ContextOperand(context, Context::CLOSURE_INDEX));
410 // Load the function context (which is the incoming, outer context).
411 __ ldr(tmp, FieldMemOperand(tmp, JSFunction::kContextOffset));
412 context = tmp;
413 }
414 // We may have a 'with' context now. Get the function context.
415 // (In fact this mov may never be the needed, since the scope analysis
416 // may not permit a direct context access in this case and thus we are
417 // always at a function context. However it is safe to dereference be-
418 // cause the function context of a function context is itself. Before
419 // deleting this mov we should try to create a counter-example first,
420 // though...)
421 __ ldr(tmp, ContextOperand(context, Context::FCONTEXT_INDEX));
422 return ContextOperand(tmp, index);
423 }
424
425 default:
426 UNREACHABLE();
427 return MemOperand(r0, 0);
428 }
429}
430
431
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000432MemOperand CodeGenerator::ContextSlotOperandCheckExtensions(
433 Slot* slot,
434 Register tmp,
435 Register tmp2,
436 JumpTarget* slow) {
ager@chromium.org381abbb2009-02-25 13:23:22 +0000437 ASSERT(slot->type() == Slot::CONTEXT);
ager@chromium.org381abbb2009-02-25 13:23:22 +0000438 Register context = cp;
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000439
ager@chromium.org381abbb2009-02-25 13:23:22 +0000440 for (Scope* s = scope(); s != slot->var()->scope(); s = s->outer_scope()) {
441 if (s->num_heap_slots() > 0) {
442 if (s->calls_eval()) {
443 // Check that extension is NULL.
444 __ ldr(tmp2, ContextOperand(context, Context::EXTENSION_INDEX));
445 __ tst(tmp2, tmp2);
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000446 slow->Branch(ne);
ager@chromium.org381abbb2009-02-25 13:23:22 +0000447 }
448 __ ldr(tmp, ContextOperand(context, Context::CLOSURE_INDEX));
449 __ ldr(tmp, FieldMemOperand(tmp, JSFunction::kContextOffset));
450 context = tmp;
451 }
452 }
453 // Check that last extension is NULL.
454 __ ldr(tmp2, ContextOperand(context, Context::EXTENSION_INDEX));
455 __ tst(tmp2, tmp2);
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000456 slow->Branch(ne);
ager@chromium.org381abbb2009-02-25 13:23:22 +0000457 __ ldr(tmp, ContextOperand(context, Context::FCONTEXT_INDEX));
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000458 return ContextOperand(tmp, slot->index());
ager@chromium.org381abbb2009-02-25 13:23:22 +0000459}
460
461
ager@chromium.org3bf7b912008-11-17 09:09:45 +0000462// Loads a value on TOS. If it is a boolean value, the result may have been
463// (partially) translated into branches, or it may have set the condition
464// code register. If force_cc is set, the value is forced to set the
465// condition code register and no value is pushed. If the condition code
466// register was set, has_cc() is true and cc_reg_ contains the condition to
467// test for 'true'.
ager@chromium.org7c537e22008-10-16 08:43:32 +0000468void CodeGenerator::LoadCondition(Expression* x,
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000469 JumpTarget* true_target,
470 JumpTarget* false_target,
ager@chromium.org3bf7b912008-11-17 09:09:45 +0000471 bool force_cc) {
ager@chromium.org7c537e22008-10-16 08:43:32 +0000472 ASSERT(!has_cc());
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000473 int original_height = frame_->height();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000474
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +0000475 { ConditionCodeGenState new_state(this, true_target, false_target);
kasperl@chromium.orgb9123622008-09-17 14:05:56 +0000476 Visit(x);
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000477
478 // If we hit a stack overflow, we may not have actually visited
479 // the expression. In that case, we ensure that we have a
480 // valid-looking frame state because we will continue to generate
481 // code as we unwind the C++ stack.
482 //
483 // It's possible to have both a stack overflow and a valid frame
484 // state (eg, a subexpression overflowed, visiting it returned
485 // with a dummied frame state, and visiting this expression
486 // returned with a normal-looking state).
487 if (HasStackOverflow() &&
488 has_valid_frame() &&
489 !has_cc() &&
490 frame_->height() == original_height) {
491 true_target->Jump();
492 }
kasperl@chromium.orgb9123622008-09-17 14:05:56 +0000493 }
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000494 if (force_cc && frame_ != NULL && !has_cc()) {
mads.s.ager31e71382008-08-13 09:32:07 +0000495 // Convert the TOS value to a boolean in the condition code register.
496 ToBoolean(true_target, false_target);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000497 }
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000498 ASSERT(!force_cc || !has_valid_frame() || has_cc());
499 ASSERT(!has_valid_frame() ||
500 (has_cc() && frame_->height() == original_height) ||
501 (!has_cc() && frame_->height() == original_height + 1));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000502}
503
504
ager@chromium.orgc4c92722009-11-18 14:12:51 +0000505void CodeGenerator::Load(Expression* expr) {
ager@chromium.orgea4f62e2010-08-16 16:28:43 +0000506 // We generally assume that we are not in a spilled scope for most
507 // of the code generator. A failure to ensure this caused issue 815
508 // and this assert is designed to catch similar issues.
509 frame_->AssertIsNotSpilled();
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000510#ifdef DEBUG
511 int original_height = frame_->height();
512#endif
kasperl@chromium.org71affb52009-05-26 05:44:31 +0000513 JumpTarget true_target;
514 JumpTarget false_target;
ager@chromium.orgc4c92722009-11-18 14:12:51 +0000515 LoadCondition(expr, &true_target, &false_target, false);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000516
517 if (has_cc()) {
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000518 // Convert cc_reg_ into a boolean value.
kasperl@chromium.org71affb52009-05-26 05:44:31 +0000519 JumpTarget loaded;
520 JumpTarget materialize_true;
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000521 materialize_true.Branch(cc_reg_);
fschneider@chromium.org40b9da32010-06-28 11:29:21 +0000522 frame_->EmitPushRoot(Heap::kFalseValueRootIndex);
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000523 loaded.Jump();
524 materialize_true.Bind();
fschneider@chromium.org40b9da32010-06-28 11:29:21 +0000525 frame_->EmitPushRoot(Heap::kTrueValueRootIndex);
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000526 loaded.Bind();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000527 cc_reg_ = al;
528 }
529
530 if (true_target.is_linked() || false_target.is_linked()) {
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000531 // We have at least one condition value that has been "translated"
532 // into a branch, thus it needs to be loaded explicitly.
kasperl@chromium.org71affb52009-05-26 05:44:31 +0000533 JumpTarget loaded;
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000534 if (frame_ != NULL) {
535 loaded.Jump(); // Don't lose the current TOS.
536 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000537 bool both = true_target.is_linked() && false_target.is_linked();
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000538 // Load "true" if necessary.
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000539 if (true_target.is_linked()) {
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000540 true_target.Bind();
fschneider@chromium.org40b9da32010-06-28 11:29:21 +0000541 frame_->EmitPushRoot(Heap::kTrueValueRootIndex);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000542 }
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000543 // If both "true" and "false" need to be loaded jump across the code for
544 // "false".
545 if (both) {
546 loaded.Jump();
547 }
548 // Load "false" if necessary.
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000549 if (false_target.is_linked()) {
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000550 false_target.Bind();
fschneider@chromium.org40b9da32010-06-28 11:29:21 +0000551 frame_->EmitPushRoot(Heap::kFalseValueRootIndex);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000552 }
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000553 // A value is loaded on all paths reaching this point.
554 loaded.Bind();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000555 }
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000556 ASSERT(has_valid_frame());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000557 ASSERT(!has_cc());
ager@chromium.orgac091b72010-05-05 07:34:42 +0000558 ASSERT_EQ(original_height + 1, frame_->height());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000559}
560
561
ager@chromium.org7c537e22008-10-16 08:43:32 +0000562void CodeGenerator::LoadGlobal() {
lrn@chromium.orgc34f5802010-04-28 12:53:43 +0000563 Register reg = frame_->GetTOSRegister();
erik.corry@gmail.com4a6c3272010-11-18 12:04:40 +0000564 __ ldr(reg, GlobalObjectOperand());
lrn@chromium.orgc34f5802010-04-28 12:53:43 +0000565 frame_->EmitPush(reg);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000566}
567
568
ager@chromium.org3bf7b912008-11-17 09:09:45 +0000569void CodeGenerator::LoadGlobalReceiver(Register scratch) {
fschneider@chromium.org40b9da32010-06-28 11:29:21 +0000570 Register reg = frame_->GetTOSRegister();
571 __ ldr(reg, ContextOperand(cp, Context::GLOBAL_INDEX));
572 __ ldr(reg,
573 FieldMemOperand(reg, GlobalObject::kGlobalReceiverOffset));
574 frame_->EmitPush(reg);
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000575}
576
577
fschneider@chromium.org013f3e12010-04-26 13:27:52 +0000578ArgumentsAllocationMode CodeGenerator::ArgumentsMode() {
579 if (scope()->arguments() == NULL) return NO_ARGUMENTS_ALLOCATION;
580 ASSERT(scope()->arguments_shadow() != NULL);
581 // We don't want to do lazy arguments allocation for functions that
582 // have heap-allocated contexts, because it interfers with the
583 // uninitialized const tracking in the context objects.
584 return (scope()->num_heap_slots() > 0)
585 ? EAGER_ARGUMENTS_ALLOCATION
586 : LAZY_ARGUMENTS_ALLOCATION;
587}
588
589
590void CodeGenerator::StoreArgumentsObject(bool initial) {
fschneider@chromium.org013f3e12010-04-26 13:27:52 +0000591 ArgumentsAllocationMode mode = ArgumentsMode();
592 ASSERT(mode != NO_ARGUMENTS_ALLOCATION);
593
594 Comment cmnt(masm_, "[ store arguments object");
595 if (mode == LAZY_ARGUMENTS_ALLOCATION && initial) {
596 // When using lazy arguments allocation, we store the hole value
597 // as a sentinel indicating that the arguments object hasn't been
598 // allocated yet.
kmillikin@chromium.orgd2c22f02011-01-10 08:15:37 +0000599 frame_->EmitPushRoot(Heap::kArgumentsMarkerRootIndex);
fschneider@chromium.org013f3e12010-04-26 13:27:52 +0000600 } else {
fschneider@chromium.org40b9da32010-06-28 11:29:21 +0000601 frame_->SpillAll();
fschneider@chromium.org013f3e12010-04-26 13:27:52 +0000602 ArgumentsAccessStub stub(ArgumentsAccessStub::NEW_OBJECT);
603 __ ldr(r2, frame_->Function());
604 // The receiver is below the arguments, the return address, and the
605 // frame pointer on the stack.
606 const int kReceiverDisplacement = 2 + scope()->num_parameters();
607 __ add(r1, fp, Operand(kReceiverDisplacement * kPointerSize));
608 __ mov(r0, Operand(Smi::FromInt(scope()->num_parameters())));
609 frame_->Adjust(3);
lrn@chromium.orgc34f5802010-04-28 12:53:43 +0000610 __ Push(r2, r1, r0);
fschneider@chromium.org013f3e12010-04-26 13:27:52 +0000611 frame_->CallStub(&stub, 3);
612 frame_->EmitPush(r0);
613 }
614
whesse@chromium.org4a1fe7d2010-09-27 12:32:04 +0000615 Variable* arguments = scope()->arguments();
616 Variable* shadow = scope()->arguments_shadow();
617 ASSERT(arguments != NULL && arguments->AsSlot() != NULL);
618 ASSERT(shadow != NULL && shadow->AsSlot() != NULL);
fschneider@chromium.org013f3e12010-04-26 13:27:52 +0000619 JumpTarget done;
620 if (mode == LAZY_ARGUMENTS_ALLOCATION && !initial) {
621 // We have to skip storing into the arguments slot if it has
622 // already been written to. This can happen if the a function
623 // has a local variable named 'arguments'.
whesse@chromium.org4a1fe7d2010-09-27 12:32:04 +0000624 LoadFromSlot(scope()->arguments()->AsSlot(), NOT_INSIDE_TYPEOF);
fschneider@chromium.org40b9da32010-06-28 11:29:21 +0000625 Register arguments = frame_->PopToRegister();
kmillikin@chromium.orgd2c22f02011-01-10 08:15:37 +0000626 __ LoadRoot(ip, Heap::kArgumentsMarkerRootIndex);
fschneider@chromium.org40b9da32010-06-28 11:29:21 +0000627 __ cmp(arguments, ip);
fschneider@chromium.org013f3e12010-04-26 13:27:52 +0000628 done.Branch(ne);
629 }
whesse@chromium.org4a1fe7d2010-09-27 12:32:04 +0000630 StoreToSlot(arguments->AsSlot(), NOT_CONST_INIT);
fschneider@chromium.org013f3e12010-04-26 13:27:52 +0000631 if (mode == LAZY_ARGUMENTS_ALLOCATION) done.Bind();
whesse@chromium.org4a1fe7d2010-09-27 12:32:04 +0000632 StoreToSlot(shadow->AsSlot(), NOT_CONST_INIT);
fschneider@chromium.org013f3e12010-04-26 13:27:52 +0000633}
634
635
ager@chromium.orgc4c92722009-11-18 14:12:51 +0000636void CodeGenerator::LoadTypeofExpression(Expression* expr) {
637 // Special handling of identifiers as subexpressions of typeof.
ager@chromium.orgc4c92722009-11-18 14:12:51 +0000638 Variable* variable = expr->AsVariableProxy()->AsVariable();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000639 if (variable != NULL && !variable->is_this() && variable->is_global()) {
ager@chromium.orgc4c92722009-11-18 14:12:51 +0000640 // For a global variable we build the property reference
641 // <global>.<variable> and perform a (regular non-contextual) property
642 // load to make sure we do not get reference errors.
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000643 Slot global(variable, Slot::CONTEXT, Context::GLOBAL_INDEX);
644 Literal key(variable->name());
ager@chromium.org236ad962008-09-25 09:45:57 +0000645 Property property(&global, &key, RelocInfo::kNoPosition);
ager@chromium.orgc4c92722009-11-18 14:12:51 +0000646 Reference ref(this, &property);
ager@chromium.org357bf652010-04-12 11:30:10 +0000647 ref.GetValue();
whesse@chromium.org4a1fe7d2010-09-27 12:32:04 +0000648 } else if (variable != NULL && variable->AsSlot() != NULL) {
ager@chromium.orgc4c92722009-11-18 14:12:51 +0000649 // For a variable that rewrites to a slot, we signal it is the immediate
650 // subexpression of a typeof.
whesse@chromium.org4a1fe7d2010-09-27 12:32:04 +0000651 LoadFromSlotCheckForArguments(variable->AsSlot(), INSIDE_TYPEOF);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000652 } else {
ager@chromium.orgc4c92722009-11-18 14:12:51 +0000653 // Anything else can be handled normally.
ricow@chromium.org30ce4112010-05-31 10:38:25 +0000654 Load(expr);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000655 }
656}
657
658
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +0000659Reference::Reference(CodeGenerator* cgen,
660 Expression* expression,
661 bool persist_after_get)
662 : cgen_(cgen),
663 expression_(expression),
664 type_(ILLEGAL),
665 persist_after_get_(persist_after_get) {
ager@chromium.orgea4f62e2010-08-16 16:28:43 +0000666 // We generally assume that we are not in a spilled scope for most
667 // of the code generator. A failure to ensure this caused issue 815
668 // and this assert is designed to catch similar issues.
669 cgen->frame()->AssertIsNotSpilled();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000670 cgen->LoadReference(this);
671}
672
673
674Reference::~Reference() {
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +0000675 ASSERT(is_unloaded() || is_illegal());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000676}
677
678
ager@chromium.org7c537e22008-10-16 08:43:32 +0000679void CodeGenerator::LoadReference(Reference* ref) {
680 Comment cmnt(masm_, "[ LoadReference");
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000681 Expression* e = ref->expression();
682 Property* property = e->AsProperty();
683 Variable* var = e->AsVariableProxy()->AsVariable();
684
685 if (property != NULL) {
ager@chromium.org7c537e22008-10-16 08:43:32 +0000686 // The expression is either a property or a variable proxy that rewrites
687 // to a property.
lrn@chromium.orgc34f5802010-04-28 12:53:43 +0000688 Load(property->obj());
fschneider@chromium.org0c20e672010-01-14 15:28:53 +0000689 if (property->key()->IsPropertyName()) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000690 ref->set_type(Reference::NAMED);
691 } else {
lrn@chromium.orgc34f5802010-04-28 12:53:43 +0000692 Load(property->key());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000693 ref->set_type(Reference::KEYED);
694 }
695 } else if (var != NULL) {
ager@chromium.org7c537e22008-10-16 08:43:32 +0000696 // The expression is a variable proxy that does not rewrite to a
697 // property. Global variables are treated as named property references.
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000698 if (var->is_global()) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000699 LoadGlobal();
700 ref->set_type(Reference::NAMED);
701 } else {
whesse@chromium.org4a1fe7d2010-09-27 12:32:04 +0000702 ASSERT(var->AsSlot() != NULL);
ager@chromium.org7c537e22008-10-16 08:43:32 +0000703 ref->set_type(Reference::SLOT);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000704 }
705 } else {
ager@chromium.org7c537e22008-10-16 08:43:32 +0000706 // Anything else is a runtime error.
ricow@chromium.org30ce4112010-05-31 10:38:25 +0000707 Load(e);
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000708 frame_->CallRuntime(Runtime::kThrowReferenceError, 1);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000709 }
710}
711
712
ager@chromium.org7c537e22008-10-16 08:43:32 +0000713void CodeGenerator::UnloadReference(Reference* ref) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000714 int size = ref->size();
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +0000715 ref->set_unloaded();
ager@chromium.org357bf652010-04-12 11:30:10 +0000716 if (size == 0) return;
717
718 // Pop a reference from the stack while preserving TOS.
719 VirtualFrame::RegisterAllocationScope scope(this);
720 Comment cmnt(masm_, "[ UnloadReference");
721 if (size > 0) {
722 Register tos = frame_->PopToRegister();
723 frame_->Drop(size);
724 frame_->EmitPush(tos);
725 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000726}
727
728
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000729// ECMA-262, section 9.2, page 30: ToBoolean(). Convert the given
730// register to a boolean in the condition code register. The code
731// may jump to 'false_target' in case the register converts to 'false'.
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000732void CodeGenerator::ToBoolean(JumpTarget* true_target,
733 JumpTarget* false_target) {
mads.s.ager31e71382008-08-13 09:32:07 +0000734 // Note: The generated code snippet does not change stack variables.
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000735 // Only the condition code should be set.
kmillikin@chromium.org69ea3962010-07-05 11:01:40 +0000736 bool known_smi = frame_->KnownSmiAt(0);
fschneider@chromium.org40b9da32010-06-28 11:29:21 +0000737 Register tos = frame_->PopToRegister();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000738
739 // Fast case checks
740
mads.s.ager31e71382008-08-13 09:32:07 +0000741 // Check if the value is 'false'.
kmillikin@chromium.org69ea3962010-07-05 11:01:40 +0000742 if (!known_smi) {
743 __ LoadRoot(ip, Heap::kFalseValueRootIndex);
744 __ cmp(tos, ip);
745 false_target->Branch(eq);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000746
kmillikin@chromium.org69ea3962010-07-05 11:01:40 +0000747 // Check if the value is 'true'.
748 __ LoadRoot(ip, Heap::kTrueValueRootIndex);
749 __ cmp(tos, ip);
750 true_target->Branch(eq);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000751
kmillikin@chromium.org69ea3962010-07-05 11:01:40 +0000752 // Check if the value is 'undefined'.
753 __ LoadRoot(ip, Heap::kUndefinedValueRootIndex);
754 __ cmp(tos, ip);
755 false_target->Branch(eq);
756 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000757
mads.s.ager31e71382008-08-13 09:32:07 +0000758 // Check if the value is a smi.
fschneider@chromium.org40b9da32010-06-28 11:29:21 +0000759 __ cmp(tos, Operand(Smi::FromInt(0)));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000760
kmillikin@chromium.org69ea3962010-07-05 11:01:40 +0000761 if (!known_smi) {
762 false_target->Branch(eq);
763 __ tst(tos, Operand(kSmiTagMask));
764 true_target->Branch(eq);
765
ager@chromium.orgea4f62e2010-08-16 16:28:43 +0000766 // Slow case.
767 if (CpuFeatures::IsSupported(VFP3)) {
768 CpuFeatures::Scope scope(VFP3);
769 // Implements the slow case by using ToBooleanStub.
770 // The ToBooleanStub takes a single argument, and
771 // returns a non-zero value for true, or zero for false.
772 // Both the argument value and the return value use the
773 // register assigned to tos_
774 ToBooleanStub stub(tos);
775 frame_->CallStub(&stub, 0);
776 // Convert the result in "tos" to a condition code.
ager@chromium.org5b2fbee2010-09-08 06:38:15 +0000777 __ cmp(tos, Operand(0, RelocInfo::NONE));
ager@chromium.orgea4f62e2010-08-16 16:28:43 +0000778 } else {
779 // Implements slow case by calling the runtime.
780 frame_->EmitPush(tos);
781 frame_->CallRuntime(Runtime::kToBool, 1);
782 // Convert the result (r0) to a condition code.
783 __ LoadRoot(ip, Heap::kFalseValueRootIndex);
784 __ cmp(r0, ip);
785 }
kmillikin@chromium.org69ea3962010-07-05 11:01:40 +0000786 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000787
788 cc_reg_ = ne;
789}
790
791
ager@chromium.org65dad4b2009-04-23 08:48:43 +0000792void CodeGenerator::GenericBinaryOperation(Token::Value op,
kasperl@chromium.org86f77b72009-07-06 08:21:57 +0000793 OverwriteMode overwrite_mode,
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +0000794 GenerateInlineSmi inline_smi,
kasperl@chromium.org86f77b72009-07-06 08:21:57 +0000795 int constant_rhs) {
ager@chromium.org357bf652010-04-12 11:30:10 +0000796 // top of virtual frame: y
797 // 2nd elt. on virtual frame : x
798 // result : top of virtual frame
799
800 // Stub is entered with a call: 'return address' is in lr.
801 switch (op) {
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +0000802 case Token::ADD:
803 case Token::SUB:
804 if (inline_smi) {
805 JumpTarget done;
806 Register rhs = frame_->PopToRegister();
807 Register lhs = frame_->PopToRegister(rhs);
808 Register scratch = VirtualFrame::scratch0();
809 __ orr(scratch, rhs, Operand(lhs));
810 // Check they are both small and positive.
811 __ tst(scratch, Operand(kSmiTagMask | 0xc0000000));
812 ASSERT(rhs.is(r0) || lhs.is(r0)); // r0 is free now.
whesse@chromium.orgba5a61b2010-07-26 11:44:40 +0000813 STATIC_ASSERT(kSmiTag == 0);
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +0000814 if (op == Token::ADD) {
815 __ add(r0, lhs, Operand(rhs), LeaveCC, eq);
816 } else {
817 __ sub(r0, lhs, Operand(rhs), LeaveCC, eq);
818 }
819 done.Branch(eq);
820 GenericBinaryOpStub stub(op, overwrite_mode, lhs, rhs, constant_rhs);
821 frame_->SpillAll();
822 frame_->CallStub(&stub, 0);
823 done.Bind();
824 frame_->EmitPush(r0);
825 break;
826 } else {
827 // Fall through!
828 }
mads.s.ager@gmail.com9a4089a2008-09-01 08:55:01 +0000829 case Token::BIT_OR:
830 case Token::BIT_AND:
831 case Token::BIT_XOR:
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +0000832 if (inline_smi) {
833 bool rhs_is_smi = frame_->KnownSmiAt(0);
834 bool lhs_is_smi = frame_->KnownSmiAt(1);
835 Register rhs = frame_->PopToRegister();
836 Register lhs = frame_->PopToRegister(rhs);
837 Register smi_test_reg;
838 Condition cond;
839 if (!rhs_is_smi || !lhs_is_smi) {
840 if (rhs_is_smi) {
841 smi_test_reg = lhs;
842 } else if (lhs_is_smi) {
843 smi_test_reg = rhs;
844 } else {
845 smi_test_reg = VirtualFrame::scratch0();
846 __ orr(smi_test_reg, rhs, Operand(lhs));
847 }
848 // Check they are both Smis.
849 __ tst(smi_test_reg, Operand(kSmiTagMask));
850 cond = eq;
851 } else {
852 cond = al;
853 }
854 ASSERT(rhs.is(r0) || lhs.is(r0)); // r0 is free now.
855 if (op == Token::BIT_OR) {
856 __ orr(r0, lhs, Operand(rhs), LeaveCC, cond);
857 } else if (op == Token::BIT_AND) {
858 __ and_(r0, lhs, Operand(rhs), LeaveCC, cond);
859 } else {
860 ASSERT(op == Token::BIT_XOR);
whesse@chromium.orgba5a61b2010-07-26 11:44:40 +0000861 STATIC_ASSERT(kSmiTag == 0);
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +0000862 __ eor(r0, lhs, Operand(rhs), LeaveCC, cond);
863 }
864 if (cond != al) {
865 JumpTarget done;
866 done.Branch(cond);
867 GenericBinaryOpStub stub(op, overwrite_mode, lhs, rhs, constant_rhs);
868 frame_->SpillAll();
869 frame_->CallStub(&stub, 0);
870 done.Bind();
871 }
872 frame_->EmitPush(r0);
873 break;
874 } else {
875 // Fall through!
876 }
877 case Token::MUL:
878 case Token::DIV:
879 case Token::MOD:
mads.s.ager@gmail.com9a4089a2008-09-01 08:55:01 +0000880 case Token::SHL:
881 case Token::SHR:
882 case Token::SAR: {
ager@chromium.org357bf652010-04-12 11:30:10 +0000883 Register rhs = frame_->PopToRegister();
884 Register lhs = frame_->PopToRegister(rhs); // Don't pop to rhs register.
ricow@chromium.org30ce4112010-05-31 10:38:25 +0000885 GenericBinaryOpStub stub(op, overwrite_mode, lhs, rhs, constant_rhs);
886 frame_->SpillAll();
887 frame_->CallStub(&stub, 0);
ager@chromium.org357bf652010-04-12 11:30:10 +0000888 frame_->EmitPush(r0);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000889 break;
890 }
891
ager@chromium.org357bf652010-04-12 11:30:10 +0000892 case Token::COMMA: {
893 Register scratch = frame_->PopToRegister();
894 // Simply discard left value.
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000895 frame_->Drop();
ager@chromium.org357bf652010-04-12 11:30:10 +0000896 frame_->EmitPush(scratch);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000897 break;
ager@chromium.org357bf652010-04-12 11:30:10 +0000898 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000899
900 default:
901 // Other cases should have been handled before this point.
902 UNREACHABLE();
903 break;
904 }
905}
906
907
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000908class DeferredInlineSmiOperation: public DeferredCode {
mads.s.ager@gmail.com9a4089a2008-09-01 08:55:01 +0000909 public:
sgjesse@chromium.org755c5b12009-05-29 11:04:38 +0000910 DeferredInlineSmiOperation(Token::Value op,
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000911 int value,
ager@chromium.org65dad4b2009-04-23 08:48:43 +0000912 bool reversed,
ager@chromium.org357bf652010-04-12 11:30:10 +0000913 OverwriteMode overwrite_mode,
914 Register tos)
sgjesse@chromium.org755c5b12009-05-29 11:04:38 +0000915 : op_(op),
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000916 value_(value),
ager@chromium.org65dad4b2009-04-23 08:48:43 +0000917 reversed_(reversed),
ager@chromium.org357bf652010-04-12 11:30:10 +0000918 overwrite_mode_(overwrite_mode),
919 tos_register_(tos) {
mads.s.ager@gmail.com9a4089a2008-09-01 08:55:01 +0000920 set_comment("[ DeferredInlinedSmiOperation");
921 }
922
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000923 virtual void Generate();
kmillikin@chromium.org3cdd9e12010-09-06 11:39:48 +0000924 // This stub makes explicit calls to SaveRegisters(), RestoreRegisters() and
925 // Exit(). Currently on ARM SaveRegisters() and RestoreRegisters() are empty
926 // methods, it is the responsibility of the deferred code to save and restore
927 // registers.
928 virtual bool AutoSaveAndRestore() { return false; }
929
930 void JumpToNonSmiInput(Condition cond);
931 void JumpToAnswerOutOfRange(Condition cond);
mads.s.ager@gmail.com9a4089a2008-09-01 08:55:01 +0000932
933 private:
kmillikin@chromium.org3cdd9e12010-09-06 11:39:48 +0000934 void GenerateNonSmiInput();
935 void GenerateAnswerOutOfRange();
936 void WriteNonSmiAnswer(Register answer,
937 Register heap_number,
938 Register scratch);
939
mads.s.ager@gmail.com9a4089a2008-09-01 08:55:01 +0000940 Token::Value op_;
941 int value_;
942 bool reversed_;
ager@chromium.org65dad4b2009-04-23 08:48:43 +0000943 OverwriteMode overwrite_mode_;
ager@chromium.org357bf652010-04-12 11:30:10 +0000944 Register tos_register_;
kmillikin@chromium.org3cdd9e12010-09-06 11:39:48 +0000945 Label non_smi_input_;
946 Label answer_out_of_range_;
mads.s.ager@gmail.com9a4089a2008-09-01 08:55:01 +0000947};
948
949
kmillikin@chromium.org3cdd9e12010-09-06 11:39:48 +0000950// For bit operations we try harder and handle the case where the input is not
951// a Smi but a 32bits integer without calling the generic stub.
952void DeferredInlineSmiOperation::JumpToNonSmiInput(Condition cond) {
953 ASSERT(Token::IsBitOp(op_));
954
955 __ b(cond, &non_smi_input_);
956}
957
958
959// For bit operations the result is always 32bits so we handle the case where
960// the result does not fit in a Smi without calling the generic stub.
961void DeferredInlineSmiOperation::JumpToAnswerOutOfRange(Condition cond) {
962 ASSERT(Token::IsBitOp(op_));
963
964 if ((op_ == Token::SHR) && !CpuFeatures::IsSupported(VFP3)) {
965 // >>> requires an unsigned to double conversion and the non VFP code
966 // does not support this conversion.
967 __ b(cond, entry_label());
968 } else {
969 __ b(cond, &answer_out_of_range_);
970 }
971}
972
fschneider@chromium.org40b9da32010-06-28 11:29:21 +0000973
974// On entry the non-constant side of the binary operation is in tos_register_
975// and the constant smi side is nowhere. The tos_register_ is not used by the
976// virtual frame. On exit the answer is in the tos_register_ and the virtual
977// frame is unchanged.
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000978void DeferredInlineSmiOperation::Generate() {
fschneider@chromium.org40b9da32010-06-28 11:29:21 +0000979 VirtualFrame copied_frame(*frame_state()->frame());
980 copied_frame.SpillAll();
981
ager@chromium.org357bf652010-04-12 11:30:10 +0000982 Register lhs = r1;
983 Register rhs = r0;
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000984 switch (op_) {
985 case Token::ADD: {
ager@chromium.orge2902be2009-06-08 12:21:35 +0000986 // Revert optimistic add.
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000987 if (reversed_) {
ager@chromium.org357bf652010-04-12 11:30:10 +0000988 __ sub(r0, tos_register_, Operand(Smi::FromInt(value_)));
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000989 __ mov(r1, Operand(Smi::FromInt(value_)));
990 } else {
ager@chromium.org357bf652010-04-12 11:30:10 +0000991 __ sub(r1, tos_register_, Operand(Smi::FromInt(value_)));
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000992 __ mov(r0, Operand(Smi::FromInt(value_)));
993 }
994 break;
995 }
996
997 case Token::SUB: {
ager@chromium.orge2902be2009-06-08 12:21:35 +0000998 // Revert optimistic sub.
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000999 if (reversed_) {
ager@chromium.org357bf652010-04-12 11:30:10 +00001000 __ rsb(r0, tos_register_, Operand(Smi::FromInt(value_)));
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00001001 __ mov(r1, Operand(Smi::FromInt(value_)));
1002 } else {
ager@chromium.org357bf652010-04-12 11:30:10 +00001003 __ add(r1, tos_register_, Operand(Smi::FromInt(value_)));
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00001004 __ mov(r0, Operand(Smi::FromInt(value_)));
1005 }
1006 break;
1007 }
1008
kasperl@chromium.org86f77b72009-07-06 08:21:57 +00001009 // For these operations there is no optimistic operation that needs to be
1010 // reverted.
1011 case Token::MUL:
1012 case Token::MOD:
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00001013 case Token::BIT_OR:
1014 case Token::BIT_XOR:
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00001015 case Token::BIT_AND:
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00001016 case Token::SHL:
1017 case Token::SHR:
1018 case Token::SAR: {
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00001019 if (tos_register_.is(r1)) {
1020 __ mov(r0, Operand(Smi::FromInt(value_)));
1021 } else {
1022 ASSERT(tos_register_.is(r0));
1023 __ mov(r1, Operand(Smi::FromInt(value_)));
1024 }
1025 if (reversed_ == tos_register_.is(r1)) {
ager@chromium.org357bf652010-04-12 11:30:10 +00001026 lhs = r0;
1027 rhs = r1;
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00001028 }
1029 break;
1030 }
1031
1032 default:
ager@chromium.orge2902be2009-06-08 12:21:35 +00001033 // Other cases should have been handled before this point.
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00001034 UNREACHABLE();
1035 break;
1036 }
1037
ager@chromium.org357bf652010-04-12 11:30:10 +00001038 GenericBinaryOpStub stub(op_, overwrite_mode_, lhs, rhs, value_);
ager@chromium.orge2902be2009-06-08 12:21:35 +00001039 __ CallStub(&stub);
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00001040
ager@chromium.org357bf652010-04-12 11:30:10 +00001041 // The generic stub returns its value in r0, but that's not
1042 // necessarily what we want. We want whatever the inlined code
1043 // expected, which is that the answer is in the same register as
1044 // the operand was.
1045 __ Move(tos_register_, r0);
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00001046
1047 // The tos register was not in use for the virtual frame that we
1048 // came into this function with, so we can merge back to that frame
1049 // without trashing it.
1050 copied_frame.MergeTo(frame_state()->frame());
kmillikin@chromium.org3cdd9e12010-09-06 11:39:48 +00001051
1052 Exit();
1053
1054 if (non_smi_input_.is_linked()) {
1055 GenerateNonSmiInput();
1056 }
1057
1058 if (answer_out_of_range_.is_linked()) {
1059 GenerateAnswerOutOfRange();
1060 }
1061}
1062
1063
1064// Convert and write the integer answer into heap_number.
1065void DeferredInlineSmiOperation::WriteNonSmiAnswer(Register answer,
1066 Register heap_number,
1067 Register scratch) {
1068 if (CpuFeatures::IsSupported(VFP3)) {
1069 CpuFeatures::Scope scope(VFP3);
1070 __ vmov(s0, answer);
1071 if (op_ == Token::SHR) {
1072 __ vcvt_f64_u32(d0, s0);
1073 } else {
1074 __ vcvt_f64_s32(d0, s0);
1075 }
1076 __ sub(scratch, heap_number, Operand(kHeapObjectTag));
1077 __ vstr(d0, scratch, HeapNumber::kValueOffset);
1078 } else {
1079 WriteInt32ToHeapNumberStub stub(answer, heap_number, scratch);
1080 __ CallStub(&stub);
1081 }
1082}
1083
1084
1085void DeferredInlineSmiOperation::GenerateNonSmiInput() {
1086 // We know the left hand side is not a Smi and the right hand side is an
1087 // immediate value (value_) which can be represented as a Smi. We only
1088 // handle bit operations.
1089 ASSERT(Token::IsBitOp(op_));
1090
1091 if (FLAG_debug_code) {
1092 __ Abort("Should not fall through!");
1093 }
1094
1095 __ bind(&non_smi_input_);
1096 if (FLAG_debug_code) {
1097 __ AbortIfSmi(tos_register_);
1098 }
1099
1100 // This routine uses the registers from r2 to r6. At the moment they are
1101 // not used by the register allocator, but when they are it should use
1102 // SpillAll and MergeTo like DeferredInlineSmiOperation::Generate() above.
1103
1104 Register heap_number_map = r7;
1105 __ LoadRoot(heap_number_map, Heap::kHeapNumberMapRootIndex);
1106 __ ldr(r3, FieldMemOperand(tos_register_, HeapNumber::kMapOffset));
1107 __ cmp(r3, heap_number_map);
1108 // Not a number, fall back to the GenericBinaryOpStub.
1109 __ b(ne, entry_label());
1110
1111 Register int32 = r2;
1112 // Not a 32bits signed int, fall back to the GenericBinaryOpStub.
ricow@chromium.org83aa5492011-02-07 12:42:56 +00001113 __ ConvertToInt32(tos_register_, int32, r4, r5, d0, entry_label());
kmillikin@chromium.org3cdd9e12010-09-06 11:39:48 +00001114
1115 // tos_register_ (r0 or r1): Original heap number.
1116 // int32: signed 32bits int.
1117
1118 Label result_not_a_smi;
1119 int shift_value = value_ & 0x1f;
1120 switch (op_) {
1121 case Token::BIT_OR: __ orr(int32, int32, Operand(value_)); break;
1122 case Token::BIT_XOR: __ eor(int32, int32, Operand(value_)); break;
1123 case Token::BIT_AND: __ and_(int32, int32, Operand(value_)); break;
1124 case Token::SAR:
1125 ASSERT(!reversed_);
1126 if (shift_value != 0) {
1127 __ mov(int32, Operand(int32, ASR, shift_value));
1128 }
1129 break;
1130 case Token::SHR:
1131 ASSERT(!reversed_);
1132 if (shift_value != 0) {
1133 __ mov(int32, Operand(int32, LSR, shift_value), SetCC);
1134 } else {
1135 // SHR is special because it is required to produce a positive answer.
ager@chromium.org5b2fbee2010-09-08 06:38:15 +00001136 __ cmp(int32, Operand(0, RelocInfo::NONE));
kmillikin@chromium.org3cdd9e12010-09-06 11:39:48 +00001137 }
1138 if (CpuFeatures::IsSupported(VFP3)) {
1139 __ b(mi, &result_not_a_smi);
1140 } else {
1141 // Non VFP code cannot convert from unsigned to double, so fall back
1142 // to GenericBinaryOpStub.
1143 __ b(mi, entry_label());
1144 }
1145 break;
1146 case Token::SHL:
1147 ASSERT(!reversed_);
1148 if (shift_value != 0) {
1149 __ mov(int32, Operand(int32, LSL, shift_value));
1150 }
1151 break;
1152 default: UNREACHABLE();
1153 }
1154 // Check that the *signed* result fits in a smi. Not necessary for AND, SAR
1155 // if the shift if more than 0 or SHR if the shit is more than 1.
1156 if (!( (op_ == Token::AND) ||
1157 ((op_ == Token::SAR) && (shift_value > 0)) ||
1158 ((op_ == Token::SHR) && (shift_value > 1)))) {
1159 __ add(r3, int32, Operand(0x40000000), SetCC);
1160 __ b(mi, &result_not_a_smi);
1161 }
1162 __ mov(tos_register_, Operand(int32, LSL, kSmiTagSize));
1163 Exit();
1164
1165 if (result_not_a_smi.is_linked()) {
1166 __ bind(&result_not_a_smi);
1167 if (overwrite_mode_ != OVERWRITE_LEFT) {
1168 ASSERT((overwrite_mode_ == NO_OVERWRITE) ||
1169 (overwrite_mode_ == OVERWRITE_RIGHT));
1170 // If the allocation fails, fall back to the GenericBinaryOpStub.
1171 __ AllocateHeapNumber(r4, r5, r6, heap_number_map, entry_label());
1172 // Nothing can go wrong now, so overwrite tos.
1173 __ mov(tos_register_, Operand(r4));
1174 }
1175
1176 // int32: answer as signed 32bits integer.
1177 // tos_register_: Heap number to write the answer into.
1178 WriteNonSmiAnswer(int32, tos_register_, r3);
1179
1180 Exit();
1181 }
1182}
1183
1184
1185void DeferredInlineSmiOperation::GenerateAnswerOutOfRange() {
1186 // The input from a bitwise operation were Smis but the result cannot fit
lrn@chromium.org303ada72010-10-27 09:33:13 +00001187 // into a Smi, so we store it into a heap number. VirtualFrame::scratch0()
1188 // holds the untagged result to be converted. tos_register_ contains the
1189 // input. See the calls to JumpToAnswerOutOfRange to see how we got here.
kmillikin@chromium.org3cdd9e12010-09-06 11:39:48 +00001190 ASSERT(Token::IsBitOp(op_));
1191 ASSERT(!reversed_);
1192
lrn@chromium.org303ada72010-10-27 09:33:13 +00001193 Register untagged_result = VirtualFrame::scratch0();
1194
kmillikin@chromium.org3cdd9e12010-09-06 11:39:48 +00001195 if (FLAG_debug_code) {
1196 __ Abort("Should not fall through!");
1197 }
1198
1199 __ bind(&answer_out_of_range_);
1200 if (((value_ & 0x1f) == 0) && (op_ == Token::SHR)) {
lrn@chromium.org303ada72010-10-27 09:33:13 +00001201 // >>> 0 is a special case where the untagged_result register is not set up
1202 // yet. We untag the input to get it.
1203 __ mov(untagged_result, Operand(tos_register_, ASR, kSmiTagSize));
kmillikin@chromium.org3cdd9e12010-09-06 11:39:48 +00001204 }
1205
1206 // This routine uses the registers from r2 to r6. At the moment they are
1207 // not used by the register allocator, but when they are it should use
1208 // SpillAll and MergeTo like DeferredInlineSmiOperation::Generate() above.
1209
1210 // Allocate the result heap number.
lrn@chromium.org303ada72010-10-27 09:33:13 +00001211 Register heap_number_map = VirtualFrame::scratch1();
kmillikin@chromium.org3cdd9e12010-09-06 11:39:48 +00001212 Register heap_number = r4;
1213 __ LoadRoot(heap_number_map, Heap::kHeapNumberMapRootIndex);
1214 // If the allocation fails, fall back to the GenericBinaryOpStub.
1215 __ AllocateHeapNumber(heap_number, r5, r6, heap_number_map, entry_label());
lrn@chromium.org303ada72010-10-27 09:33:13 +00001216 WriteNonSmiAnswer(untagged_result, heap_number, r3);
kmillikin@chromium.org3cdd9e12010-09-06 11:39:48 +00001217 __ mov(tos_register_, Operand(heap_number));
1218
1219 Exit();
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00001220}
1221
1222
kasperl@chromium.org86f77b72009-07-06 08:21:57 +00001223static bool PopCountLessThanEqual2(unsigned int x) {
1224 x &= x - 1;
1225 return (x & (x - 1)) == 0;
1226}
1227
1228
1229// Returns the index of the lowest bit set.
1230static int BitPosition(unsigned x) {
1231 int bit_posn = 0;
1232 while ((x & 0xf) == 0) {
1233 bit_posn += 4;
1234 x >>= 4;
1235 }
1236 while ((x & 1) == 0) {
1237 bit_posn++;
1238 x >>= 1;
1239 }
1240 return bit_posn;
1241}
1242
1243
ricow@chromium.org65fae842010-08-25 15:26:24 +00001244// Can we multiply by x with max two shifts and an add.
1245// This answers yes to all integers from 2 to 10.
1246static bool IsEasyToMultiplyBy(int x) {
1247 if (x < 2) return false; // Avoid special cases.
1248 if (x > (Smi::kMaxValue + 1) >> 2) return false; // Almost always overflows.
1249 if (IsPowerOf2(x)) return true; // Simple shift.
1250 if (PopCountLessThanEqual2(x)) return true; // Shift and add and shift.
1251 if (IsPowerOf2(x + 1)) return true; // Patterns like 11111.
1252 return false;
1253}
1254
1255
1256// Can multiply by anything that IsEasyToMultiplyBy returns true for.
1257// Source and destination may be the same register. This routine does
1258// not set carry and overflow the way a mul instruction would.
1259static void InlineMultiplyByKnownInt(MacroAssembler* masm,
1260 Register source,
1261 Register destination,
1262 int known_int) {
1263 if (IsPowerOf2(known_int)) {
1264 masm->mov(destination, Operand(source, LSL, BitPosition(known_int)));
1265 } else if (PopCountLessThanEqual2(known_int)) {
1266 int first_bit = BitPosition(known_int);
1267 int second_bit = BitPosition(known_int ^ (1 << first_bit));
1268 masm->add(destination, source,
1269 Operand(source, LSL, second_bit - first_bit));
1270 if (first_bit != 0) {
1271 masm->mov(destination, Operand(destination, LSL, first_bit));
1272 }
1273 } else {
1274 ASSERT(IsPowerOf2(known_int + 1)); // Patterns like 1111.
1275 int the_bit = BitPosition(known_int + 1);
1276 masm->rsb(destination, source, Operand(source, LSL, the_bit));
1277 }
1278}
1279
1280
kmillikin@chromium.org4111b802010-05-03 10:34:42 +00001281void CodeGenerator::SmiOperation(Token::Value op,
1282 Handle<Object> value,
1283 bool reversed,
1284 OverwriteMode mode) {
ager@chromium.org357bf652010-04-12 11:30:10 +00001285 int int_value = Smi::cast(*value)->value();
1286
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00001287 bool both_sides_are_smi = frame_->KnownSmiAt(0);
1288
ager@chromium.org357bf652010-04-12 11:30:10 +00001289 bool something_to_inline;
1290 switch (op) {
1291 case Token::ADD:
1292 case Token::SUB:
1293 case Token::BIT_AND:
1294 case Token::BIT_OR:
1295 case Token::BIT_XOR: {
1296 something_to_inline = true;
1297 break;
1298 }
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00001299 case Token::SHL: {
1300 something_to_inline = (both_sides_are_smi || !reversed);
1301 break;
1302 }
ager@chromium.org357bf652010-04-12 11:30:10 +00001303 case Token::SHR:
1304 case Token::SAR: {
1305 if (reversed) {
1306 something_to_inline = false;
1307 } else {
1308 something_to_inline = true;
1309 }
1310 break;
1311 }
1312 case Token::MOD: {
1313 if (reversed || int_value < 2 || !IsPowerOf2(int_value)) {
1314 something_to_inline = false;
1315 } else {
1316 something_to_inline = true;
1317 }
1318 break;
1319 }
1320 case Token::MUL: {
1321 if (!IsEasyToMultiplyBy(int_value)) {
1322 something_to_inline = false;
1323 } else {
1324 something_to_inline = true;
1325 }
1326 break;
1327 }
1328 default: {
1329 something_to_inline = false;
1330 break;
1331 }
1332 }
1333
1334 if (!something_to_inline) {
1335 if (!reversed) {
1336 // Push the rhs onto the virtual frame by putting it in a TOS register.
1337 Register rhs = frame_->GetTOSRegister();
1338 __ mov(rhs, Operand(value));
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00001339 frame_->EmitPush(rhs, TypeInfo::Smi());
1340 GenericBinaryOperation(op, mode, GENERATE_INLINE_SMI, int_value);
ager@chromium.org357bf652010-04-12 11:30:10 +00001341 } else {
1342 // Pop the rhs, then push lhs and rhs in the right order. Only performs
1343 // at most one pop, the rest takes place in TOS registers.
1344 Register lhs = frame_->GetTOSRegister(); // Get reg for pushing.
1345 Register rhs = frame_->PopToRegister(lhs); // Don't use lhs for this.
1346 __ mov(lhs, Operand(value));
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00001347 frame_->EmitPush(lhs, TypeInfo::Smi());
1348 TypeInfo t = both_sides_are_smi ? TypeInfo::Smi() : TypeInfo::Unknown();
1349 frame_->EmitPush(rhs, t);
ricow@chromium.orgd236f4d2010-09-01 06:52:08 +00001350 GenericBinaryOperation(op, mode, GENERATE_INLINE_SMI,
1351 GenericBinaryOpStub::kUnknownIntValue);
ager@chromium.org357bf652010-04-12 11:30:10 +00001352 }
1353 return;
1354 }
1355
1356 // We move the top of stack to a register (normally no move is invoved).
1357 Register tos = frame_->PopToRegister();
ager@chromium.org357bf652010-04-12 11:30:10 +00001358 switch (op) {
1359 case Token::ADD: {
1360 DeferredCode* deferred =
1361 new DeferredInlineSmiOperation(op, int_value, reversed, mode, tos);
1362
1363 __ add(tos, tos, Operand(value), SetCC);
1364 deferred->Branch(vs);
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00001365 if (!both_sides_are_smi) {
1366 __ tst(tos, Operand(kSmiTagMask));
1367 deferred->Branch(ne);
1368 }
ager@chromium.org357bf652010-04-12 11:30:10 +00001369 deferred->BindExit();
1370 frame_->EmitPush(tos);
1371 break;
1372 }
1373
1374 case Token::SUB: {
1375 DeferredCode* deferred =
1376 new DeferredInlineSmiOperation(op, int_value, reversed, mode, tos);
1377
1378 if (reversed) {
1379 __ rsb(tos, tos, Operand(value), SetCC);
1380 } else {
1381 __ sub(tos, tos, Operand(value), SetCC);
1382 }
1383 deferred->Branch(vs);
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00001384 if (!both_sides_are_smi) {
1385 __ tst(tos, Operand(kSmiTagMask));
1386 deferred->Branch(ne);
1387 }
ager@chromium.org357bf652010-04-12 11:30:10 +00001388 deferred->BindExit();
1389 frame_->EmitPush(tos);
1390 break;
1391 }
1392
1393
1394 case Token::BIT_OR:
1395 case Token::BIT_XOR:
1396 case Token::BIT_AND: {
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00001397 if (both_sides_are_smi) {
1398 switch (op) {
1399 case Token::BIT_OR: __ orr(tos, tos, Operand(value)); break;
1400 case Token::BIT_XOR: __ eor(tos, tos, Operand(value)); break;
whesse@chromium.org2c186ca2010-06-16 11:32:39 +00001401 case Token::BIT_AND: __ And(tos, tos, Operand(value)); break;
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00001402 default: UNREACHABLE();
1403 }
1404 frame_->EmitPush(tos, TypeInfo::Smi());
1405 } else {
kmillikin@chromium.org3cdd9e12010-09-06 11:39:48 +00001406 DeferredInlineSmiOperation* deferred =
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00001407 new DeferredInlineSmiOperation(op, int_value, reversed, mode, tos);
1408 __ tst(tos, Operand(kSmiTagMask));
kmillikin@chromium.org3cdd9e12010-09-06 11:39:48 +00001409 deferred->JumpToNonSmiInput(ne);
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00001410 switch (op) {
1411 case Token::BIT_OR: __ orr(tos, tos, Operand(value)); break;
1412 case Token::BIT_XOR: __ eor(tos, tos, Operand(value)); break;
whesse@chromium.org2c186ca2010-06-16 11:32:39 +00001413 case Token::BIT_AND: __ And(tos, tos, Operand(value)); break;
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00001414 default: UNREACHABLE();
1415 }
1416 deferred->BindExit();
1417 TypeInfo result_type =
1418 (op == Token::BIT_AND) ? TypeInfo::Smi() : TypeInfo::Integer32();
1419 frame_->EmitPush(tos, result_type);
ager@chromium.org357bf652010-04-12 11:30:10 +00001420 }
ager@chromium.org357bf652010-04-12 11:30:10 +00001421 break;
1422 }
1423
1424 case Token::SHL:
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00001425 if (reversed) {
1426 ASSERT(both_sides_are_smi);
1427 int max_shift = 0;
1428 int max_result = int_value == 0 ? 1 : int_value;
1429 while (Smi::IsValid(max_result << 1)) {
1430 max_shift++;
1431 max_result <<= 1;
1432 }
1433 DeferredCode* deferred =
1434 new DeferredInlineSmiOperation(op, int_value, true, mode, tos);
1435 // Mask off the last 5 bits of the shift operand (rhs). This is part
1436 // of the definition of shift in JS and we know we have a Smi so we
1437 // can safely do this. The masked version gets passed to the
1438 // deferred code, but that makes no difference.
1439 __ and_(tos, tos, Operand(Smi::FromInt(0x1f)));
1440 __ cmp(tos, Operand(Smi::FromInt(max_shift)));
1441 deferred->Branch(ge);
1442 Register scratch = VirtualFrame::scratch0();
1443 __ mov(scratch, Operand(tos, ASR, kSmiTagSize)); // Untag.
1444 __ mov(tos, Operand(Smi::FromInt(int_value))); // Load constant.
1445 __ mov(tos, Operand(tos, LSL, scratch)); // Shift constant.
1446 deferred->BindExit();
1447 TypeInfo result = TypeInfo::Integer32();
1448 frame_->EmitPush(tos, result);
1449 break;
1450 }
1451 // Fall through!
ager@chromium.org357bf652010-04-12 11:30:10 +00001452 case Token::SHR:
1453 case Token::SAR: {
1454 ASSERT(!reversed);
kmillikin@chromium.org3cdd9e12010-09-06 11:39:48 +00001455 int shift_value = int_value & 0x1f;
erik.corry@gmail.com145eff52010-08-23 11:36:18 +00001456 TypeInfo result = TypeInfo::Number();
1457
1458 if (op == Token::SHR) {
kmillikin@chromium.org3cdd9e12010-09-06 11:39:48 +00001459 if (shift_value > 1) {
erik.corry@gmail.com145eff52010-08-23 11:36:18 +00001460 result = TypeInfo::Smi();
kmillikin@chromium.org3cdd9e12010-09-06 11:39:48 +00001461 } else if (shift_value > 0) {
erik.corry@gmail.com145eff52010-08-23 11:36:18 +00001462 result = TypeInfo::Integer32();
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00001463 }
erik.corry@gmail.com145eff52010-08-23 11:36:18 +00001464 } else if (op == Token::SAR) {
kmillikin@chromium.org3cdd9e12010-09-06 11:39:48 +00001465 if (shift_value > 0) {
erik.corry@gmail.com145eff52010-08-23 11:36:18 +00001466 result = TypeInfo::Smi();
1467 } else {
1468 result = TypeInfo::Integer32();
1469 }
1470 } else {
1471 ASSERT(op == Token::SHL);
1472 result = TypeInfo::Integer32();
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00001473 }
erik.corry@gmail.com145eff52010-08-23 11:36:18 +00001474
kmillikin@chromium.org3cdd9e12010-09-06 11:39:48 +00001475 DeferredInlineSmiOperation* deferred =
ager@chromium.org357bf652010-04-12 11:30:10 +00001476 new DeferredInlineSmiOperation(op, shift_value, false, mode, tos);
kmillikin@chromium.org3cdd9e12010-09-06 11:39:48 +00001477 if (!both_sides_are_smi) {
1478 __ tst(tos, Operand(kSmiTagMask));
1479 deferred->JumpToNonSmiInput(ne);
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00001480 }
ager@chromium.org357bf652010-04-12 11:30:10 +00001481 switch (op) {
1482 case Token::SHL: {
1483 if (shift_value != 0) {
lrn@chromium.org303ada72010-10-27 09:33:13 +00001484 Register untagged_result = VirtualFrame::scratch0();
1485 Register scratch = VirtualFrame::scratch1();
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +00001486 int adjusted_shift = shift_value - kSmiTagSize;
1487 ASSERT(adjusted_shift >= 0);
kmillikin@chromium.org3cdd9e12010-09-06 11:39:48 +00001488
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +00001489 if (adjusted_shift != 0) {
lrn@chromium.org303ada72010-10-27 09:33:13 +00001490 __ mov(untagged_result, Operand(tos, LSL, adjusted_shift));
1491 } else {
1492 __ mov(untagged_result, Operand(tos));
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +00001493 }
kmillikin@chromium.org3cdd9e12010-09-06 11:39:48 +00001494 // Check that the *signed* result fits in a smi.
lrn@chromium.org303ada72010-10-27 09:33:13 +00001495 __ add(scratch, untagged_result, Operand(0x40000000), SetCC);
kmillikin@chromium.org3cdd9e12010-09-06 11:39:48 +00001496 deferred->JumpToAnswerOutOfRange(mi);
lrn@chromium.org303ada72010-10-27 09:33:13 +00001497 __ mov(tos, Operand(untagged_result, LSL, kSmiTagSize));
ager@chromium.org357bf652010-04-12 11:30:10 +00001498 }
ager@chromium.org357bf652010-04-12 11:30:10 +00001499 break;
1500 }
1501 case Token::SHR: {
ager@chromium.org357bf652010-04-12 11:30:10 +00001502 if (shift_value != 0) {
lrn@chromium.org303ada72010-10-27 09:33:13 +00001503 Register untagged_result = VirtualFrame::scratch0();
1504 // Remove tag.
1505 __ mov(untagged_result, Operand(tos, ASR, kSmiTagSize));
1506 __ mov(untagged_result, Operand(untagged_result, LSR, shift_value));
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +00001507 if (shift_value == 1) {
kmillikin@chromium.org3cdd9e12010-09-06 11:39:48 +00001508 // Check that the *unsigned* result fits in a smi.
1509 // Neither of the two high-order bits can be set:
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +00001510 // - 0x80000000: high bit would be lost when smi tagging
kmillikin@chromium.org3cdd9e12010-09-06 11:39:48 +00001511 // - 0x40000000: this number would convert to negative when Smi
1512 // tagging.
1513 // These two cases can only happen with shifts by 0 or 1 when
1514 // handed a valid smi.
lrn@chromium.org303ada72010-10-27 09:33:13 +00001515 __ tst(untagged_result, Operand(0xc0000000));
kmillikin@chromium.org3cdd9e12010-09-06 11:39:48 +00001516 deferred->JumpToAnswerOutOfRange(ne);
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +00001517 }
lrn@chromium.org303ada72010-10-27 09:33:13 +00001518 __ mov(tos, Operand(untagged_result, LSL, kSmiTagSize));
kmillikin@chromium.org3cdd9e12010-09-06 11:39:48 +00001519 } else {
ager@chromium.org5b2fbee2010-09-08 06:38:15 +00001520 __ cmp(tos, Operand(0, RelocInfo::NONE));
kmillikin@chromium.org3cdd9e12010-09-06 11:39:48 +00001521 deferred->JumpToAnswerOutOfRange(mi);
ager@chromium.org357bf652010-04-12 11:30:10 +00001522 }
ager@chromium.org357bf652010-04-12 11:30:10 +00001523 break;
1524 }
1525 case Token::SAR: {
1526 if (shift_value != 0) {
kmillikin@chromium.org3cdd9e12010-09-06 11:39:48 +00001527 // Do the shift and the tag removal in one operation. If the shift
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +00001528 // is 31 bits (the highest possible value) then we emit the
kmillikin@chromium.org3cdd9e12010-09-06 11:39:48 +00001529 // instruction as a shift by 0 which in the ARM ISA means shift
1530 // arithmetically by 32.
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +00001531 __ mov(tos, Operand(tos, ASR, (kSmiTagSize + shift_value) & 0x1f));
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +00001532 __ mov(tos, Operand(tos, LSL, kSmiTagSize));
ager@chromium.org357bf652010-04-12 11:30:10 +00001533 }
1534 break;
1535 }
1536 default: UNREACHABLE();
1537 }
ager@chromium.org357bf652010-04-12 11:30:10 +00001538 deferred->BindExit();
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00001539 frame_->EmitPush(tos, result);
ager@chromium.org357bf652010-04-12 11:30:10 +00001540 break;
1541 }
1542
1543 case Token::MOD: {
1544 ASSERT(!reversed);
1545 ASSERT(int_value >= 2);
1546 ASSERT(IsPowerOf2(int_value));
1547 DeferredCode* deferred =
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00001548 new DeferredInlineSmiOperation(op, int_value, reversed, mode, tos);
ager@chromium.org357bf652010-04-12 11:30:10 +00001549 unsigned mask = (0x80000000u | kSmiTagMask);
1550 __ tst(tos, Operand(mask));
1551 deferred->Branch(ne); // Go to deferred code on non-Smis and negative.
1552 mask = (int_value << kSmiTagSize) - 1;
1553 __ and_(tos, tos, Operand(mask));
1554 deferred->BindExit();
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00001555 // Mod of positive power of 2 Smi gives a Smi if the lhs is an integer.
1556 frame_->EmitPush(
1557 tos,
1558 both_sides_are_smi ? TypeInfo::Smi() : TypeInfo::Number());
ager@chromium.org357bf652010-04-12 11:30:10 +00001559 break;
1560 }
1561
1562 case Token::MUL: {
1563 ASSERT(IsEasyToMultiplyBy(int_value));
1564 DeferredCode* deferred =
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00001565 new DeferredInlineSmiOperation(op, int_value, reversed, mode, tos);
ager@chromium.org357bf652010-04-12 11:30:10 +00001566 unsigned max_smi_that_wont_overflow = Smi::kMaxValue / int_value;
1567 max_smi_that_wont_overflow <<= kSmiTagSize;
1568 unsigned mask = 0x80000000u;
1569 while ((mask & max_smi_that_wont_overflow) == 0) {
1570 mask |= mask >> 1;
1571 }
1572 mask |= kSmiTagMask;
1573 // This does a single mask that checks for a too high value in a
1574 // conservative way and for a non-Smi. It also filters out negative
1575 // numbers, unfortunately, but since this code is inline we prefer
1576 // brevity to comprehensiveness.
1577 __ tst(tos, Operand(mask));
1578 deferred->Branch(ne);
ricow@chromium.org65fae842010-08-25 15:26:24 +00001579 InlineMultiplyByKnownInt(masm_, tos, tos, int_value);
ager@chromium.org357bf652010-04-12 11:30:10 +00001580 deferred->BindExit();
1581 frame_->EmitPush(tos);
1582 break;
1583 }
1584
1585 default:
1586 UNREACHABLE();
1587 break;
1588 }
1589}
1590
1591
ager@chromium.org378b34e2011-01-28 08:04:38 +00001592void CodeGenerator::Comparison(Condition cond,
kasperl@chromium.org2abc4502009-07-02 07:00:29 +00001593 Expression* left,
1594 Expression* right,
1595 bool strict) {
ager@chromium.org357bf652010-04-12 11:30:10 +00001596 VirtualFrame::RegisterAllocationScope scope(this);
kasperl@chromium.org2abc4502009-07-02 07:00:29 +00001597
ager@chromium.org357bf652010-04-12 11:30:10 +00001598 if (left != NULL) Load(left);
1599 if (right != NULL) Load(right);
1600
mads.s.ager31e71382008-08-13 09:32:07 +00001601 // sp[0] : y
1602 // sp[1] : x
1603 // result : cc register
1604
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001605 // Strict only makes sense for equality comparisons.
ager@chromium.org378b34e2011-01-28 08:04:38 +00001606 ASSERT(!strict || cond == eq);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001607
ager@chromium.org357bf652010-04-12 11:30:10 +00001608 Register lhs;
1609 Register rhs;
1610
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00001611 bool lhs_is_smi;
1612 bool rhs_is_smi;
1613
ager@chromium.org357bf652010-04-12 11:30:10 +00001614 // We load the top two stack positions into registers chosen by the virtual
1615 // frame. This should keep the register shuffling to a minimum.
mads.s.ager@gmail.com769cc962008-08-06 10:02:49 +00001616 // Implement '>' and '<=' by reversal to obtain ECMA-262 conversion order.
ager@chromium.org378b34e2011-01-28 08:04:38 +00001617 if (cond == gt || cond == le) {
1618 cond = ReverseCondition(cond);
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00001619 lhs_is_smi = frame_->KnownSmiAt(0);
1620 rhs_is_smi = frame_->KnownSmiAt(1);
ager@chromium.org357bf652010-04-12 11:30:10 +00001621 lhs = frame_->PopToRegister();
1622 rhs = frame_->PopToRegister(lhs); // Don't pop to the same register again!
mads.s.ager@gmail.com769cc962008-08-06 10:02:49 +00001623 } else {
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00001624 rhs_is_smi = frame_->KnownSmiAt(0);
1625 lhs_is_smi = frame_->KnownSmiAt(1);
ager@chromium.org357bf652010-04-12 11:30:10 +00001626 rhs = frame_->PopToRegister();
1627 lhs = frame_->PopToRegister(rhs); // Don't pop to the same register again!
mads.s.ager@gmail.com769cc962008-08-06 10:02:49 +00001628 }
ager@chromium.org357bf652010-04-12 11:30:10 +00001629
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00001630 bool both_sides_are_smi = (lhs_is_smi && rhs_is_smi);
1631
ager@chromium.org357bf652010-04-12 11:30:10 +00001632 ASSERT(rhs.is(r0) || rhs.is(r1));
1633 ASSERT(lhs.is(r0) || lhs.is(r1));
1634
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00001635 JumpTarget exit;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001636
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00001637 if (!both_sides_are_smi) {
1638 // Now we have the two sides in r0 and r1. We flush any other registers
1639 // because the stub doesn't know about register allocation.
1640 frame_->SpillAll();
1641 Register scratch = VirtualFrame::scratch0();
1642 Register smi_test_reg;
1643 if (lhs_is_smi) {
1644 smi_test_reg = rhs;
1645 } else if (rhs_is_smi) {
1646 smi_test_reg = lhs;
1647 } else {
1648 __ orr(scratch, lhs, Operand(rhs));
1649 smi_test_reg = scratch;
1650 }
1651 __ tst(smi_test_reg, Operand(kSmiTagMask));
1652 JumpTarget smi;
1653 smi.Branch(eq);
1654
1655 // Perform non-smi comparison by stub.
1656 // CompareStub takes arguments in r0 and r1, returns <0, >0 or 0 in r0.
1657 // We call with 0 args because there are 0 on the stack.
ager@chromium.org378b34e2011-01-28 08:04:38 +00001658 CompareStub stub(cond, strict, NO_SMI_COMPARE_IN_STUB, lhs, rhs);
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00001659 frame_->CallStub(&stub, 0);
ager@chromium.org5b2fbee2010-09-08 06:38:15 +00001660 __ cmp(r0, Operand(0, RelocInfo::NONE));
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00001661 exit.Jump();
1662
1663 smi.Bind();
ager@chromium.org357bf652010-04-12 11:30:10 +00001664 }
1665
kasperl@chromium.org2abc4502009-07-02 07:00:29 +00001666 // Do smi comparisons by pointer comparison.
ager@chromium.org357bf652010-04-12 11:30:10 +00001667 __ cmp(lhs, Operand(rhs));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001668
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00001669 exit.Bind();
ager@chromium.org378b34e2011-01-28 08:04:38 +00001670 cc_reg_ = cond;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001671}
1672
1673
mads.s.ager31e71382008-08-13 09:32:07 +00001674// Call the function on the stack with the given arguments.
ager@chromium.org7c537e22008-10-16 08:43:32 +00001675void CodeGenerator::CallWithArguments(ZoneList<Expression*>* args,
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +00001676 CallFunctionFlags flags,
1677 int position) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001678 // Push the arguments ("left-to-right") on the stack.
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00001679 int arg_count = args->length();
1680 for (int i = 0; i < arg_count; i++) {
ricow@chromium.org30ce4112010-05-31 10:38:25 +00001681 Load(args->at(i));
mads.s.ager31e71382008-08-13 09:32:07 +00001682 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001683
kasper.lund7276f142008-07-30 08:49:36 +00001684 // Record the position for debugging purposes.
christian.plesner.hansen@gmail.com37abdec2009-01-06 14:43:28 +00001685 CodeForSourcePosition(position);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001686
kasper.lund7276f142008-07-30 08:49:36 +00001687 // Use the shared code stub to call the function.
kasperl@chromium.org71affb52009-05-26 05:44:31 +00001688 InLoopFlag in_loop = loop_nesting() > 0 ? IN_LOOP : NOT_IN_LOOP;
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +00001689 CallFunctionStub call_function(arg_count, in_loop, flags);
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00001690 frame_->CallStub(&call_function, arg_count + 1);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001691
1692 // Restore context and pop function from the stack.
ager@chromium.org3bf7b912008-11-17 09:09:45 +00001693 __ ldr(cp, frame_->Context());
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00001694 frame_->Drop(); // discard the TOS
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001695}
1696
1697
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00001698void CodeGenerator::CallApplyLazy(Expression* applicand,
1699 Expression* receiver,
1700 VariableProxy* arguments,
1701 int position) {
1702 // An optimized implementation of expressions of the form
1703 // x.apply(y, arguments).
1704 // If the arguments object of the scope has not been allocated,
1705 // and x.apply is Function.prototype.apply, this optimization
1706 // just copies y and the arguments of the current function on the
1707 // stack, as receiver and arguments, and calls x.
1708 // In the implementation comments, we call x the applicand
1709 // and y the receiver.
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00001710
1711 ASSERT(ArgumentsMode() == LAZY_ARGUMENTS_ALLOCATION);
1712 ASSERT(arguments->IsArguments());
1713
1714 // Load applicand.apply onto the stack. This will usually
1715 // give us a megamorphic load site. Not super, but it works.
ricow@chromium.org30ce4112010-05-31 10:38:25 +00001716 Load(applicand);
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00001717 Handle<String> name = Factory::LookupAsciiSymbol("apply");
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00001718 frame_->Dup();
ager@chromium.orgac091b72010-05-05 07:34:42 +00001719 frame_->CallLoadIC(name, RelocInfo::CODE_TARGET);
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00001720 frame_->EmitPush(r0);
1721
1722 // Load the receiver and the existing arguments object onto the
1723 // expression stack. Avoid allocating the arguments object here.
ricow@chromium.org30ce4112010-05-31 10:38:25 +00001724 Load(receiver);
whesse@chromium.org4a1fe7d2010-09-27 12:32:04 +00001725 LoadFromSlot(scope()->arguments()->AsSlot(), NOT_INSIDE_TYPEOF);
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00001726
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00001727 // At this point the top two stack elements are probably in registers
1728 // since they were just loaded. Ensure they are in regs and get the
1729 // regs.
1730 Register receiver_reg = frame_->Peek2();
1731 Register arguments_reg = frame_->Peek();
1732
1733 // From now on the frame is spilled.
1734 frame_->SpillAll();
1735
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00001736 // Emit the source position information after having loaded the
1737 // receiver and the arguments.
1738 CodeForSourcePosition(position);
1739 // Contents of the stack at this point:
1740 // sp[0]: arguments object of the current function or the hole.
1741 // sp[1]: receiver
1742 // sp[2]: applicand.apply
1743 // sp[3]: applicand.
1744
1745 // Check if the arguments object has been lazily allocated
1746 // already. If so, just use that instead of copying the arguments
1747 // from the stack. This also deals with cases where a local variable
1748 // named 'arguments' has been introduced.
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00001749 JumpTarget slow;
1750 Label done;
kmillikin@chromium.orgd2c22f02011-01-10 08:15:37 +00001751 __ LoadRoot(ip, Heap::kArgumentsMarkerRootIndex);
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00001752 __ cmp(ip, arguments_reg);
1753 slow.Branch(ne);
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00001754
1755 Label build_args;
1756 // Get rid of the arguments object probe.
1757 frame_->Drop();
1758 // Stack now has 3 elements on it.
1759 // Contents of stack at this point:
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00001760 // sp[0]: receiver - in the receiver_reg register.
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00001761 // sp[1]: applicand.apply
1762 // sp[2]: applicand.
1763
1764 // Check that the receiver really is a JavaScript object.
ager@chromium.org378b34e2011-01-28 08:04:38 +00001765 __ JumpIfSmi(receiver_reg, &build_args);
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00001766 // We allow all JSObjects including JSFunctions. As long as
1767 // JS_FUNCTION_TYPE is the last instance type and it is right
1768 // after LAST_JS_OBJECT_TYPE, we do not have to check the upper
1769 // bound.
whesse@chromium.orgba5a61b2010-07-26 11:44:40 +00001770 STATIC_ASSERT(LAST_TYPE == JS_FUNCTION_TYPE);
1771 STATIC_ASSERT(JS_FUNCTION_TYPE == LAST_JS_OBJECT_TYPE + 1);
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00001772 __ CompareObjectType(receiver_reg, r2, r3, FIRST_JS_OBJECT_TYPE);
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00001773 __ b(lt, &build_args);
1774
1775 // Check that applicand.apply is Function.prototype.apply.
1776 __ ldr(r0, MemOperand(sp, kPointerSize));
ager@chromium.org378b34e2011-01-28 08:04:38 +00001777 __ JumpIfSmi(r0, &build_args);
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00001778 __ CompareObjectType(r0, r1, r2, JS_FUNCTION_TYPE);
1779 __ b(ne, &build_args);
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00001780 Handle<Code> apply_code(Builtins::builtin(Builtins::FunctionApply));
erik.corry@gmail.com145eff52010-08-23 11:36:18 +00001781 __ ldr(r1, FieldMemOperand(r0, JSFunction::kCodeEntryOffset));
1782 __ sub(r1, r1, Operand(Code::kHeaderSize - kHeapObjectTag));
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00001783 __ cmp(r1, Operand(apply_code));
1784 __ b(ne, &build_args);
1785
1786 // Check that applicand is a function.
1787 __ ldr(r1, MemOperand(sp, 2 * kPointerSize));
ager@chromium.org378b34e2011-01-28 08:04:38 +00001788 __ JumpIfSmi(r1, &build_args);
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00001789 __ CompareObjectType(r1, r2, r3, JS_FUNCTION_TYPE);
1790 __ b(ne, &build_args);
1791
1792 // Copy the arguments to this function possibly from the
1793 // adaptor frame below it.
1794 Label invoke, adapted;
1795 __ ldr(r2, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
1796 __ ldr(r3, MemOperand(r2, StandardFrameConstants::kContextOffset));
1797 __ cmp(r3, Operand(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
1798 __ b(eq, &adapted);
1799
1800 // No arguments adaptor frame. Copy fixed number of arguments.
1801 __ mov(r0, Operand(scope()->num_parameters()));
1802 for (int i = 0; i < scope()->num_parameters(); i++) {
1803 __ ldr(r2, frame_->ParameterAt(i));
1804 __ push(r2);
1805 }
1806 __ jmp(&invoke);
1807
1808 // Arguments adaptor frame present. Copy arguments from there, but
1809 // avoid copying too many arguments to avoid stack overflows.
1810 __ bind(&adapted);
1811 static const uint32_t kArgumentsLimit = 1 * KB;
1812 __ ldr(r0, MemOperand(r2, ArgumentsAdaptorFrameConstants::kLengthOffset));
1813 __ mov(r0, Operand(r0, LSR, kSmiTagSize));
1814 __ mov(r3, r0);
1815 __ cmp(r0, Operand(kArgumentsLimit));
1816 __ b(gt, &build_args);
1817
1818 // Loop through the arguments pushing them onto the execution
1819 // stack. We don't inform the virtual frame of the push, so we don't
1820 // have to worry about getting rid of the elements from the virtual
1821 // frame.
1822 Label loop;
1823 // r3 is a small non-negative integer, due to the test above.
ager@chromium.org5b2fbee2010-09-08 06:38:15 +00001824 __ cmp(r3, Operand(0, RelocInfo::NONE));
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00001825 __ b(eq, &invoke);
1826 // Compute the address of the first argument.
1827 __ add(r2, r2, Operand(r3, LSL, kPointerSizeLog2));
1828 __ add(r2, r2, Operand(kPointerSize));
1829 __ bind(&loop);
1830 // Post-decrement argument address by kPointerSize on each iteration.
1831 __ ldr(r4, MemOperand(r2, kPointerSize, NegPostIndex));
1832 __ push(r4);
1833 __ sub(r3, r3, Operand(1), SetCC);
1834 __ b(gt, &loop);
1835
1836 // Invoke the function.
1837 __ bind(&invoke);
1838 ParameterCount actual(r0);
1839 __ InvokeFunction(r1, actual, CALL_FUNCTION);
1840 // Drop applicand.apply and applicand from the stack, and push
1841 // the result of the function call, but leave the spilled frame
1842 // unchanged, with 3 elements, so it is correct when we compile the
1843 // slow-case code.
1844 __ add(sp, sp, Operand(2 * kPointerSize));
1845 __ push(r0);
1846 // Stack now has 1 element:
1847 // sp[0]: result
1848 __ jmp(&done);
1849
1850 // Slow-case: Allocate the arguments object since we know it isn't
1851 // there, and fall-through to the slow-case where we call
1852 // applicand.apply.
1853 __ bind(&build_args);
1854 // Stack now has 3 elements, because we have jumped from where:
1855 // sp[0]: receiver
1856 // sp[1]: applicand.apply
1857 // sp[2]: applicand.
1858 StoreArgumentsObject(false);
1859
1860 // Stack and frame now have 4 elements.
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00001861 slow.Bind();
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00001862
1863 // Generic computation of x.apply(y, args) with no special optimization.
1864 // Flip applicand.apply and applicand on the stack, so
1865 // applicand looks like the receiver of the applicand.apply call.
1866 // Then process it as a normal function call.
1867 __ ldr(r0, MemOperand(sp, 3 * kPointerSize));
1868 __ ldr(r1, MemOperand(sp, 2 * kPointerSize));
kmillikin@chromium.org9155e252010-05-26 13:27:57 +00001869 __ Strd(r0, r1, MemOperand(sp, 2 * kPointerSize));
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00001870
1871 CallFunctionStub call_function(2, NOT_IN_LOOP, NO_CALL_FUNCTION_FLAGS);
1872 frame_->CallStub(&call_function, 3);
1873 // The function and its two arguments have been dropped.
1874 frame_->Drop(); // Drop the receiver as well.
1875 frame_->EmitPush(r0);
whesse@chromium.orge90029b2010-08-02 11:52:17 +00001876 frame_->SpillAll(); // A spilled frame is also jumping to label done.
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00001877 // Stack now has 1 element:
1878 // sp[0]: result
1879 __ bind(&done);
1880
1881 // Restore the context register after a call.
1882 __ ldr(cp, frame_->Context());
1883}
1884
1885
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00001886void CodeGenerator::Branch(bool if_true, JumpTarget* target) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001887 ASSERT(has_cc());
ager@chromium.org378b34e2011-01-28 08:04:38 +00001888 Condition cond = if_true ? cc_reg_ : NegateCondition(cc_reg_);
1889 target->Branch(cond);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001890 cc_reg_ = al;
1891}
1892
1893
ager@chromium.org7c537e22008-10-16 08:43:32 +00001894void CodeGenerator::CheckStack() {
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00001895 frame_->SpillAll();
ager@chromium.org3811b432009-10-28 14:53:37 +00001896 Comment cmnt(masm_, "[ check stack");
1897 __ LoadRoot(ip, Heap::kStackLimitRootIndex);
ager@chromium.org3811b432009-10-28 14:53:37 +00001898 masm_->cmp(sp, Operand(ip));
1899 StackCheckStub stub;
1900 // Call the stub if lower.
erik.corry@gmail.com4a6c3272010-11-18 12:04:40 +00001901 masm_->mov(ip,
ager@chromium.org3811b432009-10-28 14:53:37 +00001902 Operand(reinterpret_cast<intptr_t>(stub.GetCode().location()),
1903 RelocInfo::CODE_TARGET),
1904 LeaveCC,
1905 lo);
erik.corry@gmail.com4a6c3272010-11-18 12:04:40 +00001906 masm_->Call(ip, lo);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001907}
1908
1909
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00001910void CodeGenerator::VisitStatements(ZoneList<Statement*>* statements) {
1911#ifdef DEBUG
1912 int original_height = frame_->height();
1913#endif
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00001914 for (int i = 0; frame_ != NULL && i < statements->length(); i++) {
ricow@chromium.org30ce4112010-05-31 10:38:25 +00001915 Visit(statements->at(i));
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00001916 }
1917 ASSERT(!has_valid_frame() || frame_->height() == original_height);
1918}
1919
1920
ager@chromium.org7c537e22008-10-16 08:43:32 +00001921void CodeGenerator::VisitBlock(Block* node) {
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00001922#ifdef DEBUG
1923 int original_height = frame_->height();
1924#endif
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001925 Comment cmnt(masm_, "[ Block");
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00001926 CodeForStatementPosition(node);
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +00001927 node->break_target()->SetExpectedHeight();
ricow@chromium.org30ce4112010-05-31 10:38:25 +00001928 VisitStatements(node->statements());
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00001929 if (node->break_target()->is_linked()) {
1930 node->break_target()->Bind();
1931 }
1932 node->break_target()->Unuse();
1933 ASSERT(!has_valid_frame() || frame_->height() == original_height);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001934}
1935
1936
ager@chromium.org7c537e22008-10-16 08:43:32 +00001937void CodeGenerator::DeclareGlobals(Handle<FixedArray> pairs) {
ager@chromium.org3811b432009-10-28 14:53:37 +00001938 frame_->EmitPush(cp);
ager@chromium.orgac091b72010-05-05 07:34:42 +00001939 frame_->EmitPush(Operand(pairs));
1940 frame_->EmitPush(Operand(Smi::FromInt(is_eval() ? 1 : 0)));
1941
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00001942 frame_->CallRuntime(Runtime::kDeclareGlobals, 3);
mads.s.ager31e71382008-08-13 09:32:07 +00001943 // The result is discarded.
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001944}
1945
1946
ager@chromium.org7c537e22008-10-16 08:43:32 +00001947void CodeGenerator::VisitDeclaration(Declaration* node) {
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00001948#ifdef DEBUG
1949 int original_height = frame_->height();
1950#endif
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001951 Comment cmnt(masm_, "[ Declaration");
1952 Variable* var = node->proxy()->var();
1953 ASSERT(var != NULL); // must have been resolved
whesse@chromium.org4a1fe7d2010-09-27 12:32:04 +00001954 Slot* slot = var->AsSlot();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001955
1956 // If it was not possible to allocate the variable at compile time,
1957 // we need to "declare" it at runtime to make sure it actually
1958 // exists in the local context.
1959 if (slot != NULL && slot->type() == Slot::LOOKUP) {
1960 // Variables with a "LOOKUP" slot were introduced as non-locals
1961 // during variable resolution and must have mode DYNAMIC.
ager@chromium.org381abbb2009-02-25 13:23:22 +00001962 ASSERT(var->is_dynamic());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001963 // For now, just do a runtime call.
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00001964 frame_->EmitPush(cp);
ager@chromium.orgac091b72010-05-05 07:34:42 +00001965 frame_->EmitPush(Operand(var->name()));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001966 // Declaration nodes are always declared in only two modes.
1967 ASSERT(node->mode() == Variable::VAR || node->mode() == Variable::CONST);
1968 PropertyAttributes attr = node->mode() == Variable::VAR ? NONE : READ_ONLY;
ager@chromium.orgac091b72010-05-05 07:34:42 +00001969 frame_->EmitPush(Operand(Smi::FromInt(attr)));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001970 // Push initial value, if any.
1971 // Note: For variables we must not push an initial value (such as
1972 // 'undefined') because we may have a (legal) redeclaration and we
1973 // must not destroy the current value.
1974 if (node->mode() == Variable::CONST) {
ager@chromium.orgac091b72010-05-05 07:34:42 +00001975 frame_->EmitPushRoot(Heap::kTheHoleValueRootIndex);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001976 } else if (node->fun() != NULL) {
ager@chromium.orgac091b72010-05-05 07:34:42 +00001977 Load(node->fun());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001978 } else {
ager@chromium.org5b2fbee2010-09-08 06:38:15 +00001979 frame_->EmitPush(Operand(0, RelocInfo::NONE));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001980 }
ager@chromium.orgac091b72010-05-05 07:34:42 +00001981
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00001982 frame_->CallRuntime(Runtime::kDeclareContextSlot, 4);
ager@chromium.org7c537e22008-10-16 08:43:32 +00001983 // Ignore the return value (declarations are statements).
ager@chromium.orgac091b72010-05-05 07:34:42 +00001984
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00001985 ASSERT(frame_->height() == original_height);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001986 return;
1987 }
1988
1989 ASSERT(!var->is_global());
1990
1991 // If we have a function or a constant, we need to initialize the variable.
1992 Expression* val = NULL;
1993 if (node->mode() == Variable::CONST) {
1994 val = new Literal(Factory::the_hole_value());
1995 } else {
1996 val = node->fun(); // NULL if we don't have a function
1997 }
1998
kmillikin@chromium.org69ea3962010-07-05 11:01:40 +00001999
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002000 if (val != NULL) {
kmillikin@chromium.org69ea3962010-07-05 11:01:40 +00002001 WriteBarrierCharacter wb_info =
2002 val->type()->IsLikelySmi() ? LIKELY_SMI : UNLIKELY_SMI;
2003 if (val->AsLiteral() != NULL) wb_info = NEVER_NEWSPACE;
ager@chromium.orgac091b72010-05-05 07:34:42 +00002004 // Set initial value.
2005 Reference target(this, node->proxy());
2006 Load(val);
kmillikin@chromium.org69ea3962010-07-05 11:01:40 +00002007 target.SetValue(NOT_CONST_INIT, wb_info);
ager@chromium.orgac091b72010-05-05 07:34:42 +00002008
iposva@chromium.org245aa852009-02-10 00:49:54 +00002009 // Get rid of the assigned value (declarations are statements).
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002010 frame_->Drop();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002011 }
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002012 ASSERT(frame_->height() == original_height);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002013}
2014
2015
ager@chromium.org7c537e22008-10-16 08:43:32 +00002016void CodeGenerator::VisitExpressionStatement(ExpressionStatement* node) {
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002017#ifdef DEBUG
2018 int original_height = frame_->height();
2019#endif
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002020 Comment cmnt(masm_, "[ ExpressionStatement");
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002021 CodeForStatementPosition(node);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002022 Expression* expression = node->expression();
2023 expression->MarkAsStatement();
ricow@chromium.org30ce4112010-05-31 10:38:25 +00002024 Load(expression);
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002025 frame_->Drop();
2026 ASSERT(frame_->height() == original_height);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002027}
2028
2029
ager@chromium.org7c537e22008-10-16 08:43:32 +00002030void CodeGenerator::VisitEmptyStatement(EmptyStatement* node) {
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002031#ifdef DEBUG
2032 int original_height = frame_->height();
2033#endif
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002034 Comment cmnt(masm_, "// EmptyStatement");
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002035 CodeForStatementPosition(node);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002036 // nothing to do
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002037 ASSERT(frame_->height() == original_height);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002038}
2039
2040
ager@chromium.org7c537e22008-10-16 08:43:32 +00002041void CodeGenerator::VisitIfStatement(IfStatement* node) {
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002042#ifdef DEBUG
2043 int original_height = frame_->height();
2044#endif
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002045 Comment cmnt(masm_, "[ IfStatement");
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002046 // Generate different code depending on which parts of the if statement
2047 // are present or not.
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002048 bool has_then_stm = node->HasThenStatement();
2049 bool has_else_stm = node->HasElseStatement();
2050
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002051 CodeForStatementPosition(node);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002052
kasperl@chromium.org71affb52009-05-26 05:44:31 +00002053 JumpTarget exit;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002054 if (has_then_stm && has_else_stm) {
mads.s.ager31e71382008-08-13 09:32:07 +00002055 Comment cmnt(masm_, "[ IfThenElse");
kasperl@chromium.org71affb52009-05-26 05:44:31 +00002056 JumpTarget then;
2057 JumpTarget else_;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002058 // if (cond)
ricow@chromium.org30ce4112010-05-31 10:38:25 +00002059 LoadCondition(node->condition(), &then, &else_, true);
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002060 if (frame_ != NULL) {
2061 Branch(false, &else_);
2062 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002063 // then
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002064 if (frame_ != NULL || then.is_linked()) {
2065 then.Bind();
ricow@chromium.org30ce4112010-05-31 10:38:25 +00002066 Visit(node->then_statement());
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002067 }
2068 if (frame_ != NULL) {
2069 exit.Jump();
2070 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002071 // else
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002072 if (else_.is_linked()) {
2073 else_.Bind();
ricow@chromium.org30ce4112010-05-31 10:38:25 +00002074 Visit(node->else_statement());
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002075 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002076
2077 } else if (has_then_stm) {
mads.s.ager31e71382008-08-13 09:32:07 +00002078 Comment cmnt(masm_, "[ IfThen");
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002079 ASSERT(!has_else_stm);
kasperl@chromium.org71affb52009-05-26 05:44:31 +00002080 JumpTarget then;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002081 // if (cond)
ricow@chromium.org30ce4112010-05-31 10:38:25 +00002082 LoadCondition(node->condition(), &then, &exit, true);
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002083 if (frame_ != NULL) {
2084 Branch(false, &exit);
2085 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002086 // then
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002087 if (frame_ != NULL || then.is_linked()) {
2088 then.Bind();
ricow@chromium.org30ce4112010-05-31 10:38:25 +00002089 Visit(node->then_statement());
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002090 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002091
2092 } else if (has_else_stm) {
mads.s.ager31e71382008-08-13 09:32:07 +00002093 Comment cmnt(masm_, "[ IfElse");
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002094 ASSERT(!has_then_stm);
kasperl@chromium.org71affb52009-05-26 05:44:31 +00002095 JumpTarget else_;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002096 // if (!cond)
ricow@chromium.org30ce4112010-05-31 10:38:25 +00002097 LoadCondition(node->condition(), &exit, &else_, true);
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002098 if (frame_ != NULL) {
2099 Branch(true, &exit);
2100 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002101 // else
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002102 if (frame_ != NULL || else_.is_linked()) {
2103 else_.Bind();
ricow@chromium.org30ce4112010-05-31 10:38:25 +00002104 Visit(node->else_statement());
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002105 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002106
2107 } else {
mads.s.ager31e71382008-08-13 09:32:07 +00002108 Comment cmnt(masm_, "[ If");
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002109 ASSERT(!has_then_stm && !has_else_stm);
2110 // if (cond)
ricow@chromium.org30ce4112010-05-31 10:38:25 +00002111 LoadCondition(node->condition(), &exit, &exit, false);
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002112 if (frame_ != NULL) {
2113 if (has_cc()) {
2114 cc_reg_ = al;
2115 } else {
2116 frame_->Drop();
2117 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002118 }
2119 }
2120
2121 // end
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002122 if (exit.is_linked()) {
2123 exit.Bind();
2124 }
2125 ASSERT(!has_valid_frame() || frame_->height() == original_height);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002126}
2127
2128
ager@chromium.org7c537e22008-10-16 08:43:32 +00002129void CodeGenerator::VisitContinueStatement(ContinueStatement* node) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002130 Comment cmnt(masm_, "[ ContinueStatement");
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002131 CodeForStatementPosition(node);
2132 node->target()->continue_target()->Jump();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002133}
2134
2135
ager@chromium.org7c537e22008-10-16 08:43:32 +00002136void CodeGenerator::VisitBreakStatement(BreakStatement* node) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002137 Comment cmnt(masm_, "[ BreakStatement");
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002138 CodeForStatementPosition(node);
2139 node->target()->break_target()->Jump();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002140}
2141
2142
ager@chromium.org7c537e22008-10-16 08:43:32 +00002143void CodeGenerator::VisitReturnStatement(ReturnStatement* node) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002144 Comment cmnt(masm_, "[ ReturnStatement");
mads.s.ager31e71382008-08-13 09:32:07 +00002145
ager@chromium.org4af710e2009-09-15 12:20:11 +00002146 CodeForStatementPosition(node);
ricow@chromium.org30ce4112010-05-31 10:38:25 +00002147 Load(node->expression());
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00002148 frame_->PopToR0();
2149 frame_->PrepareForReturn();
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002150 if (function_return_is_shadowed_) {
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002151 function_return_.Jump();
2152 } else {
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002153 // Pop the result from the frame and prepare the frame for
2154 // returning thus making it easier to merge.
whesse@chromium.org2c186ca2010-06-16 11:32:39 +00002155 if (function_return_.is_bound()) {
2156 // If the function return label is already bound we reuse the
2157 // code by jumping to the return site.
2158 function_return_.Jump();
2159 } else {
2160 function_return_.Bind();
2161 GenerateReturnSequence();
2162 }
2163 }
2164}
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002165
whesse@chromium.org2c186ca2010-06-16 11:32:39 +00002166
2167void CodeGenerator::GenerateReturnSequence() {
2168 if (FLAG_trace) {
2169 // Push the return value on the stack as the parameter.
2170 // Runtime::TraceExit returns the parameter as it is.
2171 frame_->EmitPush(r0);
2172 frame_->CallRuntime(Runtime::kTraceExit, 1);
2173 }
2174
2175#ifdef DEBUG
2176 // Add a label for checking the size of the code used for returning.
2177 Label check_exit_codesize;
2178 masm_->bind(&check_exit_codesize);
2179#endif
2180 // Make sure that the constant pool is not emitted inside of the return
2181 // sequence.
2182 { Assembler::BlockConstPoolScope block_const_pool(masm_);
2183 // Tear down the frame which will restore the caller's frame pointer and
2184 // the link register.
2185 frame_->Exit();
2186
2187 // Here we use masm_-> instead of the __ macro to avoid the code coverage
2188 // tool from instrumenting as we rely on the code size here.
2189 int32_t sp_delta = (scope()->num_parameters() + 1) * kPointerSize;
2190 masm_->add(sp, sp, Operand(sp_delta));
2191 masm_->Jump(lr);
2192 DeleteFrame();
2193
2194#ifdef DEBUG
2195 // Check that the size of the code used for returning matches what is
2196 // expected by the debugger. If the sp_delts above cannot be encoded in
2197 // the add instruction the add will generate two instructions.
2198 int return_sequence_length =
2199 masm_->InstructionsGeneratedSince(&check_exit_codesize);
2200 CHECK(return_sequence_length ==
2201 Assembler::kJSReturnSequenceInstructions ||
2202 return_sequence_length ==
2203 Assembler::kJSReturnSequenceInstructions + 1);
2204#endif
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002205 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002206}
2207
2208
ager@chromium.org7c537e22008-10-16 08:43:32 +00002209void CodeGenerator::VisitWithEnterStatement(WithEnterStatement* node) {
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002210#ifdef DEBUG
2211 int original_height = frame_->height();
2212#endif
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002213 Comment cmnt(masm_, "[ WithEnterStatement");
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002214 CodeForStatementPosition(node);
ricow@chromium.org30ce4112010-05-31 10:38:25 +00002215 Load(node->expression());
christian.plesner.hansen@gmail.com37abdec2009-01-06 14:43:28 +00002216 if (node->is_catch_block()) {
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002217 frame_->CallRuntime(Runtime::kPushCatchContext, 1);
christian.plesner.hansen@gmail.com37abdec2009-01-06 14:43:28 +00002218 } else {
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002219 frame_->CallRuntime(Runtime::kPushContext, 1);
christian.plesner.hansen@gmail.com37abdec2009-01-06 14:43:28 +00002220 }
ager@chromium.org65dad4b2009-04-23 08:48:43 +00002221#ifdef DEBUG
kasperl@chromium.org71affb52009-05-26 05:44:31 +00002222 JumpTarget verified_true;
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00002223 __ cmp(r0, cp);
ager@chromium.org65dad4b2009-04-23 08:48:43 +00002224 verified_true.Branch(eq);
2225 __ stop("PushContext: r0 is expected to be the same as cp");
2226 verified_true.Bind();
2227#endif
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002228 // Update context local.
ager@chromium.org3bf7b912008-11-17 09:09:45 +00002229 __ str(cp, frame_->Context());
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002230 ASSERT(frame_->height() == original_height);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002231}
2232
2233
ager@chromium.org7c537e22008-10-16 08:43:32 +00002234void CodeGenerator::VisitWithExitStatement(WithExitStatement* node) {
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002235#ifdef DEBUG
2236 int original_height = frame_->height();
2237#endif
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002238 Comment cmnt(masm_, "[ WithExitStatement");
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002239 CodeForStatementPosition(node);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002240 // Pop context.
2241 __ ldr(cp, ContextOperand(cp, Context::PREVIOUS_INDEX));
2242 // Update context local.
ager@chromium.org3bf7b912008-11-17 09:09:45 +00002243 __ str(cp, frame_->Context());
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002244 ASSERT(frame_->height() == original_height);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002245}
2246
2247
ager@chromium.org7c537e22008-10-16 08:43:32 +00002248void CodeGenerator::VisitSwitchStatement(SwitchStatement* node) {
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002249#ifdef DEBUG
2250 int original_height = frame_->height();
2251#endif
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002252 Comment cmnt(masm_, "[ SwitchStatement");
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002253 CodeForStatementPosition(node);
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +00002254 node->break_target()->SetExpectedHeight();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002255
ricow@chromium.org30ce4112010-05-31 10:38:25 +00002256 Load(node->tag());
kasperl@chromium.org41044eb2008-10-06 08:24:46 +00002257
kasperl@chromium.org71affb52009-05-26 05:44:31 +00002258 JumpTarget next_test;
2259 JumpTarget fall_through;
2260 JumpTarget default_entry;
2261 JumpTarget default_exit(JumpTarget::BIDIRECTIONAL);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002262 ZoneList<CaseClause*>* cases = node->cases();
2263 int length = cases->length();
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002264 CaseClause* default_clause = NULL;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002265
2266 for (int i = 0; i < length; i++) {
2267 CaseClause* clause = cases->at(i);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002268 if (clause->is_default()) {
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002269 // Remember the default clause and compile it at the end.
2270 default_clause = clause;
2271 continue;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002272 }
2273
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002274 Comment cmnt(masm_, "[ Case clause");
2275 // Compile the test.
2276 next_test.Bind();
2277 next_test.Unuse();
2278 // Duplicate TOS.
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00002279 frame_->Dup();
kasperl@chromium.org2abc4502009-07-02 07:00:29 +00002280 Comparison(eq, NULL, clause->label(), true);
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002281 Branch(false, &next_test);
kasperl@chromium.orgb9123622008-09-17 14:05:56 +00002282
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002283 // Before entering the body from the test, remove the switch value from
2284 // the stack.
2285 frame_->Drop();
2286
2287 // Label the body so that fall through is enabled.
2288 if (i > 0 && cases->at(i - 1)->is_default()) {
2289 default_exit.Bind();
2290 } else {
2291 fall_through.Bind();
2292 fall_through.Unuse();
2293 }
ricow@chromium.org30ce4112010-05-31 10:38:25 +00002294 VisitStatements(clause->statements());
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002295
2296 // If control flow can fall through from the body, jump to the next body
2297 // or the end of the statement.
2298 if (frame_ != NULL) {
2299 if (i < length - 1 && cases->at(i + 1)->is_default()) {
2300 default_entry.Jump();
2301 } else {
2302 fall_through.Jump();
2303 }
2304 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002305 }
2306
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002307 // The final "test" removes the switch value.
2308 next_test.Bind();
2309 frame_->Drop();
2310
2311 // If there is a default clause, compile it.
2312 if (default_clause != NULL) {
2313 Comment cmnt(masm_, "[ Default clause");
2314 default_entry.Bind();
ricow@chromium.org30ce4112010-05-31 10:38:25 +00002315 VisitStatements(default_clause->statements());
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002316 // If control flow can fall out of the default and there is a case after
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00002317 // it, jump to that case's body.
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002318 if (frame_ != NULL && default_exit.is_bound()) {
2319 default_exit.Jump();
2320 }
kasperl@chromium.orgb9123622008-09-17 14:05:56 +00002321 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002322
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002323 if (fall_through.is_linked()) {
2324 fall_through.Bind();
2325 }
2326
2327 if (node->break_target()->is_linked()) {
2328 node->break_target()->Bind();
2329 }
2330 node->break_target()->Unuse();
2331 ASSERT(!has_valid_frame() || frame_->height() == original_height);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002332}
2333
2334
christian.plesner.hansen@gmail.com9d58c2b2009-10-16 11:48:38 +00002335void CodeGenerator::VisitDoWhileStatement(DoWhileStatement* node) {
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002336#ifdef DEBUG
2337 int original_height = frame_->height();
2338#endif
christian.plesner.hansen@gmail.com9d58c2b2009-10-16 11:48:38 +00002339 Comment cmnt(masm_, "[ DoWhileStatement");
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002340 CodeForStatementPosition(node);
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +00002341 node->break_target()->SetExpectedHeight();
christian.plesner.hansen@gmail.com9d58c2b2009-10-16 11:48:38 +00002342 JumpTarget body(JumpTarget::BIDIRECTIONAL);
ricow@chromium.orgc9c80822010-04-21 08:22:37 +00002343 IncrementLoopNesting();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002344
christian.plesner.hansen@gmail.com9d58c2b2009-10-16 11:48:38 +00002345 // Label the top of the loop for the backward CFG edge. If the test
2346 // is always true we can use the continue target, and if the test is
2347 // always false there is no need.
2348 ConditionAnalysis info = AnalyzeCondition(node->cond());
2349 switch (info) {
2350 case ALWAYS_TRUE:
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +00002351 node->continue_target()->SetExpectedHeight();
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002352 node->continue_target()->Bind();
christian.plesner.hansen@gmail.com9d58c2b2009-10-16 11:48:38 +00002353 break;
2354 case ALWAYS_FALSE:
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +00002355 node->continue_target()->SetExpectedHeight();
christian.plesner.hansen@gmail.com9d58c2b2009-10-16 11:48:38 +00002356 break;
2357 case DONT_KNOW:
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +00002358 node->continue_target()->SetExpectedHeight();
christian.plesner.hansen@gmail.com9d58c2b2009-10-16 11:48:38 +00002359 body.Bind();
2360 break;
2361 }
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002362
christian.plesner.hansen@gmail.com9d58c2b2009-10-16 11:48:38 +00002363 CheckStack(); // TODO(1222600): ignore if body contains calls.
ricow@chromium.org30ce4112010-05-31 10:38:25 +00002364 Visit(node->body());
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002365
sgjesse@chromium.orgac6aa172009-12-04 12:29:05 +00002366 // Compile the test.
christian.plesner.hansen@gmail.com9d58c2b2009-10-16 11:48:38 +00002367 switch (info) {
2368 case ALWAYS_TRUE:
2369 // If control can fall off the end of the body, jump back to the
2370 // top.
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002371 if (has_valid_frame()) {
christian.plesner.hansen@gmail.com9d58c2b2009-10-16 11:48:38 +00002372 node->continue_target()->Jump();
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002373 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002374 break;
christian.plesner.hansen@gmail.com9d58c2b2009-10-16 11:48:38 +00002375 case ALWAYS_FALSE:
2376 // If we have a continue in the body, we only have to bind its
2377 // jump target.
2378 if (node->continue_target()->is_linked()) {
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002379 node->continue_target()->Bind();
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002380 }
christian.plesner.hansen@gmail.com9d58c2b2009-10-16 11:48:38 +00002381 break;
2382 case DONT_KNOW:
2383 // We have to compile the test expression if it can be reached by
2384 // control flow falling out of the body or via continue.
2385 if (node->continue_target()->is_linked()) {
2386 node->continue_target()->Bind();
2387 }
2388 if (has_valid_frame()) {
ager@chromium.orgc4c92722009-11-18 14:12:51 +00002389 Comment cmnt(masm_, "[ DoWhileCondition");
2390 CodeForDoWhileConditionPosition(node);
ricow@chromium.org30ce4112010-05-31 10:38:25 +00002391 LoadCondition(node->cond(), &body, node->break_target(), true);
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002392 if (has_valid_frame()) {
christian.plesner.hansen@gmail.com9d58c2b2009-10-16 11:48:38 +00002393 // A invalid frame here indicates that control did not
2394 // fall out of the test expression.
2395 Branch(true, &body);
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002396 }
2397 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002398 break;
2399 }
2400
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002401 if (node->break_target()->is_linked()) {
2402 node->break_target()->Bind();
2403 }
ricow@chromium.orgc9c80822010-04-21 08:22:37 +00002404 DecrementLoopNesting();
christian.plesner.hansen@gmail.com9d58c2b2009-10-16 11:48:38 +00002405 ASSERT(!has_valid_frame() || frame_->height() == original_height);
2406}
2407
2408
2409void CodeGenerator::VisitWhileStatement(WhileStatement* node) {
2410#ifdef DEBUG
2411 int original_height = frame_->height();
2412#endif
christian.plesner.hansen@gmail.com9d58c2b2009-10-16 11:48:38 +00002413 Comment cmnt(masm_, "[ WhileStatement");
2414 CodeForStatementPosition(node);
2415
2416 // If the test is never true and has no side effects there is no need
2417 // to compile the test or body.
2418 ConditionAnalysis info = AnalyzeCondition(node->cond());
2419 if (info == ALWAYS_FALSE) return;
2420
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +00002421 node->break_target()->SetExpectedHeight();
ricow@chromium.orgc9c80822010-04-21 08:22:37 +00002422 IncrementLoopNesting();
christian.plesner.hansen@gmail.com9d58c2b2009-10-16 11:48:38 +00002423
2424 // Label the top of the loop with the continue target for the backward
2425 // CFG edge.
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +00002426 node->continue_target()->SetExpectedHeight();
christian.plesner.hansen@gmail.com9d58c2b2009-10-16 11:48:38 +00002427 node->continue_target()->Bind();
2428
2429 if (info == DONT_KNOW) {
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00002430 JumpTarget body(JumpTarget::BIDIRECTIONAL);
ricow@chromium.org30ce4112010-05-31 10:38:25 +00002431 LoadCondition(node->cond(), &body, node->break_target(), true);
christian.plesner.hansen@gmail.com9d58c2b2009-10-16 11:48:38 +00002432 if (has_valid_frame()) {
2433 // A NULL frame indicates that control did not fall out of the
2434 // test expression.
2435 Branch(false, node->break_target());
2436 }
2437 if (has_valid_frame() || body.is_linked()) {
2438 body.Bind();
2439 }
2440 }
2441
2442 if (has_valid_frame()) {
2443 CheckStack(); // TODO(1222600): ignore if body contains calls.
ricow@chromium.org30ce4112010-05-31 10:38:25 +00002444 Visit(node->body());
christian.plesner.hansen@gmail.com9d58c2b2009-10-16 11:48:38 +00002445
2446 // If control flow can fall out of the body, jump back to the top.
2447 if (has_valid_frame()) {
2448 node->continue_target()->Jump();
2449 }
2450 }
2451 if (node->break_target()->is_linked()) {
2452 node->break_target()->Bind();
2453 }
ricow@chromium.orgc9c80822010-04-21 08:22:37 +00002454 DecrementLoopNesting();
christian.plesner.hansen@gmail.com9d58c2b2009-10-16 11:48:38 +00002455 ASSERT(!has_valid_frame() || frame_->height() == original_height);
2456}
2457
2458
2459void CodeGenerator::VisitForStatement(ForStatement* node) {
2460#ifdef DEBUG
2461 int original_height = frame_->height();
2462#endif
christian.plesner.hansen@gmail.com9d58c2b2009-10-16 11:48:38 +00002463 Comment cmnt(masm_, "[ ForStatement");
2464 CodeForStatementPosition(node);
2465 if (node->init() != NULL) {
ricow@chromium.org30ce4112010-05-31 10:38:25 +00002466 Visit(node->init());
christian.plesner.hansen@gmail.com9d58c2b2009-10-16 11:48:38 +00002467 }
2468
2469 // If the test is never true there is no need to compile the test or
2470 // body.
2471 ConditionAnalysis info = AnalyzeCondition(node->cond());
2472 if (info == ALWAYS_FALSE) return;
2473
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +00002474 node->break_target()->SetExpectedHeight();
ricow@chromium.orgc9c80822010-04-21 08:22:37 +00002475 IncrementLoopNesting();
christian.plesner.hansen@gmail.com9d58c2b2009-10-16 11:48:38 +00002476
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00002477 // We know that the loop index is a smi if it is not modified in the
2478 // loop body and it is checked against a constant limit in the loop
2479 // condition. In this case, we reset the static type information of the
2480 // loop index to smi before compiling the body, the update expression, and
2481 // the bottom check of the loop condition.
2482 TypeInfoCodeGenState type_info_scope(this,
2483 node->is_fast_smi_loop() ?
whesse@chromium.org4a1fe7d2010-09-27 12:32:04 +00002484 node->loop_variable()->AsSlot() :
2485 NULL,
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00002486 TypeInfo::Smi());
2487
christian.plesner.hansen@gmail.com9d58c2b2009-10-16 11:48:38 +00002488 // If there is no update statement, label the top of the loop with the
2489 // continue target, otherwise with the loop target.
2490 JumpTarget loop(JumpTarget::BIDIRECTIONAL);
2491 if (node->next() == NULL) {
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +00002492 node->continue_target()->SetExpectedHeight();
christian.plesner.hansen@gmail.com9d58c2b2009-10-16 11:48:38 +00002493 node->continue_target()->Bind();
2494 } else {
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +00002495 node->continue_target()->SetExpectedHeight();
christian.plesner.hansen@gmail.com9d58c2b2009-10-16 11:48:38 +00002496 loop.Bind();
2497 }
2498
2499 // If the test is always true, there is no need to compile it.
2500 if (info == DONT_KNOW) {
2501 JumpTarget body;
ricow@chromium.org30ce4112010-05-31 10:38:25 +00002502 LoadCondition(node->cond(), &body, node->break_target(), true);
christian.plesner.hansen@gmail.com9d58c2b2009-10-16 11:48:38 +00002503 if (has_valid_frame()) {
2504 Branch(false, node->break_target());
2505 }
2506 if (has_valid_frame() || body.is_linked()) {
2507 body.Bind();
2508 }
2509 }
2510
2511 if (has_valid_frame()) {
2512 CheckStack(); // TODO(1222600): ignore if body contains calls.
ricow@chromium.org30ce4112010-05-31 10:38:25 +00002513 Visit(node->body());
christian.plesner.hansen@gmail.com9d58c2b2009-10-16 11:48:38 +00002514
2515 if (node->next() == NULL) {
2516 // If there is no update statement and control flow can fall out
2517 // of the loop, jump directly to the continue label.
2518 if (has_valid_frame()) {
2519 node->continue_target()->Jump();
2520 }
2521 } else {
2522 // If there is an update statement and control flow can reach it
2523 // via falling out of the body of the loop or continuing, we
2524 // compile the update statement.
2525 if (node->continue_target()->is_linked()) {
2526 node->continue_target()->Bind();
2527 }
2528 if (has_valid_frame()) {
2529 // Record source position of the statement as this code which is
2530 // after the code for the body actually belongs to the loop
2531 // statement and not the body.
2532 CodeForStatementPosition(node);
ricow@chromium.org30ce4112010-05-31 10:38:25 +00002533 Visit(node->next());
christian.plesner.hansen@gmail.com9d58c2b2009-10-16 11:48:38 +00002534 loop.Jump();
2535 }
2536 }
2537 }
2538 if (node->break_target()->is_linked()) {
2539 node->break_target()->Bind();
2540 }
ricow@chromium.orgc9c80822010-04-21 08:22:37 +00002541 DecrementLoopNesting();
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002542 ASSERT(!has_valid_frame() || frame_->height() == original_height);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002543}
2544
2545
ager@chromium.org7c537e22008-10-16 08:43:32 +00002546void CodeGenerator::VisitForInStatement(ForInStatement* node) {
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002547#ifdef DEBUG
2548 int original_height = frame_->height();
2549#endif
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002550 Comment cmnt(masm_, "[ ForInStatement");
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002551 CodeForStatementPosition(node);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002552
kasperl@chromium.org71affb52009-05-26 05:44:31 +00002553 JumpTarget primitive;
2554 JumpTarget jsobject;
2555 JumpTarget fixed_array;
2556 JumpTarget entry(JumpTarget::BIDIRECTIONAL);
2557 JumpTarget end_del_check;
2558 JumpTarget exit;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002559
2560 // Get the object to enumerate over (converted to JSObject).
ricow@chromium.org30ce4112010-05-31 10:38:25 +00002561 Load(node->enumerable());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002562
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00002563 VirtualFrame::SpilledScope spilled_scope(frame_);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002564 // Both SpiderMonkey and kjs ignore null and undefined in contrast
2565 // to the specification. 12.6.4 mandates a call to ToObject.
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002566 frame_->EmitPop(r0);
ager@chromium.orgab99eea2009-08-25 07:05:41 +00002567 __ LoadRoot(ip, Heap::kUndefinedValueRootIndex);
2568 __ cmp(r0, ip);
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002569 exit.Branch(eq);
ager@chromium.orgab99eea2009-08-25 07:05:41 +00002570 __ LoadRoot(ip, Heap::kNullValueRootIndex);
2571 __ cmp(r0, ip);
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002572 exit.Branch(eq);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002573
2574 // Stack layout in body:
2575 // [iteration counter (Smi)]
2576 // [length of array]
2577 // [FixedArray]
2578 // [Map or 0]
2579 // [Object]
2580
2581 // Check if enumerable is already a JSObject
2582 __ tst(r0, Operand(kSmiTagMask));
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002583 primitive.Branch(eq);
ager@chromium.orgeadaf222009-06-16 09:43:10 +00002584 __ CompareObjectType(r0, r1, r1, FIRST_JS_OBJECT_TYPE);
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002585 jsobject.Branch(hs);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002586
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002587 primitive.Bind();
2588 frame_->EmitPush(r0);
kmillikin@chromium.org13bd2942009-12-16 15:36:05 +00002589 frame_->InvokeBuiltin(Builtins::TO_OBJECT, CALL_JS, 1);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002590
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002591 jsobject.Bind();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002592 // Get the set of properties (as a FixedArray or Map).
sgjesse@chromium.orgac6aa172009-12-04 12:29:05 +00002593 // r0: value to be iterated over
2594 frame_->EmitPush(r0); // Push the object being iterated over.
2595
2596 // Check cache validity in generated code. This is a fast case for
2597 // the JSObject::IsSimpleEnum cache validity checks. If we cannot
2598 // guarantee cache validity, call the runtime system to check cache
2599 // validity or get the property names in a fixed array.
2600 JumpTarget call_runtime;
2601 JumpTarget loop(JumpTarget::BIDIRECTIONAL);
2602 JumpTarget check_prototype;
2603 JumpTarget use_cache;
2604 __ mov(r1, Operand(r0));
2605 loop.Bind();
2606 // Check that there are no elements.
2607 __ ldr(r2, FieldMemOperand(r1, JSObject::kElementsOffset));
2608 __ LoadRoot(r4, Heap::kEmptyFixedArrayRootIndex);
2609 __ cmp(r2, r4);
2610 call_runtime.Branch(ne);
2611 // Check that instance descriptors are not empty so that we can
2612 // check for an enum cache. Leave the map in r3 for the subsequent
2613 // prototype load.
2614 __ ldr(r3, FieldMemOperand(r1, HeapObject::kMapOffset));
2615 __ ldr(r2, FieldMemOperand(r3, Map::kInstanceDescriptorsOffset));
2616 __ LoadRoot(ip, Heap::kEmptyDescriptorArrayRootIndex);
2617 __ cmp(r2, ip);
2618 call_runtime.Branch(eq);
2619 // Check that there in an enum cache in the non-empty instance
2620 // descriptors. This is the case if the next enumeration index
2621 // field does not contain a smi.
2622 __ ldr(r2, FieldMemOperand(r2, DescriptorArray::kEnumerationIndexOffset));
2623 __ tst(r2, Operand(kSmiTagMask));
2624 call_runtime.Branch(eq);
2625 // For all objects but the receiver, check that the cache is empty.
2626 // r4: empty fixed array root.
2627 __ cmp(r1, r0);
2628 check_prototype.Branch(eq);
2629 __ ldr(r2, FieldMemOperand(r2, DescriptorArray::kEnumCacheBridgeCacheOffset));
2630 __ cmp(r2, r4);
2631 call_runtime.Branch(ne);
2632 check_prototype.Bind();
2633 // Load the prototype from the map and loop if non-null.
2634 __ ldr(r1, FieldMemOperand(r3, Map::kPrototypeOffset));
2635 __ LoadRoot(ip, Heap::kNullValueRootIndex);
2636 __ cmp(r1, ip);
2637 loop.Branch(ne);
2638 // The enum cache is valid. Load the map of the object being
2639 // iterated over and use the cache for the iteration.
2640 __ ldr(r0, FieldMemOperand(r0, HeapObject::kMapOffset));
2641 use_cache.Jump();
2642
2643 call_runtime.Bind();
2644 // Call the runtime to get the property names for the object.
2645 frame_->EmitPush(r0); // push the object (slot 4) for the runtime call
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002646 frame_->CallRuntime(Runtime::kGetPropertyNamesFast, 1);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002647
sgjesse@chromium.orgac6aa172009-12-04 12:29:05 +00002648 // If we got a map from the runtime call, we can do a fast
2649 // modification check. Otherwise, we got a fixed array, and we have
2650 // to do a slow check.
2651 // r0: map or fixed array (result from call to
2652 // Runtime::kGetPropertyNamesFast)
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002653 __ mov(r2, Operand(r0));
2654 __ ldr(r1, FieldMemOperand(r2, HeapObject::kMapOffset));
ager@chromium.orgab99eea2009-08-25 07:05:41 +00002655 __ LoadRoot(ip, Heap::kMetaMapRootIndex);
2656 __ cmp(r1, ip);
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002657 fixed_array.Branch(ne);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002658
sgjesse@chromium.orgac6aa172009-12-04 12:29:05 +00002659 use_cache.Bind();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002660 // Get enum cache
sgjesse@chromium.orgac6aa172009-12-04 12:29:05 +00002661 // r0: map (either the result from a call to
2662 // Runtime::kGetPropertyNamesFast or has been fetched directly from
2663 // the object)
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002664 __ mov(r1, Operand(r0));
2665 __ ldr(r1, FieldMemOperand(r1, Map::kInstanceDescriptorsOffset));
2666 __ ldr(r1, FieldMemOperand(r1, DescriptorArray::kEnumerationIndexOffset));
2667 __ ldr(r2,
2668 FieldMemOperand(r1, DescriptorArray::kEnumCacheBridgeCacheOffset));
2669
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002670 frame_->EmitPush(r0); // map
2671 frame_->EmitPush(r2); // enum cache bridge cache
mads.s.ager31e71382008-08-13 09:32:07 +00002672 __ ldr(r0, FieldMemOperand(r2, FixedArray::kLengthOffset));
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002673 frame_->EmitPush(r0);
mads.s.ager31e71382008-08-13 09:32:07 +00002674 __ mov(r0, Operand(Smi::FromInt(0)));
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002675 frame_->EmitPush(r0);
2676 entry.Jump();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002677
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002678 fixed_array.Bind();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002679 __ mov(r1, Operand(Smi::FromInt(0)));
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002680 frame_->EmitPush(r1); // insert 0 in place of Map
2681 frame_->EmitPush(r0);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002682
2683 // Push the length of the array and the initial index onto the stack.
mads.s.ager31e71382008-08-13 09:32:07 +00002684 __ ldr(r0, FieldMemOperand(r0, FixedArray::kLengthOffset));
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002685 frame_->EmitPush(r0);
mads.s.ager31e71382008-08-13 09:32:07 +00002686 __ mov(r0, Operand(Smi::FromInt(0))); // init index
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002687 frame_->EmitPush(r0);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002688
2689 // Condition.
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002690 entry.Bind();
mads.s.ager31e71382008-08-13 09:32:07 +00002691 // sp[0] : index
2692 // sp[1] : array/enum cache length
2693 // sp[2] : array or enum cache
2694 // sp[3] : 0 or map
2695 // sp[4] : enumerable
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002696 // Grab the current frame's height for the break and continue
2697 // targets only after all the state is pushed on the frame.
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +00002698 node->break_target()->SetExpectedHeight();
2699 node->continue_target()->SetExpectedHeight();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002700
sgjesse@chromium.org720dc0b2010-05-10 09:25:39 +00002701 // Load the current count to r0, load the length to r1.
kmillikin@chromium.org9155e252010-05-26 13:27:57 +00002702 __ Ldrd(r0, r1, frame_->ElementAt(0));
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00002703 __ cmp(r0, r1); // compare to the array length
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002704 node->break_target()->Branch(hs);
2705
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002706 // Get the i'th entry of the array.
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002707 __ ldr(r2, frame_->ElementAt(2));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002708 __ add(r2, r2, Operand(FixedArray::kHeaderSize - kHeapObjectTag));
2709 __ ldr(r3, MemOperand(r2, r0, LSL, kPointerSizeLog2 - kSmiTagSize));
2710
2711 // Get Map or 0.
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002712 __ ldr(r2, frame_->ElementAt(3));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002713 // Check if this (still) matches the map of the enumerable.
2714 // If not, we have to filter the key.
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002715 __ ldr(r1, frame_->ElementAt(4));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002716 __ ldr(r1, FieldMemOperand(r1, HeapObject::kMapOffset));
2717 __ cmp(r1, Operand(r2));
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002718 end_del_check.Branch(eq);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002719
2720 // Convert the entry to a string (or null if it isn't a property anymore).
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002721 __ ldr(r0, frame_->ElementAt(4)); // push enumerable
2722 frame_->EmitPush(r0);
2723 frame_->EmitPush(r3); // push entry
kmillikin@chromium.org13bd2942009-12-16 15:36:05 +00002724 frame_->InvokeBuiltin(Builtins::FILTER_KEY, CALL_JS, 2);
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00002725 __ mov(r3, Operand(r0), SetCC);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002726 // If the property has been removed while iterating, we just skip it.
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002727 node->continue_target()->Branch(eq);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002728
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002729 end_del_check.Bind();
2730 // Store the entry in the 'each' expression and take another spin in the
2731 // loop. r3: i'th entry of the enum cache (or string there of)
2732 frame_->EmitPush(r3); // push entry
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00002733 { VirtualFrame::RegisterAllocationScope scope(this);
2734 Reference each(this, node->each());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002735 if (!each.is_illegal()) {
mads.s.ager31e71382008-08-13 09:32:07 +00002736 if (each.size() > 0) {
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00002737 // Loading a reference may leave the frame in an unspilled state.
2738 frame_->SpillAll(); // Sync stack to memory.
2739 // Get the value (under the reference on the stack) from memory.
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002740 __ ldr(r0, frame_->ElementAt(each.size()));
2741 frame_->EmitPush(r0);
kmillikin@chromium.org69ea3962010-07-05 11:01:40 +00002742 each.SetValue(NOT_CONST_INIT, UNLIKELY_SMI);
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00002743 frame_->Drop(2); // The result of the set and the extra pushed value.
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +00002744 } else {
2745 // If the reference was to a slot we rely on the convenient property
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00002746 // that it doesn't matter whether a value (eg, ebx pushed above) is
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +00002747 // right on top of or right underneath a zero-sized reference.
kmillikin@chromium.org69ea3962010-07-05 11:01:40 +00002748 each.SetValue(NOT_CONST_INIT, UNLIKELY_SMI);
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00002749 frame_->Drop(1); // Drop the result of the set operation.
mads.s.ager31e71382008-08-13 09:32:07 +00002750 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002751 }
2752 }
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002753 // Body.
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002754 CheckStack(); // TODO(1222600): ignore if body contains calls.
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00002755 { VirtualFrame::RegisterAllocationScope scope(this);
2756 Visit(node->body());
2757 }
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002758
ager@chromium.orgbb29dc92009-03-24 13:25:23 +00002759 // Next. Reestablish a spilled frame in case we are coming here via
2760 // a continue in the body.
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002761 node->continue_target()->Bind();
ager@chromium.orgbb29dc92009-03-24 13:25:23 +00002762 frame_->SpillAll();
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002763 frame_->EmitPop(r0);
2764 __ add(r0, r0, Operand(Smi::FromInt(1)));
2765 frame_->EmitPush(r0);
2766 entry.Jump();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002767
ager@chromium.orgbb29dc92009-03-24 13:25:23 +00002768 // Cleanup. No need to spill because VirtualFrame::Drop is safe for
2769 // any frame.
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002770 node->break_target()->Bind();
ager@chromium.org3bf7b912008-11-17 09:09:45 +00002771 frame_->Drop(5);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002772
2773 // Exit.
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002774 exit.Bind();
2775 node->continue_target()->Unuse();
2776 node->break_target()->Unuse();
2777 ASSERT(frame_->height() == original_height);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002778}
2779
2780
christian.plesner.hansen@gmail.com9d58c2b2009-10-16 11:48:38 +00002781void CodeGenerator::VisitTryCatchStatement(TryCatchStatement* node) {
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002782#ifdef DEBUG
2783 int original_height = frame_->height();
2784#endif
ager@chromium.org357bf652010-04-12 11:30:10 +00002785 VirtualFrame::SpilledScope spilled_scope(frame_);
christian.plesner.hansen@gmail.com9d58c2b2009-10-16 11:48:38 +00002786 Comment cmnt(masm_, "[ TryCatchStatement");
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002787 CodeForStatementPosition(node);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002788
kasperl@chromium.org71affb52009-05-26 05:44:31 +00002789 JumpTarget try_block;
2790 JumpTarget exit;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002791
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002792 try_block.Call();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002793 // --- Catch block ---
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002794 frame_->EmitPush(r0);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002795
2796 // Store the caught exception in the catch variable.
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00002797 Variable* catch_var = node->catch_var()->var();
whesse@chromium.org4a1fe7d2010-09-27 12:32:04 +00002798 ASSERT(catch_var != NULL && catch_var->AsSlot() != NULL);
2799 StoreToSlot(catch_var->AsSlot(), NOT_CONST_INIT);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002800
2801 // Remove the exception from the stack.
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002802 frame_->Drop();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002803
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00002804 { VirtualFrame::RegisterAllocationScope scope(this);
2805 VisitStatements(node->catch_block()->statements());
2806 }
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002807 if (frame_ != NULL) {
2808 exit.Jump();
2809 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002810
2811
2812 // --- Try block ---
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002813 try_block.Bind();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002814
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002815 frame_->PushTryHandler(TRY_CATCH_HANDLER);
2816 int handler_height = frame_->height();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002817
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00002818 // Shadow the labels for all escapes from the try block, including
2819 // returns. During shadowing, the original label is hidden as the
2820 // LabelShadow and operations on the original actually affect the
2821 // shadowing label.
2822 //
2823 // We should probably try to unify the escaping labels and the return
2824 // label.
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002825 int nof_escapes = node->escaping_targets()->length();
2826 List<ShadowTarget*> shadows(1 + nof_escapes);
2827
2828 // Add the shadow target for the function return.
2829 static const int kReturnShadowIndex = 0;
2830 shadows.Add(new ShadowTarget(&function_return_));
2831 bool function_return_was_shadowed = function_return_is_shadowed_;
2832 function_return_is_shadowed_ = true;
2833 ASSERT(shadows[kReturnShadowIndex]->other_target() == &function_return_);
2834
2835 // Add the remaining shadow targets.
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002836 for (int i = 0; i < nof_escapes; i++) {
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002837 shadows.Add(new ShadowTarget(node->escaping_targets()->at(i)));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002838 }
2839
2840 // Generate code for the statements in the try block.
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00002841 { VirtualFrame::RegisterAllocationScope scope(this);
2842 VisitStatements(node->try_block()->statements());
2843 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002844
2845 // Stop the introduced shadowing and count the number of required unlinks.
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00002846 // After shadowing stops, the original labels are unshadowed and the
2847 // LabelShadows represent the formerly shadowing labels.
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002848 bool has_unlinks = false;
2849 for (int i = 0; i < shadows.length(); i++) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002850 shadows[i]->StopShadowing();
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002851 has_unlinks = has_unlinks || shadows[i]->is_linked();
2852 }
2853 function_return_is_shadowed_ = function_return_was_shadowed;
2854
2855 // Get an external reference to the handler address.
2856 ExternalReference handler_address(Top::k_handler_address);
2857
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002858 // If we can fall off the end of the try block, unlink from try chain.
2859 if (has_valid_frame()) {
ager@chromium.orgeadaf222009-06-16 09:43:10 +00002860 // The next handler address is on top of the frame. Unlink from
2861 // the handler list and drop the rest of this handler from the
2862 // frame.
whesse@chromium.orgba5a61b2010-07-26 11:44:40 +00002863 STATIC_ASSERT(StackHandlerConstants::kNextOffset == 0);
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00002864 frame_->EmitPop(r1); // r0 can contain the return value.
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002865 __ mov(r3, Operand(handler_address));
2866 __ str(r1, MemOperand(r3));
ager@chromium.orgeadaf222009-06-16 09:43:10 +00002867 frame_->Drop(StackHandlerConstants::kSize / kPointerSize - 1);
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002868 if (has_unlinks) {
2869 exit.Jump();
2870 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002871 }
2872
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00002873 // Generate unlink code for the (formerly) shadowing labels that have been
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002874 // jumped to. Deallocate each shadow target.
2875 for (int i = 0; i < shadows.length(); i++) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002876 if (shadows[i]->is_linked()) {
mads.s.ager31e71382008-08-13 09:32:07 +00002877 // Unlink from try chain;
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002878 shadows[i]->Bind();
2879 // Because we can be jumping here (to spilled code) from unspilled
2880 // code, we need to reestablish a spilled frame at this block.
2881 frame_->SpillAll();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002882
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002883 // Reload sp from the top handler, because some statements that we
2884 // break from (eg, for...in) may have left stuff on the stack.
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002885 __ mov(r3, Operand(handler_address));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002886 __ ldr(sp, MemOperand(r3));
ager@chromium.orgeadaf222009-06-16 09:43:10 +00002887 frame_->Forget(frame_->height() - handler_height);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002888
whesse@chromium.orgba5a61b2010-07-26 11:44:40 +00002889 STATIC_ASSERT(StackHandlerConstants::kNextOffset == 0);
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00002890 frame_->EmitPop(r1); // r0 can contain the return value.
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002891 __ str(r1, MemOperand(r3));
ager@chromium.org3bf7b912008-11-17 09:09:45 +00002892 frame_->Drop(StackHandlerConstants::kSize / kPointerSize - 1);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002893
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002894 if (!function_return_is_shadowed_ && i == kReturnShadowIndex) {
2895 frame_->PrepareForReturn();
2896 }
2897 shadows[i]->other_target()->Jump();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002898 }
2899 }
2900
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002901 exit.Bind();
2902 ASSERT(!has_valid_frame() || frame_->height() == original_height);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002903}
2904
2905
christian.plesner.hansen@gmail.com9d58c2b2009-10-16 11:48:38 +00002906void CodeGenerator::VisitTryFinallyStatement(TryFinallyStatement* node) {
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002907#ifdef DEBUG
2908 int original_height = frame_->height();
2909#endif
ager@chromium.org357bf652010-04-12 11:30:10 +00002910 VirtualFrame::SpilledScope spilled_scope(frame_);
christian.plesner.hansen@gmail.com9d58c2b2009-10-16 11:48:38 +00002911 Comment cmnt(masm_, "[ TryFinallyStatement");
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002912 CodeForStatementPosition(node);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002913
2914 // State: Used to keep track of reason for entering the finally
2915 // block. Should probably be extended to hold information for
2916 // break/continue from within the try block.
2917 enum { FALLING, THROWING, JUMPING };
2918
kasperl@chromium.org71affb52009-05-26 05:44:31 +00002919 JumpTarget try_block;
2920 JumpTarget finally_block;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002921
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002922 try_block.Call();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002923
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002924 frame_->EmitPush(r0); // save exception object on the stack
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002925 // In case of thrown exceptions, this is where we continue.
2926 __ mov(r2, Operand(Smi::FromInt(THROWING)));
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002927 finally_block.Jump();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002928
2929 // --- Try block ---
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002930 try_block.Bind();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002931
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002932 frame_->PushTryHandler(TRY_FINALLY_HANDLER);
2933 int handler_height = frame_->height();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002934
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00002935 // Shadow the labels for all escapes from the try block, including
2936 // returns. Shadowing hides the original label as the LabelShadow and
2937 // operations on the original actually affect the shadowing label.
2938 //
2939 // We should probably try to unify the escaping labels and the return
2940 // label.
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002941 int nof_escapes = node->escaping_targets()->length();
2942 List<ShadowTarget*> shadows(1 + nof_escapes);
2943
2944 // Add the shadow target for the function return.
2945 static const int kReturnShadowIndex = 0;
2946 shadows.Add(new ShadowTarget(&function_return_));
2947 bool function_return_was_shadowed = function_return_is_shadowed_;
2948 function_return_is_shadowed_ = true;
2949 ASSERT(shadows[kReturnShadowIndex]->other_target() == &function_return_);
2950
2951 // Add the remaining shadow targets.
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002952 for (int i = 0; i < nof_escapes; i++) {
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002953 shadows.Add(new ShadowTarget(node->escaping_targets()->at(i)));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002954 }
2955
2956 // Generate code for the statements in the try block.
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00002957 { VirtualFrame::RegisterAllocationScope scope(this);
2958 VisitStatements(node->try_block()->statements());
2959 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002960
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00002961 // Stop the introduced shadowing and count the number of required unlinks.
2962 // After shadowing stops, the original labels are unshadowed and the
2963 // LabelShadows represent the formerly shadowing labels.
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002964 int nof_unlinks = 0;
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002965 for (int i = 0; i < shadows.length(); i++) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002966 shadows[i]->StopShadowing();
2967 if (shadows[i]->is_linked()) nof_unlinks++;
2968 }
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002969 function_return_is_shadowed_ = function_return_was_shadowed;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002970
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002971 // Get an external reference to the handler address.
2972 ExternalReference handler_address(Top::k_handler_address);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002973
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002974 // If we can fall off the end of the try block, unlink from the try
2975 // chain and set the state on the frame to FALLING.
2976 if (has_valid_frame()) {
ager@chromium.orgeadaf222009-06-16 09:43:10 +00002977 // The next handler address is on top of the frame.
whesse@chromium.orgba5a61b2010-07-26 11:44:40 +00002978 STATIC_ASSERT(StackHandlerConstants::kNextOffset == 0);
ager@chromium.orgeadaf222009-06-16 09:43:10 +00002979 frame_->EmitPop(r1);
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002980 __ mov(r3, Operand(handler_address));
2981 __ str(r1, MemOperand(r3));
ager@chromium.orgeadaf222009-06-16 09:43:10 +00002982 frame_->Drop(StackHandlerConstants::kSize / kPointerSize - 1);
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002983
2984 // Fake a top of stack value (unneeded when FALLING) and set the
2985 // state in r2, then jump around the unlink blocks if any.
ager@chromium.orgab99eea2009-08-25 07:05:41 +00002986 __ LoadRoot(r0, Heap::kUndefinedValueRootIndex);
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002987 frame_->EmitPush(r0);
2988 __ mov(r2, Operand(Smi::FromInt(FALLING)));
2989 if (nof_unlinks > 0) {
2990 finally_block.Jump();
2991 }
2992 }
2993
2994 // Generate code to unlink and set the state for the (formerly)
2995 // shadowing targets that have been jumped to.
2996 for (int i = 0; i < shadows.length(); i++) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002997 if (shadows[i]->is_linked()) {
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002998 // If we have come from the shadowed return, the return value is
2999 // in (a non-refcounted reference to) r0. We must preserve it
3000 // until it is pushed.
3001 //
3002 // Because we can be jumping here (to spilled code) from
3003 // unspilled code, we need to reestablish a spilled frame at
3004 // this block.
3005 shadows[i]->Bind();
3006 frame_->SpillAll();
3007
3008 // Reload sp from the top handler, because some statements that
3009 // we break from (eg, for...in) may have left stuff on the
3010 // stack.
3011 __ mov(r3, Operand(handler_address));
3012 __ ldr(sp, MemOperand(r3));
ager@chromium.orgeadaf222009-06-16 09:43:10 +00003013 frame_->Forget(frame_->height() - handler_height);
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00003014
3015 // Unlink this handler and drop it from the frame. The next
ager@chromium.orgeadaf222009-06-16 09:43:10 +00003016 // handler address is currently on top of the frame.
whesse@chromium.orgba5a61b2010-07-26 11:44:40 +00003017 STATIC_ASSERT(StackHandlerConstants::kNextOffset == 0);
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00003018 frame_->EmitPop(r1);
3019 __ str(r1, MemOperand(r3));
ager@chromium.orgeadaf222009-06-16 09:43:10 +00003020 frame_->Drop(StackHandlerConstants::kSize / kPointerSize - 1);
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00003021
3022 if (i == kReturnShadowIndex) {
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00003023 // If this label shadowed the function return, materialize the
3024 // return value on the stack.
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00003025 frame_->EmitPush(r0);
mads.s.ager31e71382008-08-13 09:32:07 +00003026 } else {
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00003027 // Fake TOS for targets that shadowed breaks and continues.
ager@chromium.orgab99eea2009-08-25 07:05:41 +00003028 __ LoadRoot(r0, Heap::kUndefinedValueRootIndex);
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00003029 frame_->EmitPush(r0);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003030 }
3031 __ mov(r2, Operand(Smi::FromInt(JUMPING + i)));
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00003032 if (--nof_unlinks > 0) {
3033 // If this is not the last unlink block, jump around the next.
3034 finally_block.Jump();
3035 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003036 }
3037 }
3038
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003039 // --- Finally block ---
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00003040 finally_block.Bind();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003041
kasperl@chromium.org41044eb2008-10-06 08:24:46 +00003042 // Push the state on the stack.
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00003043 frame_->EmitPush(r2);
kasperl@chromium.org41044eb2008-10-06 08:24:46 +00003044
3045 // We keep two elements on the stack - the (possibly faked) result
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00003046 // and the state - while evaluating the finally block.
3047 //
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003048 // Generate code for the statements in the finally block.
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00003049 { VirtualFrame::RegisterAllocationScope scope(this);
3050 VisitStatements(node->finally_block()->statements());
3051 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003052
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00003053 if (has_valid_frame()) {
3054 // Restore state and return value or faked TOS.
3055 frame_->EmitPop(r2);
3056 frame_->EmitPop(r0);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003057 }
3058
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00003059 // Generate code to jump to the right destination for all used
3060 // formerly shadowing targets. Deallocate each shadow target.
3061 for (int i = 0; i < shadows.length(); i++) {
3062 if (has_valid_frame() && shadows[i]->is_bound()) {
3063 JumpTarget* original = shadows[i]->other_target();
3064 __ cmp(r2, Operand(Smi::FromInt(JUMPING + i)));
3065 if (!function_return_is_shadowed_ && i == kReturnShadowIndex) {
kasperl@chromium.org71affb52009-05-26 05:44:31 +00003066 JumpTarget skip;
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00003067 skip.Branch(ne);
3068 frame_->PrepareForReturn();
3069 original->Jump();
3070 skip.Bind();
3071 } else {
3072 original->Branch(eq);
3073 }
3074 }
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00003075 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003076
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00003077 if (has_valid_frame()) {
3078 // Check if we need to rethrow the exception.
kasperl@chromium.org71affb52009-05-26 05:44:31 +00003079 JumpTarget exit;
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00003080 __ cmp(r2, Operand(Smi::FromInt(THROWING)));
3081 exit.Branch(ne);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003082
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00003083 // Rethrow exception.
3084 frame_->EmitPush(r0);
3085 frame_->CallRuntime(Runtime::kReThrow, 1);
3086
3087 // Done.
3088 exit.Bind();
3089 }
3090 ASSERT(!has_valid_frame() || frame_->height() == original_height);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003091}
3092
3093
ager@chromium.org7c537e22008-10-16 08:43:32 +00003094void CodeGenerator::VisitDebuggerStatement(DebuggerStatement* node) {
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00003095#ifdef DEBUG
3096 int original_height = frame_->height();
3097#endif
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003098 Comment cmnt(masm_, "[ DebuggerStatament");
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00003099 CodeForStatementPosition(node);
ager@chromium.org65dad4b2009-04-23 08:48:43 +00003100#ifdef ENABLE_DEBUGGER_SUPPORT
ager@chromium.org5c838252010-02-19 08:53:10 +00003101 frame_->DebugBreak();
ager@chromium.org65dad4b2009-04-23 08:48:43 +00003102#endif
kasperl@chromium.org9fe21c62008-10-28 08:53:51 +00003103 // Ignore the return value.
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00003104 ASSERT(frame_->height() == original_height);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003105}
3106
3107
kmillikin@chromium.org5d8f0e62010-03-24 08:21:20 +00003108void CodeGenerator::InstantiateFunction(
vegorov@chromium.org21b5e952010-11-23 10:24:40 +00003109 Handle<SharedFunctionInfo> function_info,
3110 bool pretenure) {
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00003111 // Use the fast case closure allocation code that allocates in new
3112 // space for nested functions that don't need literals cloning.
vegorov@chromium.org21b5e952010-11-23 10:24:40 +00003113 if (scope()->is_function_scope() &&
3114 function_info->num_literals() == 0 &&
3115 !pretenure) {
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00003116 FastNewClosureStub stub;
ricow@chromium.org30ce4112010-05-31 10:38:25 +00003117 frame_->EmitPush(Operand(function_info));
3118 frame_->SpillAll();
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00003119 frame_->CallStub(&stub, 1);
3120 frame_->EmitPush(r0);
3121 } else {
3122 // Create a new closure.
3123 frame_->EmitPush(cp);
ricow@chromium.org30ce4112010-05-31 10:38:25 +00003124 frame_->EmitPush(Operand(function_info));
vegorov@chromium.org21b5e952010-11-23 10:24:40 +00003125 frame_->EmitPush(Operand(pretenure
3126 ? Factory::true_value()
3127 : Factory::false_value()));
3128 frame_->CallRuntime(Runtime::kNewClosure, 3);
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00003129 frame_->EmitPush(r0);
3130 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003131}
3132
3133
ager@chromium.org7c537e22008-10-16 08:43:32 +00003134void CodeGenerator::VisitFunctionLiteral(FunctionLiteral* node) {
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00003135#ifdef DEBUG
3136 int original_height = frame_->height();
3137#endif
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003138 Comment cmnt(masm_, "[ FunctionLiteral");
3139
kmillikin@chromium.org5d8f0e62010-03-24 08:21:20 +00003140 // Build the function info and instantiate it.
3141 Handle<SharedFunctionInfo> function_info =
ager@chromium.orgb61a0d12010-10-13 08:35:23 +00003142 Compiler::BuildFunctionInfo(node, script());
3143 if (function_info.is_null()) {
3144 SetStackOverflow();
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00003145 ASSERT(frame_->height() == original_height);
3146 return;
3147 }
vegorov@chromium.org21b5e952010-11-23 10:24:40 +00003148 InstantiateFunction(function_info, node->pretenure());
ager@chromium.orgac091b72010-05-05 07:34:42 +00003149 ASSERT_EQ(original_height + 1, frame_->height());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003150}
3151
3152
kmillikin@chromium.org5d8f0e62010-03-24 08:21:20 +00003153void CodeGenerator::VisitSharedFunctionInfoLiteral(
3154 SharedFunctionInfoLiteral* node) {
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00003155#ifdef DEBUG
3156 int original_height = frame_->height();
3157#endif
kmillikin@chromium.org5d8f0e62010-03-24 08:21:20 +00003158 Comment cmnt(masm_, "[ SharedFunctionInfoLiteral");
vegorov@chromium.org21b5e952010-11-23 10:24:40 +00003159 InstantiateFunction(node->shared_function_info(), false);
ager@chromium.orgac091b72010-05-05 07:34:42 +00003160 ASSERT_EQ(original_height + 1, frame_->height());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003161}
3162
3163
ager@chromium.org7c537e22008-10-16 08:43:32 +00003164void CodeGenerator::VisitConditional(Conditional* node) {
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00003165#ifdef DEBUG
3166 int original_height = frame_->height();
3167#endif
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003168 Comment cmnt(masm_, "[ Conditional");
kasperl@chromium.org71affb52009-05-26 05:44:31 +00003169 JumpTarget then;
3170 JumpTarget else_;
ricow@chromium.org30ce4112010-05-31 10:38:25 +00003171 LoadCondition(node->condition(), &then, &else_, true);
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00003172 if (has_valid_frame()) {
3173 Branch(false, &else_);
3174 }
3175 if (has_valid_frame() || then.is_linked()) {
3176 then.Bind();
ricow@chromium.org30ce4112010-05-31 10:38:25 +00003177 Load(node->then_expression());
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00003178 }
3179 if (else_.is_linked()) {
3180 JumpTarget exit;
3181 if (has_valid_frame()) exit.Jump();
3182 else_.Bind();
ricow@chromium.org30ce4112010-05-31 10:38:25 +00003183 Load(node->else_expression());
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00003184 if (exit.is_linked()) exit.Bind();
3185 }
ager@chromium.orgac091b72010-05-05 07:34:42 +00003186 ASSERT_EQ(original_height + 1, frame_->height());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003187}
3188
3189
ager@chromium.org7c537e22008-10-16 08:43:32 +00003190void CodeGenerator::LoadFromSlot(Slot* slot, TypeofState typeof_state) {
3191 if (slot->type() == Slot::LOOKUP) {
ager@chromium.org381abbb2009-02-25 13:23:22 +00003192 ASSERT(slot->var()->is_dynamic());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003193
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00003194 // JumpTargets do not yet support merging frames so the frame must be
3195 // spilled when jumping to these targets.
kasperl@chromium.org71affb52009-05-26 05:44:31 +00003196 JumpTarget slow;
3197 JumpTarget done;
ager@chromium.org381abbb2009-02-25 13:23:22 +00003198
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +00003199 // Generate fast case for loading from slots that correspond to
3200 // local/global variables or arguments unless they are shadowed by
3201 // eval-introduced bindings.
3202 EmitDynamicLoadFromSlotFastCase(slot,
3203 typeof_state,
3204 &slow,
3205 &done);
ager@chromium.org381abbb2009-02-25 13:23:22 +00003206
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00003207 slow.Bind();
3208 frame_->EmitPush(cp);
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00003209 frame_->EmitPush(Operand(slot->var()->name()));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003210
ager@chromium.org7c537e22008-10-16 08:43:32 +00003211 if (typeof_state == INSIDE_TYPEOF) {
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00003212 frame_->CallRuntime(Runtime::kLoadContextSlotNoReferenceError, 2);
ager@chromium.org7c537e22008-10-16 08:43:32 +00003213 } else {
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00003214 frame_->CallRuntime(Runtime::kLoadContextSlot, 2);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003215 }
ager@chromium.org381abbb2009-02-25 13:23:22 +00003216
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00003217 done.Bind();
3218 frame_->EmitPush(r0);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003219
3220 } else {
ager@chromium.org357bf652010-04-12 11:30:10 +00003221 Register scratch = VirtualFrame::scratch0();
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00003222 TypeInfo info = type_info(slot);
3223 frame_->EmitPush(SlotOperand(slot, scratch), info);
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00003224
ager@chromium.org7c537e22008-10-16 08:43:32 +00003225 if (slot->var()->mode() == Variable::CONST) {
kasperl@chromium.orgb9123622008-09-17 14:05:56 +00003226 // Const slots may contain 'the hole' value (the constant hasn't been
3227 // initialized yet) which needs to be converted into the 'undefined'
3228 // value.
3229 Comment cmnt(masm_, "[ Unhole const");
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00003230 Register tos = frame_->PopToRegister();
ager@chromium.orgab99eea2009-08-25 07:05:41 +00003231 __ LoadRoot(ip, Heap::kTheHoleValueRootIndex);
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00003232 __ cmp(tos, ip);
3233 __ LoadRoot(tos, Heap::kUndefinedValueRootIndex, eq);
3234 frame_->EmitPush(tos);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003235 }
3236 }
3237}
3238
3239
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00003240void CodeGenerator::LoadFromSlotCheckForArguments(Slot* slot,
3241 TypeofState state) {
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00003242 VirtualFrame::RegisterAllocationScope scope(this);
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00003243 LoadFromSlot(slot, state);
3244
3245 // Bail out quickly if we're not using lazy arguments allocation.
3246 if (ArgumentsMode() != LAZY_ARGUMENTS_ALLOCATION) return;
3247
3248 // ... or if the slot isn't a non-parameter arguments slot.
3249 if (slot->type() == Slot::PARAMETER || !slot->is_arguments()) return;
3250
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00003251 // Load the loaded value from the stack into a register but leave it on the
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00003252 // stack.
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00003253 Register tos = frame_->Peek();
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00003254
3255 // If the loaded value is the sentinel that indicates that we
3256 // haven't loaded the arguments object yet, we need to do it now.
3257 JumpTarget exit;
kmillikin@chromium.orgd2c22f02011-01-10 08:15:37 +00003258 __ LoadRoot(ip, Heap::kArgumentsMarkerRootIndex);
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00003259 __ cmp(tos, ip);
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00003260 exit.Branch(ne);
3261 frame_->Drop();
3262 StoreArgumentsObject(false);
3263 exit.Bind();
3264}
3265
3266
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00003267void CodeGenerator::StoreToSlot(Slot* slot, InitState init_state) {
3268 ASSERT(slot != NULL);
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00003269 VirtualFrame::RegisterAllocationScope scope(this);
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00003270 if (slot->type() == Slot::LOOKUP) {
3271 ASSERT(slot->var()->is_dynamic());
3272
3273 // For now, just do a runtime call.
3274 frame_->EmitPush(cp);
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00003275 frame_->EmitPush(Operand(slot->var()->name()));
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00003276
3277 if (init_state == CONST_INIT) {
3278 // Same as the case for a normal store, but ignores attribute
3279 // (e.g. READ_ONLY) of context slot so that we can initialize
3280 // const properties (introduced via eval("const foo = (some
3281 // expr);")). Also, uses the current function context instead of
3282 // the top context.
3283 //
3284 // Note that we must declare the foo upon entry of eval(), via a
3285 // context slot declaration, but we cannot initialize it at the
3286 // same time, because the const declaration may be at the end of
3287 // the eval code (sigh...) and the const variable may have been
3288 // used before (where its value is 'undefined'). Thus, we can only
3289 // do the initialization when we actually encounter the expression
3290 // and when the expression operands are defined and valid, and
3291 // thus we need the split into 2 operations: declaration of the
3292 // context slot followed by initialization.
3293 frame_->CallRuntime(Runtime::kInitializeConstContextSlot, 3);
3294 } else {
3295 frame_->CallRuntime(Runtime::kStoreContextSlot, 3);
3296 }
3297 // Storing a variable must keep the (new) value on the expression
3298 // stack. This is necessary for compiling assignment expressions.
3299 frame_->EmitPush(r0);
3300
3301 } else {
3302 ASSERT(!slot->var()->is_dynamic());
ager@chromium.org357bf652010-04-12 11:30:10 +00003303 Register scratch = VirtualFrame::scratch0();
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00003304 Register scratch2 = VirtualFrame::scratch1();
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00003305
ager@chromium.org357bf652010-04-12 11:30:10 +00003306 // The frame must be spilled when branching to this target.
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00003307 JumpTarget exit;
ager@chromium.org357bf652010-04-12 11:30:10 +00003308
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00003309 if (init_state == CONST_INIT) {
3310 ASSERT(slot->var()->mode() == Variable::CONST);
3311 // Only the first const initialization must be executed (the slot
3312 // still contains 'the hole' value). When the assignment is
3313 // executed, the code is identical to a normal store (see below).
3314 Comment cmnt(masm_, "[ Init const");
ager@chromium.org357bf652010-04-12 11:30:10 +00003315 __ ldr(scratch, SlotOperand(slot, scratch));
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00003316 __ LoadRoot(ip, Heap::kTheHoleValueRootIndex);
ager@chromium.org357bf652010-04-12 11:30:10 +00003317 __ cmp(scratch, ip);
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00003318 exit.Branch(ne);
3319 }
3320
3321 // We must execute the store. Storing a variable must keep the
3322 // (new) value on the stack. This is necessary for compiling
3323 // assignment expressions.
3324 //
3325 // Note: We will reach here even with slot->var()->mode() ==
3326 // Variable::CONST because of const declarations which will
3327 // initialize consts to 'the hole' value and by doing so, end up
3328 // calling this code. r2 may be loaded with context; used below in
3329 // RecordWrite.
ager@chromium.org357bf652010-04-12 11:30:10 +00003330 Register tos = frame_->Peek();
3331 __ str(tos, SlotOperand(slot, scratch));
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00003332 if (slot->type() == Slot::CONTEXT) {
3333 // Skip write barrier if the written value is a smi.
ager@chromium.org357bf652010-04-12 11:30:10 +00003334 __ tst(tos, Operand(kSmiTagMask));
3335 // We don't use tos any more after here.
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00003336 exit.Branch(eq);
ager@chromium.org357bf652010-04-12 11:30:10 +00003337 // scratch is loaded with context when calling SlotOperand above.
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00003338 int offset = FixedArray::kHeaderSize + slot->index() * kPointerSize;
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00003339 // We need an extra register. Until we have a way to do that in the
3340 // virtual frame we will cheat and ask for a free TOS register.
3341 Register scratch3 = frame_->GetTOSRegister();
3342 __ RecordWrite(scratch, Operand(offset), scratch2, scratch3);
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00003343 }
3344 // If we definitely did not jump over the assignment, we do not need
3345 // to bind the exit label. Doing so can defeat peephole
3346 // optimization.
3347 if (init_state == CONST_INIT || slot->type() == Slot::CONTEXT) {
3348 exit.Bind();
3349 }
3350 }
3351}
3352
3353
ager@chromium.org381abbb2009-02-25 13:23:22 +00003354void CodeGenerator::LoadFromGlobalSlotCheckExtensions(Slot* slot,
3355 TypeofState typeof_state,
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00003356 JumpTarget* slow) {
ager@chromium.org381abbb2009-02-25 13:23:22 +00003357 // Check that no extension objects have been created by calls to
3358 // eval from the current scope to the global scope.
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00003359 Register tmp = frame_->scratch0();
3360 Register tmp2 = frame_->scratch1();
ager@chromium.org381abbb2009-02-25 13:23:22 +00003361 Register context = cp;
3362 Scope* s = scope();
3363 while (s != NULL) {
3364 if (s->num_heap_slots() > 0) {
3365 if (s->calls_eval()) {
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00003366 frame_->SpillAll();
ager@chromium.org381abbb2009-02-25 13:23:22 +00003367 // Check that extension is NULL.
3368 __ ldr(tmp2, ContextOperand(context, Context::EXTENSION_INDEX));
3369 __ tst(tmp2, tmp2);
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00003370 slow->Branch(ne);
ager@chromium.org381abbb2009-02-25 13:23:22 +00003371 }
3372 // Load next context in chain.
3373 __ ldr(tmp, ContextOperand(context, Context::CLOSURE_INDEX));
3374 __ ldr(tmp, FieldMemOperand(tmp, JSFunction::kContextOffset));
3375 context = tmp;
3376 }
3377 // If no outer scope calls eval, we do not need to check more
3378 // context extensions.
3379 if (!s->outer_scope_calls_eval() || s->is_eval_scope()) break;
3380 s = s->outer_scope();
3381 }
3382
3383 if (s->is_eval_scope()) {
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00003384 frame_->SpillAll();
ager@chromium.org381abbb2009-02-25 13:23:22 +00003385 Label next, fast;
ager@chromium.org357bf652010-04-12 11:30:10 +00003386 __ Move(tmp, context);
ager@chromium.org381abbb2009-02-25 13:23:22 +00003387 __ bind(&next);
3388 // Terminate at global context.
3389 __ ldr(tmp2, FieldMemOperand(tmp, HeapObject::kMapOffset));
ager@chromium.orgab99eea2009-08-25 07:05:41 +00003390 __ LoadRoot(ip, Heap::kGlobalContextMapRootIndex);
3391 __ cmp(tmp2, ip);
ager@chromium.org381abbb2009-02-25 13:23:22 +00003392 __ b(eq, &fast);
3393 // Check that extension is NULL.
3394 __ ldr(tmp2, ContextOperand(tmp, Context::EXTENSION_INDEX));
3395 __ tst(tmp2, tmp2);
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00003396 slow->Branch(ne);
ager@chromium.org381abbb2009-02-25 13:23:22 +00003397 // Load next context in chain.
3398 __ ldr(tmp, ContextOperand(tmp, Context::CLOSURE_INDEX));
3399 __ ldr(tmp, FieldMemOperand(tmp, JSFunction::kContextOffset));
3400 __ b(&next);
3401 __ bind(&fast);
3402 }
3403
ager@chromium.org381abbb2009-02-25 13:23:22 +00003404 // Load the global object.
3405 LoadGlobal();
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00003406 // Setup the name register and call load IC.
ager@chromium.orgac091b72010-05-05 07:34:42 +00003407 frame_->CallLoadIC(slot->var()->name(),
3408 typeof_state == INSIDE_TYPEOF
3409 ? RelocInfo::CODE_TARGET
3410 : RelocInfo::CODE_TARGET_CONTEXT);
ager@chromium.org381abbb2009-02-25 13:23:22 +00003411}
3412
3413
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +00003414void CodeGenerator::EmitDynamicLoadFromSlotFastCase(Slot* slot,
3415 TypeofState typeof_state,
3416 JumpTarget* slow,
3417 JumpTarget* done) {
3418 // Generate fast-case code for variables that might be shadowed by
3419 // eval-introduced variables. Eval is used a lot without
3420 // introducing variables. In those cases, we do not want to
3421 // perform a runtime call for all variables in the scope
3422 // containing the eval.
3423 if (slot->var()->mode() == Variable::DYNAMIC_GLOBAL) {
3424 LoadFromGlobalSlotCheckExtensions(slot, typeof_state, slow);
3425 frame_->SpillAll();
3426 done->Jump();
3427
3428 } else if (slot->var()->mode() == Variable::DYNAMIC_LOCAL) {
3429 frame_->SpillAll();
whesse@chromium.org4a1fe7d2010-09-27 12:32:04 +00003430 Slot* potential_slot = slot->var()->local_if_not_shadowed()->AsSlot();
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +00003431 Expression* rewrite = slot->var()->local_if_not_shadowed()->rewrite();
3432 if (potential_slot != NULL) {
3433 // Generate fast case for locals that rewrite to slots.
3434 __ ldr(r0,
3435 ContextSlotOperandCheckExtensions(potential_slot,
3436 r1,
3437 r2,
3438 slow));
3439 if (potential_slot->var()->mode() == Variable::CONST) {
3440 __ LoadRoot(ip, Heap::kTheHoleValueRootIndex);
3441 __ cmp(r0, ip);
3442 __ LoadRoot(r0, Heap::kUndefinedValueRootIndex, eq);
3443 }
3444 done->Jump();
3445 } else if (rewrite != NULL) {
3446 // Generate fast case for argument loads.
3447 Property* property = rewrite->AsProperty();
3448 if (property != NULL) {
3449 VariableProxy* obj_proxy = property->obj()->AsVariableProxy();
3450 Literal* key_literal = property->key()->AsLiteral();
3451 if (obj_proxy != NULL &&
3452 key_literal != NULL &&
3453 obj_proxy->IsArguments() &&
3454 key_literal->handle()->IsSmi()) {
3455 // Load arguments object if there are no eval-introduced
3456 // variables. Then load the argument from the arguments
3457 // object using keyed load.
3458 __ ldr(r0,
whesse@chromium.org4a1fe7d2010-09-27 12:32:04 +00003459 ContextSlotOperandCheckExtensions(obj_proxy->var()->AsSlot(),
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +00003460 r1,
3461 r2,
3462 slow));
3463 frame_->EmitPush(r0);
3464 __ mov(r1, Operand(key_literal->handle()));
3465 frame_->EmitPush(r1);
3466 EmitKeyedLoad();
3467 done->Jump();
3468 }
3469 }
3470 }
3471 }
3472}
3473
3474
ager@chromium.org7c537e22008-10-16 08:43:32 +00003475void CodeGenerator::VisitSlot(Slot* node) {
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00003476#ifdef DEBUG
3477 int original_height = frame_->height();
3478#endif
ager@chromium.org7c537e22008-10-16 08:43:32 +00003479 Comment cmnt(masm_, "[ Slot");
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00003480 LoadFromSlotCheckForArguments(node, NOT_INSIDE_TYPEOF);
ager@chromium.orgac091b72010-05-05 07:34:42 +00003481 ASSERT_EQ(original_height + 1, frame_->height());
ager@chromium.org7c537e22008-10-16 08:43:32 +00003482}
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003483
ager@chromium.org7c537e22008-10-16 08:43:32 +00003484
3485void CodeGenerator::VisitVariableProxy(VariableProxy* node) {
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00003486#ifdef DEBUG
3487 int original_height = frame_->height();
3488#endif
ager@chromium.org7c537e22008-10-16 08:43:32 +00003489 Comment cmnt(masm_, "[ VariableProxy");
3490
3491 Variable* var = node->var();
3492 Expression* expr = var->rewrite();
kasperl@chromium.orgb9123622008-09-17 14:05:56 +00003493 if (expr != NULL) {
3494 Visit(expr);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003495 } else {
ager@chromium.org7c537e22008-10-16 08:43:32 +00003496 ASSERT(var->is_global());
3497 Reference ref(this, node);
ager@chromium.org357bf652010-04-12 11:30:10 +00003498 ref.GetValue();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003499 }
ager@chromium.orgac091b72010-05-05 07:34:42 +00003500 ASSERT_EQ(original_height + 1, frame_->height());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003501}
3502
3503
ager@chromium.org7c537e22008-10-16 08:43:32 +00003504void CodeGenerator::VisitLiteral(Literal* node) {
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00003505#ifdef DEBUG
3506 int original_height = frame_->height();
3507#endif
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003508 Comment cmnt(masm_, "[ Literal");
ager@chromium.org357bf652010-04-12 11:30:10 +00003509 Register reg = frame_->GetTOSRegister();
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00003510 bool is_smi = node->handle()->IsSmi();
ager@chromium.org357bf652010-04-12 11:30:10 +00003511 __ mov(reg, Operand(node->handle()));
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00003512 frame_->EmitPush(reg, is_smi ? TypeInfo::Smi() : TypeInfo::Unknown());
ager@chromium.orgac091b72010-05-05 07:34:42 +00003513 ASSERT_EQ(original_height + 1, frame_->height());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003514}
3515
3516
ager@chromium.org7c537e22008-10-16 08:43:32 +00003517void CodeGenerator::VisitRegExpLiteral(RegExpLiteral* node) {
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00003518#ifdef DEBUG
3519 int original_height = frame_->height();
3520#endif
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003521 Comment cmnt(masm_, "[ RexExp Literal");
3522
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00003523 Register tmp = VirtualFrame::scratch0();
3524 // Free up a TOS register that can be used to push the literal.
3525 Register literal = frame_->GetTOSRegister();
3526
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003527 // Retrieve the literal array and check the allocated entry.
3528
3529 // Load the function of this activation.
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00003530 __ ldr(tmp, frame_->Function());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003531
3532 // Load the literals array of the function.
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00003533 __ ldr(tmp, FieldMemOperand(tmp, JSFunction::kLiteralsOffset));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003534
3535 // Load the literal at the ast saved index.
3536 int literal_offset =
3537 FixedArray::kHeaderSize + node->literal_index() * kPointerSize;
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00003538 __ ldr(literal, FieldMemOperand(tmp, literal_offset));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003539
lrn@chromium.orgc4e51ac2010-08-09 09:47:21 +00003540 JumpTarget materialized;
ager@chromium.orgab99eea2009-08-25 07:05:41 +00003541 __ LoadRoot(ip, Heap::kUndefinedValueRootIndex);
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00003542 __ cmp(literal, ip);
3543 // This branch locks the virtual frame at the done label to match the
3544 // one we have here, where the literal register is not on the stack and
3545 // nothing is spilled.
lrn@chromium.orgc4e51ac2010-08-09 09:47:21 +00003546 materialized.Branch(ne);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003547
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00003548 // If the entry is undefined we call the runtime system to compute
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003549 // the literal.
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00003550 // literal array (0)
3551 frame_->EmitPush(tmp);
3552 // literal index (1)
3553 frame_->EmitPush(Operand(Smi::FromInt(node->literal_index())));
3554 // RegExp pattern (2)
3555 frame_->EmitPush(Operand(node->pattern()));
3556 // RegExp flags (3)
3557 frame_->EmitPush(Operand(node->flags()));
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00003558 frame_->CallRuntime(Runtime::kMaterializeRegExpLiteral, 4);
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00003559 __ Move(literal, r0);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003560
lrn@chromium.orgc4e51ac2010-08-09 09:47:21 +00003561 materialized.Bind();
3562
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00003563 frame_->EmitPush(literal);
lrn@chromium.orgc4e51ac2010-08-09 09:47:21 +00003564 int size = JSRegExp::kSize + JSRegExp::kInObjectFieldCount * kPointerSize;
3565 frame_->EmitPush(Operand(Smi::FromInt(size)));
3566 frame_->CallRuntime(Runtime::kAllocateInNewSpace, 1);
3567 // TODO(lrn): Use AllocateInNewSpace macro with fallback to runtime.
3568 // r0 is newly allocated space.
3569
3570 // Reuse literal variable with (possibly) a new register, still holding
3571 // the materialized boilerplate.
3572 literal = frame_->PopToRegister(r0);
3573
3574 __ CopyFields(r0, literal, tmp.bit(), size / kPointerSize);
3575
3576 // Push the clone.
3577 frame_->EmitPush(r0);
ager@chromium.orgac091b72010-05-05 07:34:42 +00003578 ASSERT_EQ(original_height + 1, frame_->height());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003579}
3580
3581
ager@chromium.org7c537e22008-10-16 08:43:32 +00003582void CodeGenerator::VisitObjectLiteral(ObjectLiteral* node) {
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00003583#ifdef DEBUG
3584 int original_height = frame_->height();
3585#endif
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003586 Comment cmnt(masm_, "[ ObjectLiteral");
3587
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00003588 Register literal = frame_->GetTOSRegister();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003589 // Load the function of this activation.
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00003590 __ ldr(literal, frame_->Function());
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00003591 // Literal array.
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00003592 __ ldr(literal, FieldMemOperand(literal, JSFunction::kLiteralsOffset));
3593 frame_->EmitPush(literal);
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00003594 // Literal index.
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00003595 frame_->EmitPush(Operand(Smi::FromInt(node->literal_index())));
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00003596 // Constant properties.
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00003597 frame_->EmitPush(Operand(node->constant_properties()));
vegorov@chromium.orgf8372902010-03-15 10:26:20 +00003598 // Should the object literal have fast elements?
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00003599 frame_->EmitPush(Operand(Smi::FromInt(node->fast_elements() ? 1 : 0)));
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00003600 if (node->depth() > 1) {
vegorov@chromium.orgf8372902010-03-15 10:26:20 +00003601 frame_->CallRuntime(Runtime::kCreateObjectLiteral, 4);
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00003602 } else {
vegorov@chromium.orgf8372902010-03-15 10:26:20 +00003603 frame_->CallRuntime(Runtime::kCreateObjectLiteralShallow, 4);
ager@chromium.orgbb29dc92009-03-24 13:25:23 +00003604 }
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00003605 frame_->EmitPush(r0); // save the result
fschneider@chromium.orge03fb642010-11-01 12:34:09 +00003606
3607 // Mark all computed expressions that are bound to a key that
3608 // is shadowed by a later occurrence of the same key. For the
3609 // marked expressions, no store code is emitted.
3610 node->CalculateEmitStore();
3611
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003612 for (int i = 0; i < node->properties()->length(); i++) {
ager@chromium.org5c838252010-02-19 08:53:10 +00003613 // At the start of each iteration, the top of stack contains
3614 // the newly created object literal.
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003615 ObjectLiteral::Property* property = node->properties()->at(i);
3616 Literal* key = property->key();
3617 Expression* value = property->value();
3618 switch (property->kind()) {
ager@chromium.orgbb29dc92009-03-24 13:25:23 +00003619 case ObjectLiteral::Property::CONSTANT:
3620 break;
3621 case ObjectLiteral::Property::MATERIALIZED_LITERAL:
3622 if (CompileTimeValue::IsCompileTimeValue(property->value())) break;
3623 // else fall through
ager@chromium.org5c838252010-02-19 08:53:10 +00003624 case ObjectLiteral::Property::COMPUTED:
3625 if (key->handle()->IsSymbol()) {
3626 Handle<Code> ic(Builtins::builtin(Builtins::StoreIC_Initialize));
ricow@chromium.org30ce4112010-05-31 10:38:25 +00003627 Load(value);
fschneider@chromium.orge03fb642010-11-01 12:34:09 +00003628 if (property->emit_store()) {
3629 frame_->PopToR0();
3630 // Fetch the object literal.
3631 frame_->SpillAllButCopyTOSToR1();
3632 __ mov(r2, Operand(key->handle()));
3633 frame_->CallCodeObject(ic, RelocInfo::CODE_TARGET, 0);
3634 } else {
3635 frame_->Drop();
3636 }
ager@chromium.org5c838252010-02-19 08:53:10 +00003637 break;
3638 }
3639 // else fall through
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003640 case ObjectLiteral::Property::PROTOTYPE: {
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00003641 frame_->Dup();
ricow@chromium.org30ce4112010-05-31 10:38:25 +00003642 Load(key);
3643 Load(value);
fschneider@chromium.orge03fb642010-11-01 12:34:09 +00003644 if (property->emit_store()) {
3645 frame_->CallRuntime(Runtime::kSetProperty, 3);
3646 } else {
3647 frame_->Drop(3);
3648 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003649 break;
3650 }
3651 case ObjectLiteral::Property::SETTER: {
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00003652 frame_->Dup();
ricow@chromium.org30ce4112010-05-31 10:38:25 +00003653 Load(key);
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00003654 frame_->EmitPush(Operand(Smi::FromInt(1)));
ricow@chromium.org30ce4112010-05-31 10:38:25 +00003655 Load(value);
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00003656 frame_->CallRuntime(Runtime::kDefineAccessor, 4);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003657 break;
3658 }
3659 case ObjectLiteral::Property::GETTER: {
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00003660 frame_->Dup();
ricow@chromium.org30ce4112010-05-31 10:38:25 +00003661 Load(key);
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00003662 frame_->EmitPush(Operand(Smi::FromInt(0)));
ricow@chromium.org30ce4112010-05-31 10:38:25 +00003663 Load(value);
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00003664 frame_->CallRuntime(Runtime::kDefineAccessor, 4);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003665 break;
3666 }
3667 }
3668 }
ager@chromium.orgac091b72010-05-05 07:34:42 +00003669 ASSERT_EQ(original_height + 1, frame_->height());
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00003670}
3671
3672
ager@chromium.org7c537e22008-10-16 08:43:32 +00003673void CodeGenerator::VisitArrayLiteral(ArrayLiteral* node) {
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00003674#ifdef DEBUG
3675 int original_height = frame_->height();
3676#endif
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003677 Comment cmnt(masm_, "[ ArrayLiteral");
mads.s.ager@gmail.com9a4089a2008-09-01 08:55:01 +00003678
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00003679 Register tos = frame_->GetTOSRegister();
ager@chromium.orgbb29dc92009-03-24 13:25:23 +00003680 // Load the function of this activation.
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00003681 __ ldr(tos, frame_->Function());
ager@chromium.org5c838252010-02-19 08:53:10 +00003682 // Load the literals array of the function.
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00003683 __ ldr(tos, FieldMemOperand(tos, JSFunction::kLiteralsOffset));
3684 frame_->EmitPush(tos);
3685 frame_->EmitPush(Operand(Smi::FromInt(node->literal_index())));
3686 frame_->EmitPush(Operand(node->constant_elements()));
ager@chromium.org5c838252010-02-19 08:53:10 +00003687 int length = node->values()->length();
ricow@chromium.org0b9f8502010-08-18 07:45:01 +00003688 if (node->constant_elements()->map() == Heap::fixed_cow_array_map()) {
3689 FastCloneShallowArrayStub stub(
3690 FastCloneShallowArrayStub::COPY_ON_WRITE_ELEMENTS, length);
3691 frame_->CallStub(&stub, 3);
3692 __ IncrementCounter(&Counters::cow_arrays_created_stub, 1, r1, r2);
3693 } else if (node->depth() > 1) {
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00003694 frame_->CallRuntime(Runtime::kCreateArrayLiteral, 3);
ricow@chromium.org0b9f8502010-08-18 07:45:01 +00003695 } else if (length > FastCloneShallowArrayStub::kMaximumClonedLength) {
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00003696 frame_->CallRuntime(Runtime::kCreateArrayLiteralShallow, 3);
ager@chromium.org5c838252010-02-19 08:53:10 +00003697 } else {
ricow@chromium.org0b9f8502010-08-18 07:45:01 +00003698 FastCloneShallowArrayStub stub(
3699 FastCloneShallowArrayStub::CLONE_ELEMENTS, length);
ager@chromium.org5c838252010-02-19 08:53:10 +00003700 frame_->CallStub(&stub, 3);
ager@chromium.orgbb29dc92009-03-24 13:25:23 +00003701 }
ager@chromium.orgbb29dc92009-03-24 13:25:23 +00003702 frame_->EmitPush(r0); // save the result
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00003703 // r0: created object literal
mads.s.ager@gmail.com9a4089a2008-09-01 08:55:01 +00003704
3705 // Generate code to set the elements in the array that are not
3706 // literals.
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003707 for (int i = 0; i < node->values()->length(); i++) {
3708 Expression* value = node->values()->at(i);
3709
ager@chromium.orgbb29dc92009-03-24 13:25:23 +00003710 // If value is a literal the property value is already set in the
3711 // boilerplate object.
3712 if (value->AsLiteral() != NULL) continue;
3713 // If value is a materialized literal the property value is already set
3714 // in the boilerplate object if it is simple.
3715 if (CompileTimeValue::IsCompileTimeValue(value)) continue;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003716
ager@chromium.orgbb29dc92009-03-24 13:25:23 +00003717 // The property must be set by generated code.
ricow@chromium.org30ce4112010-05-31 10:38:25 +00003718 Load(value);
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00003719 frame_->PopToR0();
ager@chromium.orgbb29dc92009-03-24 13:25:23 +00003720 // Fetch the object literal.
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00003721 frame_->SpillAllButCopyTOSToR1();
3722
ager@chromium.orgbb29dc92009-03-24 13:25:23 +00003723 // Get the elements array.
3724 __ ldr(r1, FieldMemOperand(r1, JSObject::kElementsOffset));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003725
ager@chromium.orgbb29dc92009-03-24 13:25:23 +00003726 // Write to the indexed properties array.
kasperl@chromium.orge959c182009-07-27 08:59:04 +00003727 int offset = i * kPointerSize + FixedArray::kHeaderSize;
ager@chromium.orgbb29dc92009-03-24 13:25:23 +00003728 __ str(r0, FieldMemOperand(r1, offset));
3729
3730 // Update the write barrier for the array address.
ricow@chromium.org5ad5ace2010-06-23 09:06:43 +00003731 __ RecordWrite(r1, Operand(offset), r3, r2);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003732 }
ager@chromium.orgac091b72010-05-05 07:34:42 +00003733 ASSERT_EQ(original_height + 1, frame_->height());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003734}
3735
3736
ager@chromium.org32912102009-01-16 10:38:43 +00003737void CodeGenerator::VisitCatchExtensionObject(CatchExtensionObject* node) {
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00003738#ifdef DEBUG
3739 int original_height = frame_->height();
3740#endif
ager@chromium.org32912102009-01-16 10:38:43 +00003741 // Call runtime routine to allocate the catch extension object and
3742 // assign the exception value to the catch variable.
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00003743 Comment cmnt(masm_, "[ CatchExtensionObject");
ricow@chromium.org30ce4112010-05-31 10:38:25 +00003744 Load(node->key());
3745 Load(node->value());
christian.plesner.hansen@gmail.com5a6af922009-08-12 14:20:51 +00003746 frame_->CallRuntime(Runtime::kCreateCatchExtensionObject, 2);
3747 frame_->EmitPush(r0);
ager@chromium.orgac091b72010-05-05 07:34:42 +00003748 ASSERT_EQ(original_height + 1, frame_->height());
3749}
3750
3751
3752void CodeGenerator::EmitSlotAssignment(Assignment* node) {
3753#ifdef DEBUG
3754 int original_height = frame_->height();
3755#endif
3756 Comment cmnt(masm(), "[ Variable Assignment");
3757 Variable* var = node->target()->AsVariableProxy()->AsVariable();
3758 ASSERT(var != NULL);
whesse@chromium.org4a1fe7d2010-09-27 12:32:04 +00003759 Slot* slot = var->AsSlot();
ager@chromium.orgac091b72010-05-05 07:34:42 +00003760 ASSERT(slot != NULL);
3761
3762 // Evaluate the right-hand side.
3763 if (node->is_compound()) {
3764 // For a compound assignment the right-hand side is a binary operation
3765 // between the current property value and the actual right-hand side.
3766 LoadFromSlotCheckForArguments(slot, NOT_INSIDE_TYPEOF);
3767
3768 // Perform the binary operation.
3769 Literal* literal = node->value()->AsLiteral();
ricow@chromium.org65fae842010-08-25 15:26:24 +00003770 bool overwrite_value = node->value()->ResultOverwriteAllowed();
ager@chromium.orgac091b72010-05-05 07:34:42 +00003771 if (literal != NULL && literal->handle()->IsSmi()) {
3772 SmiOperation(node->binary_op(),
3773 literal->handle(),
3774 false,
3775 overwrite_value ? OVERWRITE_RIGHT : NO_OVERWRITE);
3776 } else {
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00003777 GenerateInlineSmi inline_smi =
3778 loop_nesting() > 0 ? GENERATE_INLINE_SMI : DONT_GENERATE_INLINE_SMI;
3779 if (literal != NULL) {
3780 ASSERT(!literal->handle()->IsSmi());
3781 inline_smi = DONT_GENERATE_INLINE_SMI;
3782 }
ager@chromium.orgac091b72010-05-05 07:34:42 +00003783 Load(node->value());
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00003784 GenericBinaryOperation(node->binary_op(),
3785 overwrite_value ? OVERWRITE_RIGHT : NO_OVERWRITE,
3786 inline_smi);
ager@chromium.orgac091b72010-05-05 07:34:42 +00003787 }
3788 } else {
3789 Load(node->value());
3790 }
3791
3792 // Perform the assignment.
3793 if (var->mode() != Variable::CONST || node->op() == Token::INIT_CONST) {
3794 CodeForSourcePosition(node->position());
3795 StoreToSlot(slot,
3796 node->op() == Token::INIT_CONST ? CONST_INIT : NOT_CONST_INIT);
3797 }
3798 ASSERT_EQ(original_height + 1, frame_->height());
3799}
3800
3801
3802void CodeGenerator::EmitNamedPropertyAssignment(Assignment* node) {
3803#ifdef DEBUG
3804 int original_height = frame_->height();
3805#endif
3806 Comment cmnt(masm(), "[ Named Property Assignment");
3807 Variable* var = node->target()->AsVariableProxy()->AsVariable();
3808 Property* prop = node->target()->AsProperty();
3809 ASSERT(var == NULL || (prop == NULL && var->is_global()));
3810
3811 // Initialize name and evaluate the receiver sub-expression if necessary. If
3812 // the receiver is trivial it is not placed on the stack at this point, but
3813 // loaded whenever actually needed.
3814 Handle<String> name;
3815 bool is_trivial_receiver = false;
3816 if (var != NULL) {
3817 name = var->name();
3818 } else {
3819 Literal* lit = prop->key()->AsLiteral();
3820 ASSERT_NOT_NULL(lit);
3821 name = Handle<String>::cast(lit->handle());
3822 // Do not materialize the receiver on the frame if it is trivial.
3823 is_trivial_receiver = prop->obj()->IsTrivial();
3824 if (!is_trivial_receiver) Load(prop->obj());
3825 }
3826
3827 // Change to slow case in the beginning of an initialization block to
3828 // avoid the quadratic behavior of repeatedly adding fast properties.
3829 if (node->starts_initialization_block()) {
3830 // Initialization block consists of assignments of the form expr.x = ..., so
3831 // this will never be an assignment to a variable, so there must be a
3832 // receiver object.
3833 ASSERT_EQ(NULL, var);
3834 if (is_trivial_receiver) {
3835 Load(prop->obj());
3836 } else {
3837 frame_->Dup();
3838 }
3839 frame_->CallRuntime(Runtime::kToSlowProperties, 1);
3840 }
3841
3842 // Change to fast case at the end of an initialization block. To prepare for
3843 // that add an extra copy of the receiver to the frame, so that it can be
3844 // converted back to fast case after the assignment.
3845 if (node->ends_initialization_block() && !is_trivial_receiver) {
3846 frame_->Dup();
3847 }
3848
3849 // Stack layout:
3850 // [tos] : receiver (only materialized if non-trivial)
3851 // [tos+1] : receiver if at the end of an initialization block
3852
3853 // Evaluate the right-hand side.
3854 if (node->is_compound()) {
3855 // For a compound assignment the right-hand side is a binary operation
3856 // between the current property value and the actual right-hand side.
3857 if (is_trivial_receiver) {
3858 Load(prop->obj());
3859 } else if (var != NULL) {
3860 LoadGlobal();
3861 } else {
3862 frame_->Dup();
3863 }
3864 EmitNamedLoad(name, var != NULL);
ager@chromium.orgac091b72010-05-05 07:34:42 +00003865
3866 // Perform the binary operation.
3867 Literal* literal = node->value()->AsLiteral();
ricow@chromium.org65fae842010-08-25 15:26:24 +00003868 bool overwrite_value = node->value()->ResultOverwriteAllowed();
ager@chromium.orgac091b72010-05-05 07:34:42 +00003869 if (literal != NULL && literal->handle()->IsSmi()) {
3870 SmiOperation(node->binary_op(),
3871 literal->handle(),
3872 false,
3873 overwrite_value ? OVERWRITE_RIGHT : NO_OVERWRITE);
3874 } else {
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00003875 GenerateInlineSmi inline_smi =
3876 loop_nesting() > 0 ? GENERATE_INLINE_SMI : DONT_GENERATE_INLINE_SMI;
3877 if (literal != NULL) {
3878 ASSERT(!literal->handle()->IsSmi());
3879 inline_smi = DONT_GENERATE_INLINE_SMI;
3880 }
ager@chromium.orgac091b72010-05-05 07:34:42 +00003881 Load(node->value());
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00003882 GenericBinaryOperation(node->binary_op(),
3883 overwrite_value ? OVERWRITE_RIGHT : NO_OVERWRITE,
3884 inline_smi);
ager@chromium.orgac091b72010-05-05 07:34:42 +00003885 }
3886 } else {
3887 // For non-compound assignment just load the right-hand side.
3888 Load(node->value());
3889 }
3890
3891 // Stack layout:
3892 // [tos] : value
3893 // [tos+1] : receiver (only materialized if non-trivial)
3894 // [tos+2] : receiver if at the end of an initialization block
3895
3896 // Perform the assignment. It is safe to ignore constants here.
3897 ASSERT(var == NULL || var->mode() != Variable::CONST);
3898 ASSERT_NE(Token::INIT_CONST, node->op());
3899 if (is_trivial_receiver) {
3900 // Load the receiver and swap with the value.
3901 Load(prop->obj());
3902 Register t0 = frame_->PopToRegister();
3903 Register t1 = frame_->PopToRegister(t0);
3904 frame_->EmitPush(t0);
3905 frame_->EmitPush(t1);
3906 }
3907 CodeForSourcePosition(node->position());
3908 bool is_contextual = (var != NULL);
3909 EmitNamedStore(name, is_contextual);
3910 frame_->EmitPush(r0);
3911
3912 // Change to fast case at the end of an initialization block.
3913 if (node->ends_initialization_block()) {
3914 ASSERT_EQ(NULL, var);
3915 // The argument to the runtime call is the receiver.
3916 if (is_trivial_receiver) {
3917 Load(prop->obj());
3918 } else {
3919 // A copy of the receiver is below the value of the assignment. Swap
3920 // the receiver and the value of the assignment expression.
3921 Register t0 = frame_->PopToRegister();
3922 Register t1 = frame_->PopToRegister(t0);
3923 frame_->EmitPush(t0);
3924 frame_->EmitPush(t1);
3925 }
3926 frame_->CallRuntime(Runtime::kToFastProperties, 1);
3927 }
3928
3929 // Stack layout:
3930 // [tos] : result
3931
3932 ASSERT_EQ(original_height + 1, frame_->height());
3933}
3934
3935
3936void CodeGenerator::EmitKeyedPropertyAssignment(Assignment* node) {
3937#ifdef DEBUG
3938 int original_height = frame_->height();
3939#endif
3940 Comment cmnt(masm_, "[ Keyed Property Assignment");
3941 Property* prop = node->target()->AsProperty();
3942 ASSERT_NOT_NULL(prop);
3943
3944 // Evaluate the receiver subexpression.
3945 Load(prop->obj());
3946
kmillikin@chromium.org69ea3962010-07-05 11:01:40 +00003947 WriteBarrierCharacter wb_info;
3948
ager@chromium.orgac091b72010-05-05 07:34:42 +00003949 // Change to slow case in the beginning of an initialization block to
3950 // avoid the quadratic behavior of repeatedly adding fast properties.
3951 if (node->starts_initialization_block()) {
3952 frame_->Dup();
3953 frame_->CallRuntime(Runtime::kToSlowProperties, 1);
3954 }
3955
3956 // Change to fast case at the end of an initialization block. To prepare for
3957 // that add an extra copy of the receiver to the frame, so that it can be
3958 // converted back to fast case after the assignment.
3959 if (node->ends_initialization_block()) {
3960 frame_->Dup();
3961 }
3962
3963 // Evaluate the key subexpression.
3964 Load(prop->key());
3965
3966 // Stack layout:
3967 // [tos] : key
3968 // [tos+1] : receiver
3969 // [tos+2] : receiver if at the end of an initialization block
kmillikin@chromium.org69ea3962010-07-05 11:01:40 +00003970 //
ager@chromium.orgac091b72010-05-05 07:34:42 +00003971 // Evaluate the right-hand side.
3972 if (node->is_compound()) {
3973 // For a compound assignment the right-hand side is a binary operation
3974 // between the current property value and the actual right-hand side.
sgjesse@chromium.org720dc0b2010-05-10 09:25:39 +00003975 // Duplicate receiver and key for loading the current property value.
3976 frame_->Dup2();
ager@chromium.orgac091b72010-05-05 07:34:42 +00003977 EmitKeyedLoad();
3978 frame_->EmitPush(r0);
3979
3980 // Perform the binary operation.
3981 Literal* literal = node->value()->AsLiteral();
ricow@chromium.org65fae842010-08-25 15:26:24 +00003982 bool overwrite_value = node->value()->ResultOverwriteAllowed();
ager@chromium.orgac091b72010-05-05 07:34:42 +00003983 if (literal != NULL && literal->handle()->IsSmi()) {
3984 SmiOperation(node->binary_op(),
3985 literal->handle(),
3986 false,
3987 overwrite_value ? OVERWRITE_RIGHT : NO_OVERWRITE);
3988 } else {
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00003989 GenerateInlineSmi inline_smi =
3990 loop_nesting() > 0 ? GENERATE_INLINE_SMI : DONT_GENERATE_INLINE_SMI;
3991 if (literal != NULL) {
3992 ASSERT(!literal->handle()->IsSmi());
3993 inline_smi = DONT_GENERATE_INLINE_SMI;
3994 }
ager@chromium.orgac091b72010-05-05 07:34:42 +00003995 Load(node->value());
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00003996 GenericBinaryOperation(node->binary_op(),
3997 overwrite_value ? OVERWRITE_RIGHT : NO_OVERWRITE,
3998 inline_smi);
ager@chromium.orgac091b72010-05-05 07:34:42 +00003999 }
kmillikin@chromium.org69ea3962010-07-05 11:01:40 +00004000 wb_info = node->type()->IsLikelySmi() ? LIKELY_SMI : UNLIKELY_SMI;
ager@chromium.orgac091b72010-05-05 07:34:42 +00004001 } else {
4002 // For non-compound assignment just load the right-hand side.
4003 Load(node->value());
kmillikin@chromium.org69ea3962010-07-05 11:01:40 +00004004 wb_info = node->value()->AsLiteral() != NULL ?
4005 NEVER_NEWSPACE :
4006 (node->value()->type()->IsLikelySmi() ? LIKELY_SMI : UNLIKELY_SMI);
ager@chromium.orgac091b72010-05-05 07:34:42 +00004007 }
4008
4009 // Stack layout:
4010 // [tos] : value
4011 // [tos+1] : key
4012 // [tos+2] : receiver
4013 // [tos+3] : receiver if at the end of an initialization block
4014
4015 // Perform the assignment. It is safe to ignore constants here.
4016 ASSERT(node->op() != Token::INIT_CONST);
4017 CodeForSourcePosition(node->position());
kmillikin@chromium.org69ea3962010-07-05 11:01:40 +00004018 EmitKeyedStore(prop->key()->type(), wb_info);
ager@chromium.orgac091b72010-05-05 07:34:42 +00004019 frame_->EmitPush(r0);
4020
4021 // Stack layout:
4022 // [tos] : result
4023 // [tos+1] : receiver if at the end of an initialization block
4024
4025 // Change to fast case at the end of an initialization block.
4026 if (node->ends_initialization_block()) {
4027 // The argument to the runtime call is the extra copy of the receiver,
4028 // which is below the value of the assignment. Swap the receiver and
4029 // the value of the assignment expression.
4030 Register t0 = frame_->PopToRegister();
4031 Register t1 = frame_->PopToRegister(t0);
4032 frame_->EmitPush(t1);
4033 frame_->EmitPush(t0);
4034 frame_->CallRuntime(Runtime::kToFastProperties, 1);
4035 }
4036
4037 // Stack layout:
4038 // [tos] : result
4039
4040 ASSERT_EQ(original_height + 1, frame_->height());
ager@chromium.org32912102009-01-16 10:38:43 +00004041}
4042
4043
ager@chromium.org7c537e22008-10-16 08:43:32 +00004044void CodeGenerator::VisitAssignment(Assignment* node) {
ager@chromium.org357bf652010-04-12 11:30:10 +00004045 VirtualFrame::RegisterAllocationScope scope(this);
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00004046#ifdef DEBUG
4047 int original_height = frame_->height();
4048#endif
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004049 Comment cmnt(masm_, "[ Assignment");
mads.s.ager31e71382008-08-13 09:32:07 +00004050
ager@chromium.orgac091b72010-05-05 07:34:42 +00004051 Variable* var = node->target()->AsVariableProxy()->AsVariable();
4052 Property* prop = node->target()->AsProperty();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004053
ager@chromium.orgac091b72010-05-05 07:34:42 +00004054 if (var != NULL && !var->is_global()) {
4055 EmitSlotAssignment(node);
mads.s.ager31e71382008-08-13 09:32:07 +00004056
ager@chromium.orgac091b72010-05-05 07:34:42 +00004057 } else if ((prop != NULL && prop->key()->IsPropertyName()) ||
4058 (var != NULL && var->is_global())) {
4059 // Properties whose keys are property names and global variables are
4060 // treated as named property references. We do not need to consider
4061 // global 'this' because it is not a valid left-hand side.
4062 EmitNamedPropertyAssignment(node);
4063
4064 } else if (prop != NULL) {
4065 // Other properties (including rewritten parameters for a function that
4066 // uses arguments) are keyed property assignments.
4067 EmitKeyedPropertyAssignment(node);
4068
4069 } else {
4070 // Invalid left-hand side.
4071 Load(node->target());
4072 frame_->CallRuntime(Runtime::kThrowReferenceError, 1);
4073 // The runtime call doesn't actually return but the code generator will
4074 // still generate code and expects a certain frame height.
4075 frame_->EmitPush(r0);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004076 }
ager@chromium.orgac091b72010-05-05 07:34:42 +00004077 ASSERT_EQ(original_height + 1, frame_->height());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004078}
4079
4080
ager@chromium.org7c537e22008-10-16 08:43:32 +00004081void CodeGenerator::VisitThrow(Throw* node) {
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00004082#ifdef DEBUG
4083 int original_height = frame_->height();
4084#endif
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004085 Comment cmnt(masm_, "[ Throw");
4086
ricow@chromium.org30ce4112010-05-31 10:38:25 +00004087 Load(node->exception());
christian.plesner.hansen@gmail.com37abdec2009-01-06 14:43:28 +00004088 CodeForSourcePosition(node->position());
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00004089 frame_->CallRuntime(Runtime::kThrow, 1);
4090 frame_->EmitPush(r0);
ager@chromium.orgac091b72010-05-05 07:34:42 +00004091 ASSERT_EQ(original_height + 1, frame_->height());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004092}
4093
4094
ager@chromium.org7c537e22008-10-16 08:43:32 +00004095void CodeGenerator::VisitProperty(Property* node) {
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00004096#ifdef DEBUG
4097 int original_height = frame_->height();
4098#endif
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004099 Comment cmnt(masm_, "[ Property");
kasperl@chromium.orgb9123622008-09-17 14:05:56 +00004100
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00004101 { Reference property(this, node);
ager@chromium.org357bf652010-04-12 11:30:10 +00004102 property.GetValue();
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00004103 }
ager@chromium.orgac091b72010-05-05 07:34:42 +00004104 ASSERT_EQ(original_height + 1, frame_->height());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004105}
4106
4107
ager@chromium.org7c537e22008-10-16 08:43:32 +00004108void CodeGenerator::VisitCall(Call* node) {
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00004109#ifdef DEBUG
4110 int original_height = frame_->height();
4111#endif
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004112 Comment cmnt(masm_, "[ Call");
4113
sgjesse@chromium.orgc5145742009-10-07 09:00:33 +00004114 Expression* function = node->expression();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004115 ZoneList<Expression*>* args = node->arguments();
4116
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004117 // Standard function call.
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004118 // Check if the function is a variable or a property.
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004119 Variable* var = function->AsVariableProxy()->AsVariable();
4120 Property* property = function->AsProperty();
4121
4122 // ------------------------------------------------------------------------
4123 // Fast-case: Use inline caching.
4124 // ---
4125 // According to ECMA-262, section 11.2.3, page 44, the function to call
4126 // must be resolved after the arguments have been evaluated. The IC code
4127 // automatically handles this by loading the arguments before the function
4128 // is resolved in cache misses (this also holds for megamorphic calls).
4129 // ------------------------------------------------------------------------
4130
sgjesse@chromium.orgc5145742009-10-07 09:00:33 +00004131 if (var != NULL && var->is_possibly_eval()) {
4132 // ----------------------------------
4133 // JavaScript example: 'eval(arg)' // eval is not known to be shadowed
4134 // ----------------------------------
4135
4136 // In a call to eval, we first call %ResolvePossiblyDirectEval to
4137 // resolve the function we need to call and the receiver of the
4138 // call. Then we call the resolved function using the given
4139 // arguments.
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00004140
sgjesse@chromium.orgc5145742009-10-07 09:00:33 +00004141 // Prepare stack for call to resolved function.
ricow@chromium.org30ce4112010-05-31 10:38:25 +00004142 Load(function);
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00004143
4144 // Allocate a frame slot for the receiver.
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00004145 frame_->EmitPushRoot(Heap::kUndefinedValueRootIndex);
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00004146
4147 // Load the arguments.
sgjesse@chromium.orgc5145742009-10-07 09:00:33 +00004148 int arg_count = args->length();
4149 for (int i = 0; i < arg_count; i++) {
ricow@chromium.org30ce4112010-05-31 10:38:25 +00004150 Load(args->at(i));
sgjesse@chromium.orgc5145742009-10-07 09:00:33 +00004151 }
4152
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00004153 VirtualFrame::SpilledScope spilled_scope(frame_);
4154
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00004155 // If we know that eval can only be shadowed by eval-introduced
4156 // variables we attempt to load the global eval function directly
4157 // in generated code. If we succeed, there is no need to perform a
4158 // context lookup in the runtime system.
4159 JumpTarget done;
whesse@chromium.org4a1fe7d2010-09-27 12:32:04 +00004160 if (var->AsSlot() != NULL && var->mode() == Variable::DYNAMIC_GLOBAL) {
4161 ASSERT(var->AsSlot()->type() == Slot::LOOKUP);
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00004162 JumpTarget slow;
4163 // Prepare the stack for the call to
4164 // ResolvePossiblyDirectEvalNoLookup by pushing the loaded
4165 // function, the first argument to the eval call and the
4166 // receiver.
whesse@chromium.org4a1fe7d2010-09-27 12:32:04 +00004167 LoadFromGlobalSlotCheckExtensions(var->AsSlot(),
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00004168 NOT_INSIDE_TYPEOF,
4169 &slow);
4170 frame_->EmitPush(r0);
4171 if (arg_count > 0) {
4172 __ ldr(r1, MemOperand(sp, arg_count * kPointerSize));
4173 frame_->EmitPush(r1);
4174 } else {
4175 frame_->EmitPush(r2);
4176 }
4177 __ ldr(r1, frame_->Receiver());
4178 frame_->EmitPush(r1);
4179
ricow@chromium.org83aa5492011-02-07 12:42:56 +00004180 // Push the strict mode flag.
4181 frame_->EmitPush(Operand(Smi::FromInt(strict_mode_flag())));
4182
4183 frame_->CallRuntime(Runtime::kResolvePossiblyDirectEvalNoLookup, 4);
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00004184
4185 done.Jump();
4186 slow.Bind();
4187 }
4188
4189 // Prepare the stack for the call to ResolvePossiblyDirectEval by
4190 // pushing the loaded function, the first argument to the eval
4191 // call and the receiver.
sgjesse@chromium.orgc5145742009-10-07 09:00:33 +00004192 __ ldr(r1, MemOperand(sp, arg_count * kPointerSize + kPointerSize));
4193 frame_->EmitPush(r1);
4194 if (arg_count > 0) {
4195 __ ldr(r1, MemOperand(sp, arg_count * kPointerSize));
4196 frame_->EmitPush(r1);
4197 } else {
4198 frame_->EmitPush(r2);
4199 }
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00004200 __ ldr(r1, frame_->Receiver());
4201 frame_->EmitPush(r1);
4202
ricow@chromium.org83aa5492011-02-07 12:42:56 +00004203 // Push the strict mode flag.
4204 frame_->EmitPush(Operand(Smi::FromInt(strict_mode_flag())));
4205
sgjesse@chromium.orgc5145742009-10-07 09:00:33 +00004206 // Resolve the call.
ricow@chromium.org83aa5492011-02-07 12:42:56 +00004207 frame_->CallRuntime(Runtime::kResolvePossiblyDirectEval, 4);
sgjesse@chromium.orgc5145742009-10-07 09:00:33 +00004208
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00004209 // If we generated fast-case code bind the jump-target where fast
4210 // and slow case merge.
4211 if (done.is_linked()) done.Bind();
4212
sgjesse@chromium.orgc5145742009-10-07 09:00:33 +00004213 // Touch up stack with the right values for the function and the receiver.
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00004214 __ str(r0, MemOperand(sp, (arg_count + 1) * kPointerSize));
sgjesse@chromium.orgc5145742009-10-07 09:00:33 +00004215 __ str(r1, MemOperand(sp, arg_count * kPointerSize));
4216
4217 // Call the function.
4218 CodeForSourcePosition(node->position());
4219
4220 InLoopFlag in_loop = loop_nesting() > 0 ? IN_LOOP : NOT_IN_LOOP;
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +00004221 CallFunctionStub call_function(arg_count, in_loop, RECEIVER_MIGHT_BE_VALUE);
sgjesse@chromium.orgc5145742009-10-07 09:00:33 +00004222 frame_->CallStub(&call_function, arg_count + 1);
4223
4224 __ ldr(cp, frame_->Context());
4225 // Remove the function from the stack.
4226 frame_->Drop();
4227 frame_->EmitPush(r0);
4228
4229 } else if (var != NULL && !var->is_this() && var->is_global()) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004230 // ----------------------------------
4231 // JavaScript example: 'foo(1, 2, 3)' // foo is global
4232 // ----------------------------------
kasperl@chromium.org9fe21c62008-10-28 08:53:51 +00004233 // Pass the global object as the receiver and let the IC stub
4234 // patch the stack to use the global proxy as 'this' in the
4235 // invoked function.
4236 LoadGlobal();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004237
4238 // Load the arguments.
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00004239 int arg_count = args->length();
4240 for (int i = 0; i < arg_count; i++) {
ricow@chromium.org30ce4112010-05-31 10:38:25 +00004241 Load(args->at(i));
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00004242 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004243
ricow@chromium.org30ce4112010-05-31 10:38:25 +00004244 VirtualFrame::SpilledScope spilled_scope(frame_);
ager@chromium.org5c838252010-02-19 08:53:10 +00004245 // Setup the name register and call the IC initialization code.
4246 __ mov(r2, Operand(var->name()));
kasperl@chromium.org71affb52009-05-26 05:44:31 +00004247 InLoopFlag in_loop = loop_nesting() > 0 ? IN_LOOP : NOT_IN_LOOP;
erik.corry@gmail.com4a6c3272010-11-18 12:04:40 +00004248 Handle<Code> stub = StubCache::ComputeCallInitialize(arg_count, in_loop);
christian.plesner.hansen@gmail.com37abdec2009-01-06 14:43:28 +00004249 CodeForSourcePosition(node->position());
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00004250 frame_->CallCodeObject(stub, RelocInfo::CODE_TARGET_CONTEXT,
4251 arg_count + 1);
ager@chromium.org3bf7b912008-11-17 09:09:45 +00004252 __ ldr(cp, frame_->Context());
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00004253 frame_->EmitPush(r0);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004254
whesse@chromium.org4a1fe7d2010-09-27 12:32:04 +00004255 } else if (var != NULL && var->AsSlot() != NULL &&
4256 var->AsSlot()->type() == Slot::LOOKUP) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004257 // ----------------------------------
sgjesse@chromium.org720dc0b2010-05-10 09:25:39 +00004258 // JavaScript examples:
4259 //
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +00004260 // with (obj) foo(1, 2, 3) // foo may be in obj.
sgjesse@chromium.org720dc0b2010-05-10 09:25:39 +00004261 //
4262 // function f() {};
4263 // function g() {
4264 // eval(...);
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +00004265 // f(); // f could be in extension object.
sgjesse@chromium.org720dc0b2010-05-10 09:25:39 +00004266 // }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004267 // ----------------------------------
4268
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +00004269 JumpTarget slow, done;
sgjesse@chromium.org720dc0b2010-05-10 09:25:39 +00004270
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +00004271 // Generate fast case for loading functions from slots that
4272 // correspond to local/global variables or arguments unless they
4273 // are shadowed by eval-introduced bindings.
whesse@chromium.org4a1fe7d2010-09-27 12:32:04 +00004274 EmitDynamicLoadFromSlotFastCase(var->AsSlot(),
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +00004275 NOT_INSIDE_TYPEOF,
4276 &slow,
4277 &done);
sgjesse@chromium.org720dc0b2010-05-10 09:25:39 +00004278
4279 slow.Bind();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004280 // Load the function
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00004281 frame_->EmitPush(cp);
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00004282 frame_->EmitPush(Operand(var->name()));
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00004283 frame_->CallRuntime(Runtime::kLoadContextSlot, 2);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004284 // r0: slot value; r1: receiver
4285
4286 // Load the receiver.
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00004287 frame_->EmitPush(r0); // function
4288 frame_->EmitPush(r1); // receiver
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004289
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +00004290 // If fast case code has been generated, emit code to push the
4291 // function and receiver and have the slow path jump around this
4292 // code.
4293 if (done.is_linked()) {
4294 JumpTarget call;
4295 call.Jump();
4296 done.Bind();
4297 frame_->EmitPush(r0); // function
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00004298 LoadGlobalReceiver(VirtualFrame::scratch0()); // receiver
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +00004299 call.Bind();
4300 }
4301
sgjesse@chromium.org720dc0b2010-05-10 09:25:39 +00004302 // Call the function. At this point, everything is spilled but the
4303 // function and receiver are in r0 and r1.
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +00004304 CallWithArguments(args, NO_CALL_FUNCTION_FLAGS, node->position());
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00004305 frame_->EmitPush(r0);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004306
4307 } else if (property != NULL) {
4308 // Check if the key is a literal string.
4309 Literal* literal = property->key()->AsLiteral();
4310
4311 if (literal != NULL && literal->handle()->IsSymbol()) {
4312 // ------------------------------------------------------------------
4313 // JavaScript example: 'object.foo(1, 2, 3)' or 'map["key"](1, 2, 3)'
4314 // ------------------------------------------------------------------
4315
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00004316 Handle<String> name = Handle<String>::cast(literal->handle());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004317
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00004318 if (ArgumentsMode() == LAZY_ARGUMENTS_ALLOCATION &&
4319 name->IsEqualTo(CStrVector("apply")) &&
4320 args->length() == 2 &&
4321 args->at(1)->AsVariableProxy() != NULL &&
4322 args->at(1)->AsVariableProxy()->IsArguments()) {
4323 // Use the optimized Function.prototype.apply that avoids
4324 // allocating lazily allocated arguments objects.
4325 CallApplyLazy(property->obj(),
4326 args->at(0),
4327 args->at(1)->AsVariableProxy(),
4328 node->position());
4329
4330 } else {
ricow@chromium.org30ce4112010-05-31 10:38:25 +00004331 Load(property->obj()); // Receiver.
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00004332 // Load the arguments.
4333 int arg_count = args->length();
4334 for (int i = 0; i < arg_count; i++) {
ricow@chromium.org30ce4112010-05-31 10:38:25 +00004335 Load(args->at(i));
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00004336 }
4337
ricow@chromium.org30ce4112010-05-31 10:38:25 +00004338 VirtualFrame::SpilledScope spilled_scope(frame_);
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00004339 // Set the name register and call the IC initialization code.
4340 __ mov(r2, Operand(name));
4341 InLoopFlag in_loop = loop_nesting() > 0 ? IN_LOOP : NOT_IN_LOOP;
erik.corry@gmail.com4a6c3272010-11-18 12:04:40 +00004342 Handle<Code> stub =
4343 StubCache::ComputeCallInitialize(arg_count, in_loop);
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00004344 CodeForSourcePosition(node->position());
4345 frame_->CallCodeObject(stub, RelocInfo::CODE_TARGET, arg_count + 1);
4346 __ ldr(cp, frame_->Context());
4347 frame_->EmitPush(r0);
4348 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004349
4350 } else {
4351 // -------------------------------------------
4352 // JavaScript example: 'array[index](1, 2, 3)'
4353 // -------------------------------------------
erik.corry@gmail.com4a6c3272010-11-18 12:04:40 +00004354
4355 // Load the receiver and name of the function.
ricow@chromium.org30ce4112010-05-31 10:38:25 +00004356 Load(property->obj());
erik.corry@gmail.com4a6c3272010-11-18 12:04:40 +00004357 Load(property->key());
4358
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00004359 if (property->is_synthetic()) {
whesse@chromium.org2c186ca2010-06-16 11:32:39 +00004360 EmitKeyedLoad();
4361 // Put the function below the receiver.
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +00004362 // Use the global receiver.
sgjesse@chromium.org720dc0b2010-05-10 09:25:39 +00004363 frame_->EmitPush(r0); // Function.
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00004364 LoadGlobalReceiver(VirtualFrame::scratch0());
whesse@chromium.org2c186ca2010-06-16 11:32:39 +00004365 // Call the function.
4366 CallWithArguments(args, RECEIVER_MIGHT_BE_VALUE, node->position());
4367 frame_->EmitPush(r0);
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00004368 } else {
erik.corry@gmail.com4a6c3272010-11-18 12:04:40 +00004369 // Swap the name of the function and the receiver on the stack to follow
4370 // the calling convention for call ICs.
4371 Register key = frame_->PopToRegister();
4372 Register receiver = frame_->PopToRegister(key);
4373 frame_->EmitPush(key);
4374 frame_->EmitPush(receiver);
4375
whesse@chromium.org2c186ca2010-06-16 11:32:39 +00004376 // Load the arguments.
4377 int arg_count = args->length();
4378 for (int i = 0; i < arg_count; i++) {
4379 Load(args->at(i));
4380 }
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00004381
erik.corry@gmail.com4a6c3272010-11-18 12:04:40 +00004382 // Load the key into r2 and call the IC initialization code.
whesse@chromium.org2c186ca2010-06-16 11:32:39 +00004383 InLoopFlag in_loop = loop_nesting() > 0 ? IN_LOOP : NOT_IN_LOOP;
erik.corry@gmail.com4a6c3272010-11-18 12:04:40 +00004384 Handle<Code> stub =
4385 StubCache::ComputeKeyedCallInitialize(arg_count, in_loop);
whesse@chromium.org2c186ca2010-06-16 11:32:39 +00004386 CodeForSourcePosition(node->position());
erik.corry@gmail.com4a6c3272010-11-18 12:04:40 +00004387 frame_->SpillAll();
4388 __ ldr(r2, frame_->ElementAt(arg_count + 1));
whesse@chromium.org2c186ca2010-06-16 11:32:39 +00004389 frame_->CallCodeObject(stub, RelocInfo::CODE_TARGET, arg_count + 1);
erik.corry@gmail.com4a6c3272010-11-18 12:04:40 +00004390 frame_->Drop(); // Drop the key still on the stack.
whesse@chromium.org2c186ca2010-06-16 11:32:39 +00004391 __ ldr(cp, frame_->Context());
4392 frame_->EmitPush(r0);
4393 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004394 }
4395
4396 } else {
4397 // ----------------------------------
4398 // JavaScript example: 'foo(1, 2, 3)' // foo is not global
4399 // ----------------------------------
4400
4401 // Load the function.
ricow@chromium.org30ce4112010-05-31 10:38:25 +00004402 Load(function);
4403
kasperl@chromium.org9fe21c62008-10-28 08:53:51 +00004404 // Pass the global proxy as the receiver.
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00004405 LoadGlobalReceiver(VirtualFrame::scratch0());
kasperl@chromium.org9fe21c62008-10-28 08:53:51 +00004406
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004407 // Call the function.
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +00004408 CallWithArguments(args, NO_CALL_FUNCTION_FLAGS, node->position());
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00004409 frame_->EmitPush(r0);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004410 }
ager@chromium.orgac091b72010-05-05 07:34:42 +00004411 ASSERT_EQ(original_height + 1, frame_->height());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004412}
4413
4414
ager@chromium.org7c537e22008-10-16 08:43:32 +00004415void CodeGenerator::VisitCallNew(CallNew* node) {
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00004416#ifdef DEBUG
4417 int original_height = frame_->height();
4418#endif
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004419 Comment cmnt(masm_, "[ CallNew");
4420
4421 // According to ECMA-262, section 11.2.2, page 44, the function
4422 // expression in new calls must be evaluated before the
4423 // arguments. This is different from ordinary calls, where the
4424 // actual function to call is resolved after the arguments have been
4425 // evaluated.
4426
ricow@chromium.org65fae842010-08-25 15:26:24 +00004427 // Push constructor on the stack. If it's not a function it's used as
4428 // receiver for CALL_NON_FUNCTION, otherwise the value on the stack is
4429 // ignored.
ricow@chromium.org30ce4112010-05-31 10:38:25 +00004430 Load(node->expression());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004431
4432 // Push the arguments ("left-to-right") on the stack.
4433 ZoneList<Expression*>* args = node->arguments();
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00004434 int arg_count = args->length();
4435 for (int i = 0; i < arg_count; i++) {
ricow@chromium.org30ce4112010-05-31 10:38:25 +00004436 Load(args->at(i));
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00004437 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004438
ricow@chromium.org65fae842010-08-25 15:26:24 +00004439 // Spill everything from here to simplify the implementation.
ricow@chromium.org30ce4112010-05-31 10:38:25 +00004440 VirtualFrame::SpilledScope spilled_scope(frame_);
4441
ricow@chromium.org65fae842010-08-25 15:26:24 +00004442 // Load the argument count into r0 and the function into r1 as per
4443 // calling convention.
christian.plesner.hansen@gmail.com5a6af922009-08-12 14:20:51 +00004444 __ mov(r0, Operand(arg_count));
ricow@chromium.org65fae842010-08-25 15:26:24 +00004445 __ ldr(r1, frame_->ElementAt(arg_count));
kasperl@chromium.orgb9123622008-09-17 14:05:56 +00004446
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004447 // Call the construct call builtin that handles allocation and
4448 // constructor invocation.
christian.plesner.hansen@gmail.com37abdec2009-01-06 14:43:28 +00004449 CodeForSourcePosition(node->position());
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00004450 Handle<Code> ic(Builtins::builtin(Builtins::JSConstructCall));
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +00004451 frame_->CallCodeObject(ic, RelocInfo::CONSTRUCT_CALL, arg_count + 1);
ricow@chromium.org65fae842010-08-25 15:26:24 +00004452 frame_->EmitPush(r0);
mads.s.ager31e71382008-08-13 09:32:07 +00004453
ager@chromium.orgac091b72010-05-05 07:34:42 +00004454 ASSERT_EQ(original_height + 1, frame_->height());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004455}
4456
4457
kasperl@chromium.org2abc4502009-07-02 07:00:29 +00004458void CodeGenerator::GenerateClassOf(ZoneList<Expression*>* args) {
vegorov@chromium.org26c16f82010-08-11 13:41:03 +00004459 Register scratch = VirtualFrame::scratch0();
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00004460 JumpTarget null, function, leave, non_function_constructor;
kasperl@chromium.org86f77b72009-07-06 08:21:57 +00004461
vegorov@chromium.org26c16f82010-08-11 13:41:03 +00004462 // Load the object into register.
4463 ASSERT(args->length() == 1);
ricow@chromium.org30ce4112010-05-31 10:38:25 +00004464 Load(args->at(0));
vegorov@chromium.org26c16f82010-08-11 13:41:03 +00004465 Register tos = frame_->PopToRegister();
kasperl@chromium.org86f77b72009-07-06 08:21:57 +00004466
4467 // If the object is a smi, we return null.
vegorov@chromium.org26c16f82010-08-11 13:41:03 +00004468 __ tst(tos, Operand(kSmiTagMask));
kasperl@chromium.org86f77b72009-07-06 08:21:57 +00004469 null.Branch(eq);
4470
4471 // Check that the object is a JS object but take special care of JS
4472 // functions to make sure they have 'Function' as their class.
vegorov@chromium.org26c16f82010-08-11 13:41:03 +00004473 __ CompareObjectType(tos, tos, scratch, FIRST_JS_OBJECT_TYPE);
kasperl@chromium.org86f77b72009-07-06 08:21:57 +00004474 null.Branch(lt);
4475
4476 // As long as JS_FUNCTION_TYPE is the last instance type and it is
4477 // right after LAST_JS_OBJECT_TYPE, we can avoid checking for
4478 // LAST_JS_OBJECT_TYPE.
whesse@chromium.orgba5a61b2010-07-26 11:44:40 +00004479 STATIC_ASSERT(LAST_TYPE == JS_FUNCTION_TYPE);
4480 STATIC_ASSERT(JS_FUNCTION_TYPE == LAST_JS_OBJECT_TYPE + 1);
vegorov@chromium.org26c16f82010-08-11 13:41:03 +00004481 __ cmp(scratch, Operand(JS_FUNCTION_TYPE));
kasperl@chromium.org86f77b72009-07-06 08:21:57 +00004482 function.Branch(eq);
4483
4484 // Check if the constructor in the map is a function.
vegorov@chromium.org26c16f82010-08-11 13:41:03 +00004485 __ ldr(tos, FieldMemOperand(tos, Map::kConstructorOffset));
4486 __ CompareObjectType(tos, scratch, scratch, JS_FUNCTION_TYPE);
kasperl@chromium.org86f77b72009-07-06 08:21:57 +00004487 non_function_constructor.Branch(ne);
4488
vegorov@chromium.org26c16f82010-08-11 13:41:03 +00004489 // The tos register now contains the constructor function. Grab the
kasperl@chromium.org86f77b72009-07-06 08:21:57 +00004490 // instance class name from there.
vegorov@chromium.org26c16f82010-08-11 13:41:03 +00004491 __ ldr(tos, FieldMemOperand(tos, JSFunction::kSharedFunctionInfoOffset));
4492 __ ldr(tos,
4493 FieldMemOperand(tos, SharedFunctionInfo::kInstanceClassNameOffset));
4494 frame_->EmitPush(tos);
kasperl@chromium.org86f77b72009-07-06 08:21:57 +00004495 leave.Jump();
4496
4497 // Functions have class 'Function'.
4498 function.Bind();
vegorov@chromium.org26c16f82010-08-11 13:41:03 +00004499 __ mov(tos, Operand(Factory::function_class_symbol()));
4500 frame_->EmitPush(tos);
kasperl@chromium.org86f77b72009-07-06 08:21:57 +00004501 leave.Jump();
4502
4503 // Objects with a non-function constructor have class 'Object'.
4504 non_function_constructor.Bind();
vegorov@chromium.org26c16f82010-08-11 13:41:03 +00004505 __ mov(tos, Operand(Factory::Object_symbol()));
4506 frame_->EmitPush(tos);
kasperl@chromium.org86f77b72009-07-06 08:21:57 +00004507 leave.Jump();
4508
4509 // Non-JS objects have class null.
4510 null.Bind();
vegorov@chromium.org26c16f82010-08-11 13:41:03 +00004511 __ LoadRoot(tos, Heap::kNullValueRootIndex);
4512 frame_->EmitPush(tos);
kasperl@chromium.org86f77b72009-07-06 08:21:57 +00004513
4514 // All done.
4515 leave.Bind();
kasperl@chromium.org2abc4502009-07-02 07:00:29 +00004516}
4517
4518
ager@chromium.org7c537e22008-10-16 08:43:32 +00004519void CodeGenerator::GenerateValueOf(ZoneList<Expression*>* args) {
vegorov@chromium.org26c16f82010-08-11 13:41:03 +00004520 Register scratch = VirtualFrame::scratch0();
kasperl@chromium.org71affb52009-05-26 05:44:31 +00004521 JumpTarget leave;
vegorov@chromium.org26c16f82010-08-11 13:41:03 +00004522
4523 ASSERT(args->length() == 1);
ricow@chromium.org30ce4112010-05-31 10:38:25 +00004524 Load(args->at(0));
vegorov@chromium.org26c16f82010-08-11 13:41:03 +00004525 Register tos = frame_->PopToRegister(); // tos contains object.
mads.s.ager31e71382008-08-13 09:32:07 +00004526 // if (object->IsSmi()) return the object.
vegorov@chromium.org26c16f82010-08-11 13:41:03 +00004527 __ tst(tos, Operand(kSmiTagMask));
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00004528 leave.Branch(eq);
ager@chromium.orgeadaf222009-06-16 09:43:10 +00004529 // It is a heap object - get map. If (!object->IsJSValue()) return the object.
vegorov@chromium.org26c16f82010-08-11 13:41:03 +00004530 __ CompareObjectType(tos, scratch, scratch, JS_VALUE_TYPE);
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00004531 leave.Branch(ne);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004532 // Load the value.
vegorov@chromium.org26c16f82010-08-11 13:41:03 +00004533 __ ldr(tos, FieldMemOperand(tos, JSValue::kValueOffset));
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00004534 leave.Bind();
vegorov@chromium.org26c16f82010-08-11 13:41:03 +00004535 frame_->EmitPush(tos);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004536}
4537
4538
ager@chromium.org7c537e22008-10-16 08:43:32 +00004539void CodeGenerator::GenerateSetValueOf(ZoneList<Expression*>* args) {
vegorov@chromium.org26c16f82010-08-11 13:41:03 +00004540 Register scratch1 = VirtualFrame::scratch0();
4541 Register scratch2 = VirtualFrame::scratch1();
kasperl@chromium.org71affb52009-05-26 05:44:31 +00004542 JumpTarget leave;
vegorov@chromium.org26c16f82010-08-11 13:41:03 +00004543
4544 ASSERT(args->length() == 2);
ricow@chromium.org30ce4112010-05-31 10:38:25 +00004545 Load(args->at(0)); // Load the object.
4546 Load(args->at(1)); // Load the value.
vegorov@chromium.org26c16f82010-08-11 13:41:03 +00004547 Register value = frame_->PopToRegister();
4548 Register object = frame_->PopToRegister(value);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004549 // if (object->IsSmi()) return object.
vegorov@chromium.org26c16f82010-08-11 13:41:03 +00004550 __ tst(object, Operand(kSmiTagMask));
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00004551 leave.Branch(eq);
ager@chromium.orgeadaf222009-06-16 09:43:10 +00004552 // It is a heap object - get map. If (!object->IsJSValue()) return the object.
vegorov@chromium.org26c16f82010-08-11 13:41:03 +00004553 __ CompareObjectType(object, scratch1, scratch1, JS_VALUE_TYPE);
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00004554 leave.Branch(ne);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004555 // Store the value.
vegorov@chromium.org26c16f82010-08-11 13:41:03 +00004556 __ str(value, FieldMemOperand(object, JSValue::kValueOffset));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004557 // Update the write barrier.
vegorov@chromium.org26c16f82010-08-11 13:41:03 +00004558 __ RecordWrite(object,
4559 Operand(JSValue::kValueOffset - kHeapObjectTag),
4560 scratch1,
4561 scratch2);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004562 // Leave.
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00004563 leave.Bind();
vegorov@chromium.org26c16f82010-08-11 13:41:03 +00004564 frame_->EmitPush(value);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004565}
4566
4567
ager@chromium.org7c537e22008-10-16 08:43:32 +00004568void CodeGenerator::GenerateIsSmi(ZoneList<Expression*>* args) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004569 ASSERT(args->length() == 1);
kmillikin@chromium.org9155e252010-05-26 13:27:57 +00004570 Load(args->at(0));
4571 Register reg = frame_->PopToRegister();
4572 __ tst(reg, Operand(kSmiTagMask));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004573 cc_reg_ = eq;
4574}
4575
4576
christian.plesner.hansen@gmail.com37abdec2009-01-06 14:43:28 +00004577void CodeGenerator::GenerateLog(ZoneList<Expression*>* args) {
4578 // See comment in CodeGenerator::GenerateLog in codegen-ia32.cc.
4579 ASSERT_EQ(args->length(), 3);
christian.plesner.hansen@gmail.comaca49682009-01-07 14:29:04 +00004580#ifdef ENABLE_LOGGING_AND_PROFILING
christian.plesner.hansen@gmail.com37abdec2009-01-06 14:43:28 +00004581 if (ShouldGenerateLog(args->at(0))) {
kmillikin@chromium.org9155e252010-05-26 13:27:57 +00004582 Load(args->at(1));
4583 Load(args->at(2));
ricow@chromium.org30ce4112010-05-31 10:38:25 +00004584 frame_->CallRuntime(Runtime::kLog, 2);
christian.plesner.hansen@gmail.com37abdec2009-01-06 14:43:28 +00004585 }
christian.plesner.hansen@gmail.comaca49682009-01-07 14:29:04 +00004586#endif
kmillikin@chromium.org9155e252010-05-26 13:27:57 +00004587 frame_->EmitPushRoot(Heap::kUndefinedValueRootIndex);
christian.plesner.hansen@gmail.com37abdec2009-01-06 14:43:28 +00004588}
4589
4590
ager@chromium.org7c537e22008-10-16 08:43:32 +00004591void CodeGenerator::GenerateIsNonNegativeSmi(ZoneList<Expression*>* args) {
ager@chromium.orgc27e4e72008-09-04 13:52:27 +00004592 ASSERT(args->length() == 1);
kmillikin@chromium.org9155e252010-05-26 13:27:57 +00004593 Load(args->at(0));
4594 Register reg = frame_->PopToRegister();
4595 __ tst(reg, Operand(kSmiTagMask | 0x80000000u));
ager@chromium.orgc27e4e72008-09-04 13:52:27 +00004596 cc_reg_ = eq;
4597}
4598
4599
lrn@chromium.org32d961d2010-06-30 09:09:34 +00004600// Generates the Math.pow method.
ager@chromium.orgce5e87b2010-03-10 10:24:18 +00004601void CodeGenerator::GenerateMathPow(ZoneList<Expression*>* args) {
4602 ASSERT(args->length() == 2);
4603 Load(args->at(0));
4604 Load(args->at(1));
lrn@chromium.org32d961d2010-06-30 09:09:34 +00004605
4606 if (!CpuFeatures::IsSupported(VFP3)) {
4607 frame_->CallRuntime(Runtime::kMath_pow, 2);
4608 frame_->EmitPush(r0);
4609 } else {
4610 CpuFeatures::Scope scope(VFP3);
4611 JumpTarget runtime, done;
kmillikin@chromium.org69ea3962010-07-05 11:01:40 +00004612 Label exponent_nonsmi, base_nonsmi, powi, not_minus_half, allocate_return;
lrn@chromium.org32d961d2010-06-30 09:09:34 +00004613
4614 Register scratch1 = VirtualFrame::scratch0();
4615 Register scratch2 = VirtualFrame::scratch1();
4616
4617 // Get base and exponent to registers.
4618 Register exponent = frame_->PopToRegister();
4619 Register base = frame_->PopToRegister(exponent);
kmillikin@chromium.org69ea3962010-07-05 11:01:40 +00004620 Register heap_number_map = no_reg;
lrn@chromium.org32d961d2010-06-30 09:09:34 +00004621
4622 // Set the frame for the runtime jump target. The code below jumps to the
4623 // jump target label so the frame needs to be established before that.
4624 ASSERT(runtime.entry_frame() == NULL);
4625 runtime.set_entry_frame(frame_);
4626
ager@chromium.org378b34e2011-01-28 08:04:38 +00004627 __ JumpIfNotSmi(exponent, &exponent_nonsmi);
4628 __ JumpIfNotSmi(base, &base_nonsmi);
lrn@chromium.org32d961d2010-06-30 09:09:34 +00004629
kmillikin@chromium.org69ea3962010-07-05 11:01:40 +00004630 heap_number_map = r6;
4631 __ LoadRoot(heap_number_map, Heap::kHeapNumberMapRootIndex);
4632
4633 // Exponent is a smi and base is a smi. Get the smi value into vfp register
4634 // d1.
4635 __ SmiToDoubleVFPRegister(base, d1, scratch1, s0);
4636 __ b(&powi);
4637
4638 __ bind(&base_nonsmi);
4639 // Exponent is smi and base is non smi. Get the double value from the base
4640 // into vfp register d1.
4641 __ ObjectToDoubleVFPRegister(base, d1,
4642 scratch1, scratch2, heap_number_map, s0,
4643 runtime.entry_label());
4644
4645 __ bind(&powi);
4646
4647 // Load 1.0 into d0.
ager@chromium.org6a2b0aa2010-07-13 20:58:03 +00004648 __ vmov(d0, 1.0);
kmillikin@chromium.org69ea3962010-07-05 11:01:40 +00004649
4650 // Get the absolute untagged value of the exponent and use that for the
4651 // calculation.
4652 __ mov(scratch1, Operand(exponent, ASR, kSmiTagSize), SetCC);
ager@chromium.org5b2fbee2010-09-08 06:38:15 +00004653 // Negate if negative.
4654 __ rsb(scratch1, scratch1, Operand(0, RelocInfo::NONE), LeaveCC, mi);
kmillikin@chromium.org69ea3962010-07-05 11:01:40 +00004655 __ vmov(d2, d0, mi); // 1.0 needed in d2 later if exponent is negative.
4656
4657 // Run through all the bits in the exponent. The result is calculated in d0
4658 // and d1 holds base^(bit^2).
4659 Label more_bits;
4660 __ bind(&more_bits);
4661 __ mov(scratch1, Operand(scratch1, LSR, 1), SetCC);
4662 __ vmul(d0, d0, d1, cs); // Multiply with base^(bit^2) if bit is set.
4663 __ vmul(d1, d1, d1, ne); // Don't bother calculating next d1 if done.
4664 __ b(ne, &more_bits);
4665
4666 // If exponent is positive we are done.
ager@chromium.org5b2fbee2010-09-08 06:38:15 +00004667 __ cmp(exponent, Operand(0, RelocInfo::NONE));
kmillikin@chromium.org69ea3962010-07-05 11:01:40 +00004668 __ b(ge, &allocate_return);
4669
4670 // If exponent is negative result is 1/result (d2 already holds 1.0 in that
4671 // case). However if d0 has reached infinity this will not provide the
4672 // correct result, so call runtime if that is the case.
4673 __ mov(scratch2, Operand(0x7FF00000));
ager@chromium.org5b2fbee2010-09-08 06:38:15 +00004674 __ mov(scratch1, Operand(0, RelocInfo::NONE));
kmillikin@chromium.org69ea3962010-07-05 11:01:40 +00004675 __ vmov(d1, scratch1, scratch2); // Load infinity into d1.
sgjesse@chromium.orgc6c57182011-01-17 12:24:25 +00004676 __ VFPCompareAndSetFlags(d0, d1);
kmillikin@chromium.org69ea3962010-07-05 11:01:40 +00004677 runtime.Branch(eq); // d0 reached infinity.
4678 __ vdiv(d0, d2, d0);
4679 __ b(&allocate_return);
4680
4681 __ bind(&exponent_nonsmi);
lrn@chromium.org32d961d2010-06-30 09:09:34 +00004682 // Special handling of raising to the power of -0.5 and 0.5. First check
4683 // that the value is a heap number and that the lower bits (which for both
4684 // values are zero).
kmillikin@chromium.org69ea3962010-07-05 11:01:40 +00004685 heap_number_map = r6;
lrn@chromium.org32d961d2010-06-30 09:09:34 +00004686 __ LoadRoot(heap_number_map, Heap::kHeapNumberMapRootIndex);
4687 __ ldr(scratch1, FieldMemOperand(exponent, HeapObject::kMapOffset));
4688 __ ldr(scratch2, FieldMemOperand(exponent, HeapNumber::kMantissaOffset));
4689 __ cmp(scratch1, heap_number_map);
4690 runtime.Branch(ne);
4691 __ tst(scratch2, scratch2);
4692 runtime.Branch(ne);
4693
kmillikin@chromium.org69ea3962010-07-05 11:01:40 +00004694 // Load the higher bits (which contains the floating point exponent).
lrn@chromium.org32d961d2010-06-30 09:09:34 +00004695 __ ldr(scratch1, FieldMemOperand(exponent, HeapNumber::kExponentOffset));
4696
4697 // Compare exponent with -0.5.
4698 __ cmp(scratch1, Operand(0xbfe00000));
4699 __ b(ne, &not_minus_half);
4700
4701 // Get the double value from the base into vfp register d0.
4702 __ ObjectToDoubleVFPRegister(base, d0,
4703 scratch1, scratch2, heap_number_map, s0,
4704 runtime.entry_label(),
4705 AVOID_NANS_AND_INFINITIES);
4706
kmillikin@chromium.org31b12772011-02-02 16:08:26 +00004707 // Convert -0 into +0 by adding +0.
4708 __ vmov(d2, 0.0);
4709 __ vadd(d0, d2, d0);
lrn@chromium.org32d961d2010-06-30 09:09:34 +00004710 // Load 1.0 into d2.
ager@chromium.org6a2b0aa2010-07-13 20:58:03 +00004711 __ vmov(d2, 1.0);
lrn@chromium.org32d961d2010-06-30 09:09:34 +00004712
kmillikin@chromium.org31b12772011-02-02 16:08:26 +00004713 // Calculate the reciprocal of the square root.
lrn@chromium.org32d961d2010-06-30 09:09:34 +00004714 __ vsqrt(d0, d0);
kmillikin@chromium.org31b12772011-02-02 16:08:26 +00004715 __ vdiv(d0, d2, d0);
lrn@chromium.org32d961d2010-06-30 09:09:34 +00004716
4717 __ b(&allocate_return);
4718
4719 __ bind(&not_minus_half);
4720 // Compare exponent with 0.5.
4721 __ cmp(scratch1, Operand(0x3fe00000));
4722 runtime.Branch(ne);
4723
4724 // Get the double value from the base into vfp register d0.
4725 __ ObjectToDoubleVFPRegister(base, d0,
4726 scratch1, scratch2, heap_number_map, s0,
4727 runtime.entry_label(),
4728 AVOID_NANS_AND_INFINITIES);
kmillikin@chromium.org31b12772011-02-02 16:08:26 +00004729 // Convert -0 into +0 by adding +0.
4730 __ vmov(d2, 0.0);
4731 __ vadd(d0, d2, d0);
lrn@chromium.org32d961d2010-06-30 09:09:34 +00004732 __ vsqrt(d0, d0);
4733
4734 __ bind(&allocate_return);
kmillikin@chromium.org69ea3962010-07-05 11:01:40 +00004735 Register scratch3 = r5;
4736 __ AllocateHeapNumberWithValue(scratch3, d0, scratch1, scratch2,
4737 heap_number_map, runtime.entry_label());
4738 __ mov(base, scratch3);
lrn@chromium.org32d961d2010-06-30 09:09:34 +00004739 done.Jump();
4740
4741 runtime.Bind();
4742
4743 // Push back the arguments again for the runtime call.
4744 frame_->EmitPush(base);
4745 frame_->EmitPush(exponent);
4746 frame_->CallRuntime(Runtime::kMath_pow, 2);
4747 __ Move(base, r0);
4748
4749 done.Bind();
4750 frame_->EmitPush(base);
4751 }
ager@chromium.orgce5e87b2010-03-10 10:24:18 +00004752}
4753
4754
lrn@chromium.org32d961d2010-06-30 09:09:34 +00004755// Generates the Math.sqrt method.
ager@chromium.orgce5e87b2010-03-10 10:24:18 +00004756void CodeGenerator::GenerateMathSqrt(ZoneList<Expression*>* args) {
4757 ASSERT(args->length() == 1);
4758 Load(args->at(0));
lrn@chromium.org32d961d2010-06-30 09:09:34 +00004759
4760 if (!CpuFeatures::IsSupported(VFP3)) {
4761 frame_->CallRuntime(Runtime::kMath_sqrt, 1);
4762 frame_->EmitPush(r0);
4763 } else {
4764 CpuFeatures::Scope scope(VFP3);
4765 JumpTarget runtime, done;
4766
4767 Register scratch1 = VirtualFrame::scratch0();
4768 Register scratch2 = VirtualFrame::scratch1();
4769
4770 // Get the value from the frame.
4771 Register tos = frame_->PopToRegister();
4772
4773 // Set the frame for the runtime jump target. The code below jumps to the
4774 // jump target label so the frame needs to be established before that.
4775 ASSERT(runtime.entry_frame() == NULL);
4776 runtime.set_entry_frame(frame_);
4777
4778 Register heap_number_map = r6;
lrn@chromium.org303ada72010-10-27 09:33:13 +00004779 Register new_heap_number = r5;
lrn@chromium.org32d961d2010-06-30 09:09:34 +00004780 __ LoadRoot(heap_number_map, Heap::kHeapNumberMapRootIndex);
4781
4782 // Get the double value from the heap number into vfp register d0.
4783 __ ObjectToDoubleVFPRegister(tos, d0,
4784 scratch1, scratch2, heap_number_map, s0,
4785 runtime.entry_label());
4786
4787 // Calculate the square root of d0 and place result in a heap number object.
4788 __ vsqrt(d0, d0);
lrn@chromium.org303ada72010-10-27 09:33:13 +00004789 __ AllocateHeapNumberWithValue(new_heap_number,
4790 d0,
4791 scratch1, scratch2,
4792 heap_number_map,
4793 runtime.entry_label());
4794 __ mov(tos, Operand(new_heap_number));
lrn@chromium.org32d961d2010-06-30 09:09:34 +00004795 done.Jump();
4796
4797 runtime.Bind();
4798 // Push back the argument again for the runtime call.
4799 frame_->EmitPush(tos);
4800 frame_->CallRuntime(Runtime::kMath_sqrt, 1);
4801 __ Move(tos, r0);
4802
4803 done.Bind();
4804 frame_->EmitPush(tos);
4805 }
ager@chromium.orgce5e87b2010-03-10 10:24:18 +00004806}
4807
4808
ricow@chromium.org30ce4112010-05-31 10:38:25 +00004809class DeferredStringCharCodeAt : public DeferredCode {
4810 public:
4811 DeferredStringCharCodeAt(Register object,
4812 Register index,
4813 Register scratch,
4814 Register result)
4815 : result_(result),
4816 char_code_at_generator_(object,
4817 index,
4818 scratch,
4819 result,
4820 &need_conversion_,
4821 &need_conversion_,
4822 &index_out_of_range_,
4823 STRING_INDEX_IS_NUMBER) {}
4824
4825 StringCharCodeAtGenerator* fast_case_generator() {
4826 return &char_code_at_generator_;
4827 }
4828
4829 virtual void Generate() {
4830 VirtualFrameRuntimeCallHelper call_helper(frame_state());
4831 char_code_at_generator_.GenerateSlow(masm(), call_helper);
4832
4833 __ bind(&need_conversion_);
4834 // Move the undefined value into the result register, which will
4835 // trigger conversion.
4836 __ LoadRoot(result_, Heap::kUndefinedValueRootIndex);
4837 __ jmp(exit_label());
4838
4839 __ bind(&index_out_of_range_);
4840 // When the index is out of range, the spec requires us to return
4841 // NaN.
4842 __ LoadRoot(result_, Heap::kNanValueRootIndex);
4843 __ jmp(exit_label());
4844 }
4845
4846 private:
4847 Register result_;
4848
4849 Label need_conversion_;
4850 Label index_out_of_range_;
4851
4852 StringCharCodeAtGenerator char_code_at_generator_;
4853};
4854
4855
4856// This generates code that performs a String.prototype.charCodeAt() call
4857// or returns a smi in order to trigger conversion.
4858void CodeGenerator::GenerateStringCharCodeAt(ZoneList<Expression*>* args) {
ricow@chromium.org30ce4112010-05-31 10:38:25 +00004859 Comment(masm_, "[ GenerateStringCharCodeAt");
kasper.lund7276f142008-07-30 08:49:36 +00004860 ASSERT(args->length() == 2);
ager@chromium.orgc4c92722009-11-18 14:12:51 +00004861
kmillikin@chromium.org9155e252010-05-26 13:27:57 +00004862 Load(args->at(0));
4863 Load(args->at(1));
ager@chromium.orgc4c92722009-11-18 14:12:51 +00004864
vegorov@chromium.org26c16f82010-08-11 13:41:03 +00004865 Register index = frame_->PopToRegister();
4866 Register object = frame_->PopToRegister(index);
ager@chromium.orgc4c92722009-11-18 14:12:51 +00004867
ricow@chromium.org30ce4112010-05-31 10:38:25 +00004868 // We need two extra registers.
vegorov@chromium.org26c16f82010-08-11 13:41:03 +00004869 Register scratch = VirtualFrame::scratch0();
4870 Register result = VirtualFrame::scratch1();
ricow@chromium.org30ce4112010-05-31 10:38:25 +00004871
4872 DeferredStringCharCodeAt* deferred =
4873 new DeferredStringCharCodeAt(object,
4874 index,
4875 scratch,
4876 result);
4877 deferred->fast_case_generator()->GenerateFast(masm_);
4878 deferred->BindExit();
kmillikin@chromium.org9155e252010-05-26 13:27:57 +00004879 frame_->EmitPush(result);
kasper.lund7276f142008-07-30 08:49:36 +00004880}
4881
4882
ricow@chromium.org30ce4112010-05-31 10:38:25 +00004883class DeferredStringCharFromCode : public DeferredCode {
4884 public:
4885 DeferredStringCharFromCode(Register code,
4886 Register result)
4887 : char_from_code_generator_(code, result) {}
4888
4889 StringCharFromCodeGenerator* fast_case_generator() {
4890 return &char_from_code_generator_;
4891 }
4892
4893 virtual void Generate() {
4894 VirtualFrameRuntimeCallHelper call_helper(frame_state());
4895 char_from_code_generator_.GenerateSlow(masm(), call_helper);
4896 }
4897
4898 private:
4899 StringCharFromCodeGenerator char_from_code_generator_;
4900};
4901
4902
4903// Generates code for creating a one-char string from a char code.
4904void CodeGenerator::GenerateStringCharFromCode(ZoneList<Expression*>* args) {
ricow@chromium.org30ce4112010-05-31 10:38:25 +00004905 Comment(masm_, "[ GenerateStringCharFromCode");
ager@chromium.orgce5e87b2010-03-10 10:24:18 +00004906 ASSERT(args->length() == 1);
4907
ricow@chromium.org30ce4112010-05-31 10:38:25 +00004908 Load(args->at(0));
4909
vegorov@chromium.org26c16f82010-08-11 13:41:03 +00004910 Register result = frame_->GetTOSRegister();
4911 Register code = frame_->PopToRegister(result);
ager@chromium.orgce5e87b2010-03-10 10:24:18 +00004912
ricow@chromium.org30ce4112010-05-31 10:38:25 +00004913 DeferredStringCharFromCode* deferred = new DeferredStringCharFromCode(
4914 code, result);
4915 deferred->fast_case_generator()->GenerateFast(masm_);
4916 deferred->BindExit();
4917 frame_->EmitPush(result);
4918}
4919
4920
4921class DeferredStringCharAt : public DeferredCode {
4922 public:
4923 DeferredStringCharAt(Register object,
4924 Register index,
4925 Register scratch1,
4926 Register scratch2,
4927 Register result)
4928 : result_(result),
4929 char_at_generator_(object,
4930 index,
4931 scratch1,
4932 scratch2,
4933 result,
4934 &need_conversion_,
4935 &need_conversion_,
4936 &index_out_of_range_,
4937 STRING_INDEX_IS_NUMBER) {}
4938
4939 StringCharAtGenerator* fast_case_generator() {
4940 return &char_at_generator_;
4941 }
4942
4943 virtual void Generate() {
4944 VirtualFrameRuntimeCallHelper call_helper(frame_state());
4945 char_at_generator_.GenerateSlow(masm(), call_helper);
4946
4947 __ bind(&need_conversion_);
4948 // Move smi zero into the result register, which will trigger
4949 // conversion.
4950 __ mov(result_, Operand(Smi::FromInt(0)));
4951 __ jmp(exit_label());
4952
4953 __ bind(&index_out_of_range_);
4954 // When the index is out of range, the spec requires us to return
4955 // the empty string.
4956 __ LoadRoot(result_, Heap::kEmptyStringRootIndex);
4957 __ jmp(exit_label());
4958 }
4959
4960 private:
4961 Register result_;
4962
4963 Label need_conversion_;
4964 Label index_out_of_range_;
4965
4966 StringCharAtGenerator char_at_generator_;
4967};
4968
4969
4970// This generates code that performs a String.prototype.charAt() call
4971// or returns a smi in order to trigger conversion.
4972void CodeGenerator::GenerateStringCharAt(ZoneList<Expression*>* args) {
ricow@chromium.org30ce4112010-05-31 10:38:25 +00004973 Comment(masm_, "[ GenerateStringCharAt");
4974 ASSERT(args->length() == 2);
4975
4976 Load(args->at(0));
4977 Load(args->at(1));
4978
vegorov@chromium.org26c16f82010-08-11 13:41:03 +00004979 Register index = frame_->PopToRegister();
4980 Register object = frame_->PopToRegister(index);
ricow@chromium.org30ce4112010-05-31 10:38:25 +00004981
4982 // We need three extra registers.
vegorov@chromium.org26c16f82010-08-11 13:41:03 +00004983 Register scratch1 = VirtualFrame::scratch0();
4984 Register scratch2 = VirtualFrame::scratch1();
4985 // Use r6 without notifying the virtual frame.
4986 Register result = r6;
ricow@chromium.org30ce4112010-05-31 10:38:25 +00004987
4988 DeferredStringCharAt* deferred =
4989 new DeferredStringCharAt(object,
4990 index,
4991 scratch1,
4992 scratch2,
4993 result);
4994 deferred->fast_case_generator()->GenerateFast(masm_);
4995 deferred->BindExit();
ager@chromium.orgac091b72010-05-05 07:34:42 +00004996 frame_->EmitPush(result);
ager@chromium.orgce5e87b2010-03-10 10:24:18 +00004997}
4998
4999
ager@chromium.org7c537e22008-10-16 08:43:32 +00005000void CodeGenerator::GenerateIsArray(ZoneList<Expression*>* args) {
kasperl@chromium.orgb9123622008-09-17 14:05:56 +00005001 ASSERT(args->length() == 1);
ricow@chromium.org30ce4112010-05-31 10:38:25 +00005002 Load(args->at(0));
kasperl@chromium.org71affb52009-05-26 05:44:31 +00005003 JumpTarget answer;
kasperl@chromium.orgb9123622008-09-17 14:05:56 +00005004 // We need the CC bits to come out as not_equal in the case where the
5005 // object is a smi. This can't be done with the usual test opcode so
5006 // we use XOR to get the right CC bits.
ricow@chromium.org30ce4112010-05-31 10:38:25 +00005007 Register possible_array = frame_->PopToRegister();
5008 Register scratch = VirtualFrame::scratch0();
5009 __ and_(scratch, possible_array, Operand(kSmiTagMask));
5010 __ eor(scratch, scratch, Operand(kSmiTagMask), SetCC);
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00005011 answer.Branch(ne);
ager@chromium.orgeadaf222009-06-16 09:43:10 +00005012 // It is a heap object - get the map. Check if the object is a JS array.
ricow@chromium.org30ce4112010-05-31 10:38:25 +00005013 __ CompareObjectType(possible_array, scratch, scratch, JS_ARRAY_TYPE);
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00005014 answer.Bind();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005015 cc_reg_ = eq;
5016}
5017
5018
fschneider@chromium.orgb95b98b2010-02-23 10:34:29 +00005019void CodeGenerator::GenerateIsRegExp(ZoneList<Expression*>* args) {
fschneider@chromium.orgb95b98b2010-02-23 10:34:29 +00005020 ASSERT(args->length() == 1);
ricow@chromium.org30ce4112010-05-31 10:38:25 +00005021 Load(args->at(0));
fschneider@chromium.orgb95b98b2010-02-23 10:34:29 +00005022 JumpTarget answer;
5023 // We need the CC bits to come out as not_equal in the case where the
5024 // object is a smi. This can't be done with the usual test opcode so
5025 // we use XOR to get the right CC bits.
ricow@chromium.org30ce4112010-05-31 10:38:25 +00005026 Register possible_regexp = frame_->PopToRegister();
5027 Register scratch = VirtualFrame::scratch0();
5028 __ and_(scratch, possible_regexp, Operand(kSmiTagMask));
5029 __ eor(scratch, scratch, Operand(kSmiTagMask), SetCC);
fschneider@chromium.orgb95b98b2010-02-23 10:34:29 +00005030 answer.Branch(ne);
5031 // It is a heap object - get the map. Check if the object is a regexp.
ricow@chromium.org30ce4112010-05-31 10:38:25 +00005032 __ CompareObjectType(possible_regexp, scratch, scratch, JS_REGEXP_TYPE);
fschneider@chromium.orgb95b98b2010-02-23 10:34:29 +00005033 answer.Bind();
5034 cc_reg_ = eq;
5035}
5036
5037
ager@chromium.org6141cbe2009-11-20 12:14:52 +00005038void CodeGenerator::GenerateIsObject(ZoneList<Expression*>* args) {
5039 // This generates a fast version of:
5040 // (typeof(arg) === 'object' || %_ClassOf(arg) == 'RegExp')
ager@chromium.org6141cbe2009-11-20 12:14:52 +00005041 ASSERT(args->length() == 1);
ricow@chromium.org30ce4112010-05-31 10:38:25 +00005042 Load(args->at(0));
5043 Register possible_object = frame_->PopToRegister();
5044 __ tst(possible_object, Operand(kSmiTagMask));
ager@chromium.org6141cbe2009-11-20 12:14:52 +00005045 false_target()->Branch(eq);
5046
5047 __ LoadRoot(ip, Heap::kNullValueRootIndex);
ricow@chromium.org30ce4112010-05-31 10:38:25 +00005048 __ cmp(possible_object, ip);
ager@chromium.org6141cbe2009-11-20 12:14:52 +00005049 true_target()->Branch(eq);
5050
ricow@chromium.org30ce4112010-05-31 10:38:25 +00005051 Register map_reg = VirtualFrame::scratch0();
5052 __ ldr(map_reg, FieldMemOperand(possible_object, HeapObject::kMapOffset));
ager@chromium.org6141cbe2009-11-20 12:14:52 +00005053 // Undetectable objects behave like undefined when tested with typeof.
ricow@chromium.org30ce4112010-05-31 10:38:25 +00005054 __ ldrb(possible_object, FieldMemOperand(map_reg, Map::kBitFieldOffset));
5055 __ tst(possible_object, Operand(1 << Map::kIsUndetectable));
kmillikin@chromium.org9155e252010-05-26 13:27:57 +00005056 false_target()->Branch(ne);
ager@chromium.org6141cbe2009-11-20 12:14:52 +00005057
ricow@chromium.org30ce4112010-05-31 10:38:25 +00005058 __ ldrb(possible_object, FieldMemOperand(map_reg, Map::kInstanceTypeOffset));
5059 __ cmp(possible_object, Operand(FIRST_JS_OBJECT_TYPE));
ager@chromium.org6141cbe2009-11-20 12:14:52 +00005060 false_target()->Branch(lt);
ricow@chromium.org30ce4112010-05-31 10:38:25 +00005061 __ cmp(possible_object, Operand(LAST_JS_OBJECT_TYPE));
ager@chromium.org6141cbe2009-11-20 12:14:52 +00005062 cc_reg_ = le;
5063}
5064
5065
ricow@chromium.org4980dff2010-07-19 08:33:45 +00005066void CodeGenerator::GenerateIsSpecObject(ZoneList<Expression*>* args) {
5067 // This generates a fast version of:
5068 // (typeof(arg) === 'object' || %_ClassOf(arg) == 'RegExp' ||
5069 // typeof(arg) == function).
5070 // It includes undetectable objects (as opposed to IsObject).
5071 ASSERT(args->length() == 1);
5072 Load(args->at(0));
5073 Register value = frame_->PopToRegister();
5074 __ tst(value, Operand(kSmiTagMask));
5075 false_target()->Branch(eq);
5076 // Check that this is an object.
5077 __ ldr(value, FieldMemOperand(value, HeapObject::kMapOffset));
5078 __ ldrb(value, FieldMemOperand(value, Map::kInstanceTypeOffset));
5079 __ cmp(value, Operand(FIRST_JS_OBJECT_TYPE));
5080 cc_reg_ = ge;
5081}
5082
5083
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00005084// Deferred code to check whether the String JavaScript object is safe for using
5085// default value of. This code is called after the bit caching this information
5086// in the map has been checked with the map for the object in the map_result_
5087// register. On return the register map_result_ contains 1 for true and 0 for
5088// false.
5089class DeferredIsStringWrapperSafeForDefaultValueOf : public DeferredCode {
5090 public:
5091 DeferredIsStringWrapperSafeForDefaultValueOf(Register object,
5092 Register map_result,
5093 Register scratch1,
5094 Register scratch2)
5095 : object_(object),
5096 map_result_(map_result),
5097 scratch1_(scratch1),
5098 scratch2_(scratch2) { }
5099
5100 virtual void Generate() {
5101 Label false_result;
5102
5103 // Check that map is loaded as expected.
5104 if (FLAG_debug_code) {
5105 __ ldr(ip, FieldMemOperand(object_, HeapObject::kMapOffset));
5106 __ cmp(map_result_, ip);
5107 __ Assert(eq, "Map not in expected register");
5108 }
5109
5110 // Check for fast case object. Generate false result for slow case object.
5111 __ ldr(scratch1_, FieldMemOperand(object_, JSObject::kPropertiesOffset));
5112 __ ldr(scratch1_, FieldMemOperand(scratch1_, HeapObject::kMapOffset));
5113 __ LoadRoot(ip, Heap::kHashTableMapRootIndex);
5114 __ cmp(scratch1_, ip);
5115 __ b(eq, &false_result);
5116
5117 // Look for valueOf symbol in the descriptor array, and indicate false if
5118 // found. The type is not checked, so if it is a transition it is a false
5119 // negative.
5120 __ ldr(map_result_,
5121 FieldMemOperand(map_result_, Map::kInstanceDescriptorsOffset));
5122 __ ldr(scratch2_, FieldMemOperand(map_result_, FixedArray::kLengthOffset));
5123 // map_result_: descriptor array
5124 // scratch2_: length of descriptor array
5125 // Calculate the end of the descriptor array.
5126 STATIC_ASSERT(kSmiTag == 0);
5127 STATIC_ASSERT(kSmiTagSize == 1);
5128 STATIC_ASSERT(kPointerSize == 4);
5129 __ add(scratch1_,
5130 map_result_,
5131 Operand(FixedArray::kHeaderSize - kHeapObjectTag));
5132 __ add(scratch1_,
5133 scratch1_,
5134 Operand(scratch2_, LSL, kPointerSizeLog2 - kSmiTagSize));
5135
5136 // Calculate location of the first key name.
5137 __ add(map_result_,
5138 map_result_,
5139 Operand(FixedArray::kHeaderSize - kHeapObjectTag +
5140 DescriptorArray::kFirstIndex * kPointerSize));
5141 // Loop through all the keys in the descriptor array. If one of these is the
5142 // symbol valueOf the result is false.
5143 Label entry, loop;
5144 // The use of ip to store the valueOf symbol asumes that it is not otherwise
5145 // used in the loop below.
5146 __ mov(ip, Operand(Factory::value_of_symbol()));
5147 __ jmp(&entry);
5148 __ bind(&loop);
5149 __ ldr(scratch2_, MemOperand(map_result_, 0));
5150 __ cmp(scratch2_, ip);
5151 __ b(eq, &false_result);
5152 __ add(map_result_, map_result_, Operand(kPointerSize));
5153 __ bind(&entry);
5154 __ cmp(map_result_, Operand(scratch1_));
5155 __ b(ne, &loop);
5156
5157 // Reload map as register map_result_ was used as temporary above.
5158 __ ldr(map_result_, FieldMemOperand(object_, HeapObject::kMapOffset));
5159
5160 // If a valueOf property is not found on the object check that it's
5161 // prototype is the un-modified String prototype. If not result is false.
5162 __ ldr(scratch1_, FieldMemOperand(map_result_, Map::kPrototypeOffset));
5163 __ tst(scratch1_, Operand(kSmiTagMask));
5164 __ b(eq, &false_result);
5165 __ ldr(scratch1_, FieldMemOperand(scratch1_, HeapObject::kMapOffset));
5166 __ ldr(scratch2_,
erik.corry@gmail.com4a6c3272010-11-18 12:04:40 +00005167 ContextOperand(cp, Context::GLOBAL_INDEX));
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00005168 __ ldr(scratch2_,
5169 FieldMemOperand(scratch2_, GlobalObject::kGlobalContextOffset));
5170 __ ldr(scratch2_,
erik.corry@gmail.com4a6c3272010-11-18 12:04:40 +00005171 ContextOperand(
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00005172 scratch2_, Context::STRING_FUNCTION_PROTOTYPE_MAP_INDEX));
5173 __ cmp(scratch1_, scratch2_);
5174 __ b(ne, &false_result);
5175
5176 // Set the bit in the map to indicate that it has been checked safe for
5177 // default valueOf and set true result.
5178 __ ldr(scratch1_, FieldMemOperand(map_result_, Map::kBitField2Offset));
5179 __ orr(scratch1_,
5180 scratch1_,
5181 Operand(1 << Map::kStringWrapperSafeForDefaultValueOf));
5182 __ str(scratch1_, FieldMemOperand(map_result_, Map::kBitField2Offset));
5183 __ mov(map_result_, Operand(1));
5184 __ jmp(exit_label());
5185 __ bind(&false_result);
5186 // Set false result.
ager@chromium.org5b2fbee2010-09-08 06:38:15 +00005187 __ mov(map_result_, Operand(0, RelocInfo::NONE));
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00005188 }
5189
5190 private:
5191 Register object_;
5192 Register map_result_;
5193 Register scratch1_;
5194 Register scratch2_;
5195};
5196
5197
5198void CodeGenerator::GenerateIsStringWrapperSafeForDefaultValueOf(
5199 ZoneList<Expression*>* args) {
5200 ASSERT(args->length() == 1);
5201 Load(args->at(0));
5202 Register obj = frame_->PopToRegister(); // Pop the string wrapper.
5203 if (FLAG_debug_code) {
5204 __ AbortIfSmi(obj);
5205 }
5206
5207 // Check whether this map has already been checked to be safe for default
5208 // valueOf.
5209 Register map_result = VirtualFrame::scratch0();
5210 __ ldr(map_result, FieldMemOperand(obj, HeapObject::kMapOffset));
5211 __ ldrb(ip, FieldMemOperand(map_result, Map::kBitField2Offset));
5212 __ tst(ip, Operand(1 << Map::kStringWrapperSafeForDefaultValueOf));
5213 true_target()->Branch(ne);
5214
5215 // We need an additional two scratch registers for the deferred code.
5216 Register scratch1 = VirtualFrame::scratch1();
5217 // Use r6 without notifying the virtual frame.
5218 Register scratch2 = r6;
5219
5220 DeferredIsStringWrapperSafeForDefaultValueOf* deferred =
5221 new DeferredIsStringWrapperSafeForDefaultValueOf(
5222 obj, map_result, scratch1, scratch2);
5223 deferred->Branch(eq);
5224 deferred->BindExit();
5225 __ tst(map_result, Operand(map_result));
5226 cc_reg_ = ne;
5227}
5228
5229
ager@chromium.org6141cbe2009-11-20 12:14:52 +00005230void CodeGenerator::GenerateIsFunction(ZoneList<Expression*>* args) {
5231 // This generates a fast version of:
5232 // (%_ClassOf(arg) === 'Function')
ager@chromium.org6141cbe2009-11-20 12:14:52 +00005233 ASSERT(args->length() == 1);
ricow@chromium.org30ce4112010-05-31 10:38:25 +00005234 Load(args->at(0));
5235 Register possible_function = frame_->PopToRegister();
5236 __ tst(possible_function, Operand(kSmiTagMask));
ager@chromium.org6141cbe2009-11-20 12:14:52 +00005237 false_target()->Branch(eq);
ricow@chromium.org30ce4112010-05-31 10:38:25 +00005238 Register map_reg = VirtualFrame::scratch0();
5239 Register scratch = VirtualFrame::scratch1();
5240 __ CompareObjectType(possible_function, map_reg, scratch, JS_FUNCTION_TYPE);
ager@chromium.org6141cbe2009-11-20 12:14:52 +00005241 cc_reg_ = eq;
5242}
5243
5244
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +00005245void CodeGenerator::GenerateIsUndetectableObject(ZoneList<Expression*>* args) {
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +00005246 ASSERT(args->length() == 1);
ricow@chromium.org30ce4112010-05-31 10:38:25 +00005247 Load(args->at(0));
5248 Register possible_undetectable = frame_->PopToRegister();
5249 __ tst(possible_undetectable, Operand(kSmiTagMask));
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +00005250 false_target()->Branch(eq);
ricow@chromium.org30ce4112010-05-31 10:38:25 +00005251 Register scratch = VirtualFrame::scratch0();
5252 __ ldr(scratch,
5253 FieldMemOperand(possible_undetectable, HeapObject::kMapOffset));
5254 __ ldrb(scratch, FieldMemOperand(scratch, Map::kBitFieldOffset));
5255 __ tst(scratch, Operand(1 << Map::kIsUndetectable));
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +00005256 cc_reg_ = ne;
5257}
5258
5259
kasperl@chromium.org2abc4502009-07-02 07:00:29 +00005260void CodeGenerator::GenerateIsConstructCall(ZoneList<Expression*>* args) {
kasperl@chromium.org2abc4502009-07-02 07:00:29 +00005261 ASSERT(args->length() == 0);
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00005262
kmillikin@chromium.org9155e252010-05-26 13:27:57 +00005263 Register scratch0 = VirtualFrame::scratch0();
5264 Register scratch1 = VirtualFrame::scratch1();
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00005265 // Get the frame pointer for the calling frame.
kmillikin@chromium.org9155e252010-05-26 13:27:57 +00005266 __ ldr(scratch0, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00005267
5268 // Skip the arguments adaptor frame if it exists.
kmillikin@chromium.org9155e252010-05-26 13:27:57 +00005269 __ ldr(scratch1,
5270 MemOperand(scratch0, StandardFrameConstants::kContextOffset));
5271 __ cmp(scratch1, Operand(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
5272 __ ldr(scratch0,
5273 MemOperand(scratch0, StandardFrameConstants::kCallerFPOffset), eq);
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00005274
5275 // Check the marker in the calling frame.
kmillikin@chromium.org9155e252010-05-26 13:27:57 +00005276 __ ldr(scratch1,
5277 MemOperand(scratch0, StandardFrameConstants::kMarkerOffset));
5278 __ cmp(scratch1, Operand(Smi::FromInt(StackFrame::CONSTRUCT)));
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00005279 cc_reg_ = eq;
kasperl@chromium.org2abc4502009-07-02 07:00:29 +00005280}
5281
5282
ager@chromium.org7c537e22008-10-16 08:43:32 +00005283void CodeGenerator::GenerateArgumentsLength(ZoneList<Expression*>* args) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005284 ASSERT(args->length() == 0);
5285
kmillikin@chromium.org9155e252010-05-26 13:27:57 +00005286 Register tos = frame_->GetTOSRegister();
5287 Register scratch0 = VirtualFrame::scratch0();
5288 Register scratch1 = VirtualFrame::scratch1();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005289
lrn@chromium.org25156de2010-04-06 13:10:27 +00005290 // Check if the calling frame is an arguments adaptor frame.
kmillikin@chromium.org9155e252010-05-26 13:27:57 +00005291 __ ldr(scratch0,
5292 MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
5293 __ ldr(scratch1,
5294 MemOperand(scratch0, StandardFrameConstants::kContextOffset));
5295 __ cmp(scratch1, Operand(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
5296
5297 // Get the number of formal parameters.
5298 __ mov(tos, Operand(Smi::FromInt(scope()->num_parameters())), LeaveCC, ne);
lrn@chromium.org25156de2010-04-06 13:10:27 +00005299
5300 // Arguments adaptor case: Read the arguments length from the
5301 // adaptor frame.
kmillikin@chromium.org9155e252010-05-26 13:27:57 +00005302 __ ldr(tos,
5303 MemOperand(scratch0, ArgumentsAdaptorFrameConstants::kLengthOffset),
5304 eq);
lrn@chromium.org25156de2010-04-06 13:10:27 +00005305
kmillikin@chromium.org9155e252010-05-26 13:27:57 +00005306 frame_->EmitPush(tos);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005307}
5308
5309
vegorov@chromium.orgf8372902010-03-15 10:26:20 +00005310void CodeGenerator::GenerateArguments(ZoneList<Expression*>* args) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005311 ASSERT(args->length() == 1);
5312
kasperl@chromium.orgb9123622008-09-17 14:05:56 +00005313 // Satisfy contract with ArgumentsAccessStub:
5314 // Load the key into r1 and the formal parameters count into r0.
ricow@chromium.org30ce4112010-05-31 10:38:25 +00005315 Load(args->at(0));
vegorov@chromium.org26c16f82010-08-11 13:41:03 +00005316 frame_->PopToR1();
5317 frame_->SpillAll();
ager@chromium.org5c838252010-02-19 08:53:10 +00005318 __ mov(r0, Operand(Smi::FromInt(scope()->num_parameters())));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005319
5320 // Call the shared stub to get to arguments[key].
kasperl@chromium.org41044eb2008-10-06 08:24:46 +00005321 ArgumentsAccessStub stub(ArgumentsAccessStub::READ_ELEMENT);
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00005322 frame_->CallStub(&stub, 0);
5323 frame_->EmitPush(r0);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005324}
5325
5326
ager@chromium.org357bf652010-04-12 11:30:10 +00005327void CodeGenerator::GenerateRandomHeapNumber(
5328 ZoneList<Expression*>* args) {
5329 VirtualFrame::SpilledScope spilled_scope(frame_);
ager@chromium.orgeadaf222009-06-16 09:43:10 +00005330 ASSERT(args->length() == 0);
ager@chromium.org357bf652010-04-12 11:30:10 +00005331
5332 Label slow_allocate_heapnumber;
5333 Label heapnumber_allocated;
5334
ricow@chromium.org5ad5ace2010-06-23 09:06:43 +00005335 __ LoadRoot(r6, Heap::kHeapNumberMapRootIndex);
5336 __ AllocateHeapNumber(r4, r1, r2, r6, &slow_allocate_heapnumber);
ager@chromium.org357bf652010-04-12 11:30:10 +00005337 __ jmp(&heapnumber_allocated);
5338
5339 __ bind(&slow_allocate_heapnumber);
ager@chromium.org6a2b0aa2010-07-13 20:58:03 +00005340 // Allocate a heap number.
5341 __ CallRuntime(Runtime::kNumberAlloc, 0);
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00005342 __ mov(r4, Operand(r0));
ager@chromium.org357bf652010-04-12 11:30:10 +00005343
5344 __ bind(&heapnumber_allocated);
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00005345
5346 // Convert 32 random bits in r0 to 0.(32 random bits) in a double
5347 // by computing:
5348 // ( 1.(20 0s)(32 random bits) x 2^20 ) - (1.0 x 2^20)).
5349 if (CpuFeatures::IsSupported(VFP3)) {
5350 __ PrepareCallCFunction(0, r1);
5351 __ CallCFunction(ExternalReference::random_uint32_function(), 0);
5352
5353 CpuFeatures::Scope scope(VFP3);
5354 // 0x41300000 is the top half of 1.0 x 2^20 as a double.
5355 // Create this constant using mov/orr to avoid PC relative load.
5356 __ mov(r1, Operand(0x41000000));
5357 __ orr(r1, r1, Operand(0x300000));
5358 // Move 0x41300000xxxxxxxx (x = random bits) to VFP.
5359 __ vmov(d7, r0, r1);
5360 // Move 0x4130000000000000 to VFP.
ager@chromium.org5b2fbee2010-09-08 06:38:15 +00005361 __ mov(r0, Operand(0, RelocInfo::NONE));
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00005362 __ vmov(d8, r0, r1);
5363 // Subtract and store the result in the heap number.
5364 __ vsub(d7, d7, d8);
5365 __ sub(r0, r4, Operand(kHeapObjectTag));
5366 __ vstr(d7, r0, HeapNumber::kValueOffset);
5367 frame_->EmitPush(r4);
5368 } else {
5369 __ mov(r0, Operand(r4));
5370 __ PrepareCallCFunction(1, r1);
5371 __ CallCFunction(
5372 ExternalReference::fill_heap_number_with_random_function(), 1);
5373 frame_->EmitPush(r0);
5374 }
ager@chromium.orgeadaf222009-06-16 09:43:10 +00005375}
5376
5377
sgjesse@chromium.orgac6aa172009-12-04 12:29:05 +00005378void CodeGenerator::GenerateStringAdd(ZoneList<Expression*>* args) {
5379 ASSERT_EQ(2, args->length());
5380
5381 Load(args->at(0));
5382 Load(args->at(1));
5383
ager@chromium.org5c838252010-02-19 08:53:10 +00005384 StringAddStub stub(NO_STRING_ADD_FLAGS);
ricow@chromium.org30ce4112010-05-31 10:38:25 +00005385 frame_->SpillAll();
ager@chromium.org5c838252010-02-19 08:53:10 +00005386 frame_->CallStub(&stub, 2);
sgjesse@chromium.orgac6aa172009-12-04 12:29:05 +00005387 frame_->EmitPush(r0);
5388}
5389
5390
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00005391void CodeGenerator::GenerateSubString(ZoneList<Expression*>* args) {
5392 ASSERT_EQ(3, args->length());
5393
5394 Load(args->at(0));
5395 Load(args->at(1));
5396 Load(args->at(2));
5397
ager@chromium.org5c838252010-02-19 08:53:10 +00005398 SubStringStub stub;
ricow@chromium.org30ce4112010-05-31 10:38:25 +00005399 frame_->SpillAll();
ager@chromium.org5c838252010-02-19 08:53:10 +00005400 frame_->CallStub(&stub, 3);
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00005401 frame_->EmitPush(r0);
5402}
5403
5404
5405void CodeGenerator::GenerateStringCompare(ZoneList<Expression*>* args) {
5406 ASSERT_EQ(2, args->length());
5407
5408 Load(args->at(0));
5409 Load(args->at(1));
5410
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +00005411 StringCompareStub stub;
ricow@chromium.org30ce4112010-05-31 10:38:25 +00005412 frame_->SpillAll();
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +00005413 frame_->CallStub(&stub, 2);
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00005414 frame_->EmitPush(r0);
5415}
5416
5417
5418void CodeGenerator::GenerateRegExpExec(ZoneList<Expression*>* args) {
5419 ASSERT_EQ(4, args->length());
5420
5421 Load(args->at(0));
5422 Load(args->at(1));
5423 Load(args->at(2));
5424 Load(args->at(3));
ricow@chromium.orgc9c80822010-04-21 08:22:37 +00005425 RegExpExecStub stub;
ricow@chromium.org30ce4112010-05-31 10:38:25 +00005426 frame_->SpillAll();
ricow@chromium.orgc9c80822010-04-21 08:22:37 +00005427 frame_->CallStub(&stub, 4);
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00005428 frame_->EmitPush(r0);
5429}
5430
5431
whesse@chromium.orgb6e43bb2010-04-14 09:36:28 +00005432void CodeGenerator::GenerateRegExpConstructResult(ZoneList<Expression*>* args) {
whesse@chromium.orgb6e43bb2010-04-14 09:36:28 +00005433 ASSERT_EQ(3, args->length());
kasperl@chromium.orga5551262010-12-07 12:49:48 +00005434
whesse@chromium.orgb6e43bb2010-04-14 09:36:28 +00005435 Load(args->at(0)); // Size of array, smi.
5436 Load(args->at(1)); // "index" property value.
5437 Load(args->at(2)); // "input" property value.
kasperl@chromium.orga5551262010-12-07 12:49:48 +00005438 RegExpConstructResultStub stub;
5439 frame_->SpillAll();
5440 frame_->CallStub(&stub, 3);
whesse@chromium.orgb6e43bb2010-04-14 09:36:28 +00005441 frame_->EmitPush(r0);
5442}
5443
5444
ricow@chromium.orgc9c80822010-04-21 08:22:37 +00005445class DeferredSearchCache: public DeferredCode {
5446 public:
5447 DeferredSearchCache(Register dst, Register cache, Register key)
5448 : dst_(dst), cache_(cache), key_(key) {
5449 set_comment("[ DeferredSearchCache");
5450 }
5451
5452 virtual void Generate();
5453
5454 private:
5455 Register dst_, cache_, key_;
5456};
5457
5458
5459void DeferredSearchCache::Generate() {
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00005460 __ Push(cache_, key_);
ricow@chromium.orgc9c80822010-04-21 08:22:37 +00005461 __ CallRuntime(Runtime::kGetFromCache, 2);
vegorov@chromium.org26c16f82010-08-11 13:41:03 +00005462 __ Move(dst_, r0);
ricow@chromium.orgc9c80822010-04-21 08:22:37 +00005463}
5464
5465
5466void CodeGenerator::GenerateGetFromCache(ZoneList<Expression*>* args) {
5467 ASSERT_EQ(2, args->length());
5468
5469 ASSERT_NE(NULL, args->at(0)->AsLiteral());
5470 int cache_id = Smi::cast(*(args->at(0)->AsLiteral()->handle()))->value();
5471
5472 Handle<FixedArray> jsfunction_result_caches(
5473 Top::global_context()->jsfunction_result_caches());
5474 if (jsfunction_result_caches->length() <= cache_id) {
5475 __ Abort("Attempt to use undefined cache.");
ricow@chromium.org30ce4112010-05-31 10:38:25 +00005476 frame_->EmitPushRoot(Heap::kUndefinedValueRootIndex);
ricow@chromium.orgc9c80822010-04-21 08:22:37 +00005477 return;
5478 }
ricow@chromium.orgc9c80822010-04-21 08:22:37 +00005479
5480 Load(args->at(1));
ricow@chromium.org30ce4112010-05-31 10:38:25 +00005481
vegorov@chromium.org26c16f82010-08-11 13:41:03 +00005482 frame_->PopToR1();
5483 frame_->SpillAll();
5484 Register key = r1; // Just poped to r1
5485 Register result = r0; // Free, as frame has just been spilled.
5486 Register scratch1 = VirtualFrame::scratch0();
5487 Register scratch2 = VirtualFrame::scratch1();
ricow@chromium.org30ce4112010-05-31 10:38:25 +00005488
vegorov@chromium.org26c16f82010-08-11 13:41:03 +00005489 __ ldr(scratch1, ContextOperand(cp, Context::GLOBAL_INDEX));
5490 __ ldr(scratch1,
5491 FieldMemOperand(scratch1, GlobalObject::kGlobalContextOffset));
5492 __ ldr(scratch1,
5493 ContextOperand(scratch1, Context::JSFUNCTION_RESULT_CACHES_INDEX));
5494 __ ldr(scratch1,
5495 FieldMemOperand(scratch1, FixedArray::OffsetOfElementAt(cache_id)));
ricow@chromium.orgc9c80822010-04-21 08:22:37 +00005496
vegorov@chromium.org26c16f82010-08-11 13:41:03 +00005497 DeferredSearchCache* deferred =
5498 new DeferredSearchCache(result, scratch1, key);
ricow@chromium.orgc9c80822010-04-21 08:22:37 +00005499
5500 const int kFingerOffset =
5501 FixedArray::OffsetOfElementAt(JSFunctionResultCache::kFingerIndex);
whesse@chromium.orgba5a61b2010-07-26 11:44:40 +00005502 STATIC_ASSERT(kSmiTag == 0 && kSmiTagSize == 1);
vegorov@chromium.org26c16f82010-08-11 13:41:03 +00005503 __ ldr(result, FieldMemOperand(scratch1, kFingerOffset));
5504 // result now holds finger offset as a smi.
5505 __ add(scratch2, scratch1, Operand(FixedArray::kHeaderSize - kHeapObjectTag));
5506 // scratch2 now points to the start of fixed array elements.
5507 __ ldr(result,
5508 MemOperand(
5509 scratch2, result, LSL, kPointerSizeLog2 - kSmiTagSize, PreIndex));
5510 // Note side effect of PreIndex: scratch2 now points to the key of the pair.
5511 __ cmp(key, result);
ricow@chromium.orgc9c80822010-04-21 08:22:37 +00005512 deferred->Branch(ne);
5513
vegorov@chromium.org26c16f82010-08-11 13:41:03 +00005514 __ ldr(result, MemOperand(scratch2, kPointerSize));
ricow@chromium.orgc9c80822010-04-21 08:22:37 +00005515
5516 deferred->BindExit();
vegorov@chromium.org26c16f82010-08-11 13:41:03 +00005517 frame_->EmitPush(result);
ricow@chromium.orgc9c80822010-04-21 08:22:37 +00005518}
5519
5520
ager@chromium.org5c838252010-02-19 08:53:10 +00005521void CodeGenerator::GenerateNumberToString(ZoneList<Expression*>* args) {
5522 ASSERT_EQ(args->length(), 1);
5523
5524 // Load the argument on the stack and jump to the runtime.
5525 Load(args->at(0));
5526
fschneider@chromium.org086aac62010-03-17 13:18:24 +00005527 NumberToStringStub stub;
ricow@chromium.org30ce4112010-05-31 10:38:25 +00005528 frame_->SpillAll();
fschneider@chromium.org086aac62010-03-17 13:18:24 +00005529 frame_->CallStub(&stub, 1);
ager@chromium.org5c838252010-02-19 08:53:10 +00005530 frame_->EmitPush(r0);
5531}
5532
5533
ager@chromium.orgac091b72010-05-05 07:34:42 +00005534class DeferredSwapElements: public DeferredCode {
5535 public:
5536 DeferredSwapElements(Register object, Register index1, Register index2)
5537 : object_(object), index1_(index1), index2_(index2) {
5538 set_comment("[ DeferredSwapElements");
5539 }
5540
5541 virtual void Generate();
5542
5543 private:
5544 Register object_, index1_, index2_;
5545};
5546
5547
5548void DeferredSwapElements::Generate() {
5549 __ push(object_);
5550 __ push(index1_);
5551 __ push(index2_);
5552 __ CallRuntime(Runtime::kSwapElements, 3);
5553}
5554
5555
kmillikin@chromium.org4111b802010-05-03 10:34:42 +00005556void CodeGenerator::GenerateSwapElements(ZoneList<Expression*>* args) {
5557 Comment cmnt(masm_, "[ GenerateSwapElements");
5558
5559 ASSERT_EQ(3, args->length());
5560
5561 Load(args->at(0));
5562 Load(args->at(1));
5563 Load(args->at(2));
5564
ricow@chromium.org30ce4112010-05-31 10:38:25 +00005565 VirtualFrame::SpilledScope spilled_scope(frame_);
5566
ager@chromium.orgac091b72010-05-05 07:34:42 +00005567 Register index2 = r2;
5568 Register index1 = r1;
5569 Register object = r0;
5570 Register tmp1 = r3;
5571 Register tmp2 = r4;
5572
5573 frame_->EmitPop(index2);
5574 frame_->EmitPop(index1);
5575 frame_->EmitPop(object);
5576
5577 DeferredSwapElements* deferred =
5578 new DeferredSwapElements(object, index1, index2);
5579
5580 // Fetch the map and check if array is in fast case.
5581 // Check that object doesn't require security checks and
5582 // has no indexed interceptor.
5583 __ CompareObjectType(object, tmp1, tmp2, FIRST_JS_OBJECT_TYPE);
5584 deferred->Branch(lt);
5585 __ ldrb(tmp2, FieldMemOperand(tmp1, Map::kBitFieldOffset));
5586 __ tst(tmp2, Operand(KeyedLoadIC::kSlowCaseBitFieldMask));
ager@chromium.org378b34e2011-01-28 08:04:38 +00005587 deferred->Branch(ne);
ager@chromium.orgac091b72010-05-05 07:34:42 +00005588
ricow@chromium.org0b9f8502010-08-18 07:45:01 +00005589 // Check the object's elements are in fast case and writable.
ager@chromium.orgac091b72010-05-05 07:34:42 +00005590 __ ldr(tmp1, FieldMemOperand(object, JSObject::kElementsOffset));
5591 __ ldr(tmp2, FieldMemOperand(tmp1, HeapObject::kMapOffset));
5592 __ LoadRoot(ip, Heap::kFixedArrayMapRootIndex);
5593 __ cmp(tmp2, ip);
5594 deferred->Branch(ne);
5595
5596 // Smi-tagging is equivalent to multiplying by 2.
5597 STATIC_ASSERT(kSmiTag == 0);
5598 STATIC_ASSERT(kSmiTagSize == 1);
5599
5600 // Check that both indices are smis.
5601 __ mov(tmp2, index1);
5602 __ orr(tmp2, tmp2, index2);
5603 __ tst(tmp2, Operand(kSmiTagMask));
ager@chromium.org378b34e2011-01-28 08:04:38 +00005604 deferred->Branch(ne);
ager@chromium.orgac091b72010-05-05 07:34:42 +00005605
ager@chromium.org5f0c45f2010-12-17 08:51:21 +00005606 // Check that both indices are valid.
5607 __ ldr(tmp2, FieldMemOperand(object, JSArray::kLengthOffset));
5608 __ cmp(tmp2, index1);
5609 __ cmp(tmp2, index2, hi);
5610 deferred->Branch(ls);
5611
ager@chromium.orgac091b72010-05-05 07:34:42 +00005612 // Bring the offsets into the fixed array in tmp1 into index1 and
5613 // index2.
5614 __ mov(tmp2, Operand(FixedArray::kHeaderSize - kHeapObjectTag));
5615 __ add(index1, tmp2, Operand(index1, LSL, kPointerSizeLog2 - kSmiTagSize));
5616 __ add(index2, tmp2, Operand(index2, LSL, kPointerSizeLog2 - kSmiTagSize));
5617
5618 // Swap elements.
5619 Register tmp3 = object;
5620 object = no_reg;
5621 __ ldr(tmp3, MemOperand(tmp1, index1));
5622 __ ldr(tmp2, MemOperand(tmp1, index2));
5623 __ str(tmp3, MemOperand(tmp1, index2));
5624 __ str(tmp2, MemOperand(tmp1, index1));
5625
5626 Label done;
5627 __ InNewSpace(tmp1, tmp2, eq, &done);
5628 // Possible optimization: do a check that both values are Smis
5629 // (or them and test against Smi mask.)
5630
5631 __ mov(tmp2, tmp1);
lrn@chromium.org5d00b602011-01-05 09:51:43 +00005632 __ add(index1, index1, tmp1);
5633 __ add(index2, index2, tmp1);
5634 __ RecordWriteHelper(tmp1, index1, tmp3);
5635 __ RecordWriteHelper(tmp2, index2, tmp3);
ager@chromium.orgac091b72010-05-05 07:34:42 +00005636 __ bind(&done);
5637
5638 deferred->BindExit();
5639 __ LoadRoot(tmp1, Heap::kUndefinedValueRootIndex);
5640 frame_->EmitPush(tmp1);
kmillikin@chromium.org4111b802010-05-03 10:34:42 +00005641}
5642
5643
ager@chromium.org357bf652010-04-12 11:30:10 +00005644void CodeGenerator::GenerateCallFunction(ZoneList<Expression*>* args) {
5645 Comment cmnt(masm_, "[ GenerateCallFunction");
5646
5647 ASSERT(args->length() >= 2);
5648
5649 int n_args = args->length() - 2; // for receiver and function.
5650 Load(args->at(0)); // receiver
5651 for (int i = 0; i < n_args; i++) {
5652 Load(args->at(i + 1));
5653 }
5654 Load(args->at(n_args + 1)); // function
5655 frame_->CallJSFunction(n_args);
5656 frame_->EmitPush(r0);
5657}
5658
5659
ager@chromium.orgce5e87b2010-03-10 10:24:18 +00005660void CodeGenerator::GenerateMathSin(ZoneList<Expression*>* args) {
5661 ASSERT_EQ(args->length(), 1);
ager@chromium.orgce5e87b2010-03-10 10:24:18 +00005662 Load(args->at(0));
ager@chromium.org2cc82ae2010-06-14 07:35:38 +00005663 if (CpuFeatures::IsSupported(VFP3)) {
5664 TranscendentalCacheStub stub(TranscendentalCache::SIN);
5665 frame_->SpillAllButCopyTOSToR0();
5666 frame_->CallStub(&stub, 1);
5667 } else {
5668 frame_->CallRuntime(Runtime::kMath_sin, 1);
5669 }
ager@chromium.orgce5e87b2010-03-10 10:24:18 +00005670 frame_->EmitPush(r0);
5671}
5672
5673
5674void CodeGenerator::GenerateMathCos(ZoneList<Expression*>* args) {
5675 ASSERT_EQ(args->length(), 1);
ager@chromium.orgce5e87b2010-03-10 10:24:18 +00005676 Load(args->at(0));
ager@chromium.org2cc82ae2010-06-14 07:35:38 +00005677 if (CpuFeatures::IsSupported(VFP3)) {
5678 TranscendentalCacheStub stub(TranscendentalCache::COS);
5679 frame_->SpillAllButCopyTOSToR0();
5680 frame_->CallStub(&stub, 1);
5681 } else {
5682 frame_->CallRuntime(Runtime::kMath_cos, 1);
5683 }
ager@chromium.orgce5e87b2010-03-10 10:24:18 +00005684 frame_->EmitPush(r0);
5685}
5686
5687
kasperl@chromium.orga5551262010-12-07 12:49:48 +00005688void CodeGenerator::GenerateMathLog(ZoneList<Expression*>* args) {
5689 ASSERT_EQ(args->length(), 1);
5690 Load(args->at(0));
5691 if (CpuFeatures::IsSupported(VFP3)) {
5692 TranscendentalCacheStub stub(TranscendentalCache::LOG);
5693 frame_->SpillAllButCopyTOSToR0();
5694 frame_->CallStub(&stub, 1);
5695 } else {
5696 frame_->CallRuntime(Runtime::kMath_log, 1);
5697 }
5698 frame_->EmitPush(r0);
5699}
5700
5701
ager@chromium.org7c537e22008-10-16 08:43:32 +00005702void CodeGenerator::GenerateObjectEquals(ZoneList<Expression*>* args) {
ager@chromium.org9258b6b2008-09-11 09:11:10 +00005703 ASSERT(args->length() == 2);
5704
5705 // Load the two objects into registers and perform the comparison.
kmillikin@chromium.org9155e252010-05-26 13:27:57 +00005706 Load(args->at(0));
5707 Load(args->at(1));
5708 Register lhs = frame_->PopToRegister();
5709 Register rhs = frame_->PopToRegister(lhs);
5710 __ cmp(lhs, rhs);
ager@chromium.org9258b6b2008-09-11 09:11:10 +00005711 cc_reg_ = eq;
5712}
5713
5714
lrn@chromium.orgc4e51ac2010-08-09 09:47:21 +00005715void CodeGenerator::GenerateIsRegExpEquivalent(ZoneList<Expression*>* args) {
5716 ASSERT(args->length() == 2);
5717
5718 // Load the two objects into registers and perform the comparison.
5719 Load(args->at(0));
5720 Load(args->at(1));
5721 Register right = frame_->PopToRegister();
5722 Register left = frame_->PopToRegister(right);
5723 Register tmp = frame_->scratch0();
5724 Register tmp2 = frame_->scratch1();
5725
5726 // Jumps to done must have the eq flag set if the test is successful
5727 // and clear if the test has failed.
5728 Label done;
5729
5730 // Fail if either is a non-HeapObject.
5731 __ cmp(left, Operand(right));
5732 __ b(eq, &done);
5733 __ and_(tmp, left, Operand(right));
5734 __ eor(tmp, tmp, Operand(kSmiTagMask));
5735 __ tst(tmp, Operand(kSmiTagMask));
5736 __ b(ne, &done);
5737 __ ldr(tmp, FieldMemOperand(left, HeapObject::kMapOffset));
5738 __ ldrb(tmp2, FieldMemOperand(tmp, Map::kInstanceTypeOffset));
5739 __ cmp(tmp2, Operand(JS_REGEXP_TYPE));
5740 __ b(ne, &done);
5741 __ ldr(tmp2, FieldMemOperand(right, HeapObject::kMapOffset));
5742 __ cmp(tmp, Operand(tmp2));
5743 __ b(ne, &done);
5744 __ ldr(tmp, FieldMemOperand(left, JSRegExp::kDataOffset));
5745 __ ldr(tmp2, FieldMemOperand(right, JSRegExp::kDataOffset));
5746 __ cmp(tmp, tmp2);
5747 __ bind(&done);
5748 cc_reg_ = eq;
5749}
5750
5751
ricow@chromium.orgd236f4d2010-09-01 06:52:08 +00005752void CodeGenerator::GenerateHasCachedArrayIndex(ZoneList<Expression*>* args) {
5753 ASSERT(args->length() == 1);
5754 Load(args->at(0));
5755 Register value = frame_->PopToRegister();
5756 Register tmp = frame_->scratch0();
5757 __ ldr(tmp, FieldMemOperand(value, String::kHashFieldOffset));
5758 __ tst(tmp, Operand(String::kContainsCachedArrayIndexMask));
5759 cc_reg_ = eq;
5760}
5761
5762
5763void CodeGenerator::GenerateGetCachedArrayIndex(ZoneList<Expression*>* args) {
5764 ASSERT(args->length() == 1);
5765 Load(args->at(0));
5766 Register value = frame_->PopToRegister();
5767
5768 __ ldr(value, FieldMemOperand(value, String::kHashFieldOffset));
5769 __ IndexFromHash(value, value);
5770 frame_->EmitPush(value);
5771}
5772
lrn@chromium.orgc4e51ac2010-08-09 09:47:21 +00005773
vegorov@chromium.org21b5e952010-11-23 10:24:40 +00005774void CodeGenerator::GenerateFastAsciiArrayJoin(ZoneList<Expression*>* args) {
5775 ASSERT(args->length() == 2);
5776 Load(args->at(0));
5777 Register value = frame_->PopToRegister();
5778 __ LoadRoot(value, Heap::kUndefinedValueRootIndex);
5779 frame_->EmitPush(value);
5780}
5781
5782
ager@chromium.org7c537e22008-10-16 08:43:32 +00005783void CodeGenerator::VisitCallRuntime(CallRuntime* node) {
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00005784#ifdef DEBUG
5785 int original_height = frame_->height();
5786#endif
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00005787 if (CheckForInlineRuntimeCall(node)) {
5788 ASSERT((has_cc() && frame_->height() == original_height) ||
5789 (!has_cc() && frame_->height() == original_height + 1));
5790 return;
5791 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005792
5793 ZoneList<Expression*>* args = node->arguments();
5794 Comment cmnt(masm_, "[ CallRuntime");
5795 Runtime::Function* function = node->function();
5796
ager@chromium.org41826e72009-03-30 13:30:57 +00005797 if (function == NULL) {
mads.s.ager31e71382008-08-13 09:32:07 +00005798 // Prepare stack for calling JS runtime function.
mads.s.ager31e71382008-08-13 09:32:07 +00005799 // Push the builtins object found in the current global object.
ricow@chromium.org30ce4112010-05-31 10:38:25 +00005800 Register scratch = VirtualFrame::scratch0();
erik.corry@gmail.com4a6c3272010-11-18 12:04:40 +00005801 __ ldr(scratch, GlobalObjectOperand());
ricow@chromium.org30ce4112010-05-31 10:38:25 +00005802 Register builtins = frame_->GetTOSRegister();
5803 __ ldr(builtins, FieldMemOperand(scratch, GlobalObject::kBuiltinsOffset));
5804 frame_->EmitPush(builtins);
ager@chromium.org41826e72009-03-30 13:30:57 +00005805 }
mads.s.ager31e71382008-08-13 09:32:07 +00005806
ager@chromium.org41826e72009-03-30 13:30:57 +00005807 // Push the arguments ("left-to-right").
5808 int arg_count = args->length();
5809 for (int i = 0; i < arg_count; i++) {
ricow@chromium.org30ce4112010-05-31 10:38:25 +00005810 Load(args->at(i));
ager@chromium.org41826e72009-03-30 13:30:57 +00005811 }
mads.s.ager31e71382008-08-13 09:32:07 +00005812
ricow@chromium.org30ce4112010-05-31 10:38:25 +00005813 VirtualFrame::SpilledScope spilled_scope(frame_);
5814
ager@chromium.org41826e72009-03-30 13:30:57 +00005815 if (function == NULL) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005816 // Call the JS runtime function.
ager@chromium.org5c838252010-02-19 08:53:10 +00005817 __ mov(r2, Operand(node->name()));
kasperl@chromium.org71affb52009-05-26 05:44:31 +00005818 InLoopFlag in_loop = loop_nesting() > 0 ? IN_LOOP : NOT_IN_LOOP;
erik.corry@gmail.com4a6c3272010-11-18 12:04:40 +00005819 Handle<Code> stub = StubCache::ComputeCallInitialize(arg_count, in_loop);
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00005820 frame_->CallCodeObject(stub, RelocInfo::CODE_TARGET, arg_count + 1);
ager@chromium.org3bf7b912008-11-17 09:09:45 +00005821 __ ldr(cp, frame_->Context());
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00005822 frame_->EmitPush(r0);
ager@chromium.org41826e72009-03-30 13:30:57 +00005823 } else {
5824 // Call the C runtime function.
5825 frame_->CallRuntime(function, arg_count);
5826 frame_->EmitPush(r0);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005827 }
ager@chromium.orgac091b72010-05-05 07:34:42 +00005828 ASSERT_EQ(original_height + 1, frame_->height());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005829}
5830
5831
ager@chromium.org7c537e22008-10-16 08:43:32 +00005832void CodeGenerator::VisitUnaryOperation(UnaryOperation* node) {
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00005833#ifdef DEBUG
5834 int original_height = frame_->height();
5835#endif
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005836 Comment cmnt(masm_, "[ UnaryOperation");
5837
5838 Token::Value op = node->op();
5839
5840 if (op == Token::NOT) {
ricow@chromium.org30ce4112010-05-31 10:38:25 +00005841 LoadCondition(node->expression(), false_target(), true_target(), true);
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00005842 // LoadCondition may (and usually does) leave a test and branch to
5843 // be emitted by the caller. In that case, negate the condition.
5844 if (has_cc()) cc_reg_ = NegateCondition(cc_reg_);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005845
5846 } else if (op == Token::DELETE) {
5847 Property* property = node->expression()->AsProperty();
mads.s.ager31e71382008-08-13 09:32:07 +00005848 Variable* variable = node->expression()->AsVariableProxy()->AsVariable();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005849 if (property != NULL) {
ricow@chromium.org30ce4112010-05-31 10:38:25 +00005850 Load(property->obj());
5851 Load(property->key());
kmillikin@chromium.org13bd2942009-12-16 15:36:05 +00005852 frame_->InvokeBuiltin(Builtins::DELETE, CALL_JS, 2);
ricow@chromium.org30ce4112010-05-31 10:38:25 +00005853 frame_->EmitPush(r0);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005854
mads.s.ager31e71382008-08-13 09:32:07 +00005855 } else if (variable != NULL) {
whesse@chromium.org4a1fe7d2010-09-27 12:32:04 +00005856 Slot* slot = variable->AsSlot();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005857 if (variable->is_global()) {
5858 LoadGlobal();
ricow@chromium.org30ce4112010-05-31 10:38:25 +00005859 frame_->EmitPush(Operand(variable->name()));
kmillikin@chromium.org13bd2942009-12-16 15:36:05 +00005860 frame_->InvokeBuiltin(Builtins::DELETE, CALL_JS, 2);
ricow@chromium.org30ce4112010-05-31 10:38:25 +00005861 frame_->EmitPush(r0);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005862
5863 } else if (slot != NULL && slot->type() == Slot::LOOKUP) {
ager@chromium.org0ee099b2011-01-25 14:06:47 +00005864 // Delete from the context holding the named variable.
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00005865 frame_->EmitPush(cp);
ricow@chromium.org30ce4112010-05-31 10:38:25 +00005866 frame_->EmitPush(Operand(variable->name()));
ager@chromium.org0ee099b2011-01-25 14:06:47 +00005867 frame_->CallRuntime(Runtime::kDeleteContextSlot, 2);
ricow@chromium.org30ce4112010-05-31 10:38:25 +00005868 frame_->EmitPush(r0);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005869
mads.s.ager31e71382008-08-13 09:32:07 +00005870 } else {
5871 // Default: Result of deleting non-global, not dynamically
5872 // introduced variables is false.
ricow@chromium.org30ce4112010-05-31 10:38:25 +00005873 frame_->EmitPushRoot(Heap::kFalseValueRootIndex);
mads.s.ager31e71382008-08-13 09:32:07 +00005874 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005875
5876 } else {
5877 // Default: Result of deleting expressions is true.
ricow@chromium.org30ce4112010-05-31 10:38:25 +00005878 Load(node->expression()); // may have side-effects
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00005879 frame_->Drop();
ricow@chromium.org30ce4112010-05-31 10:38:25 +00005880 frame_->EmitPushRoot(Heap::kTrueValueRootIndex);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005881 }
5882
5883 } else if (op == Token::TYPEOF) {
5884 // Special case for loading the typeof expression; see comment on
5885 // LoadTypeofExpression().
5886 LoadTypeofExpression(node->expression());
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00005887 frame_->CallRuntime(Runtime::kTypeof, 1);
5888 frame_->EmitPush(r0); // r0 has result
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005889
5890 } else {
ricow@chromium.org65fae842010-08-25 15:26:24 +00005891 bool can_overwrite = node->expression()->ResultOverwriteAllowed();
erik.corry@gmail.com4a2e25e2010-07-07 12:22:46 +00005892 UnaryOverwriteMode overwrite =
5893 can_overwrite ? UNARY_OVERWRITE : UNARY_NO_OVERWRITE;
5894
5895 bool no_negative_zero = node->expression()->no_negative_zero();
ricow@chromium.org30ce4112010-05-31 10:38:25 +00005896 Load(node->expression());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005897 switch (op) {
5898 case Token::NOT:
5899 case Token::DELETE:
5900 case Token::TYPEOF:
5901 UNREACHABLE(); // handled above
5902 break;
5903
5904 case Token::SUB: {
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00005905 frame_->PopToR0();
erik.corry@gmail.com4a2e25e2010-07-07 12:22:46 +00005906 GenericUnaryOpStub stub(
5907 Token::SUB,
5908 overwrite,
erik.corry@gmail.comd88afa22010-09-15 12:33:05 +00005909 NO_UNARY_FLAGS,
erik.corry@gmail.com4a2e25e2010-07-07 12:22:46 +00005910 no_negative_zero ? kIgnoreNegativeZero : kStrictNegativeZero);
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00005911 frame_->CallStub(&stub, 0);
ricow@chromium.org30ce4112010-05-31 10:38:25 +00005912 frame_->EmitPush(r0); // r0 has result
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005913 break;
5914 }
5915
5916 case Token::BIT_NOT: {
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00005917 Register tos = frame_->PopToRegister();
5918 JumpTarget not_smi_label;
kasperl@chromium.org71affb52009-05-26 05:44:31 +00005919 JumpTarget continue_label;
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00005920 // Smi check.
5921 __ tst(tos, Operand(kSmiTagMask));
5922 not_smi_label.Branch(ne);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005923
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00005924 __ mvn(tos, Operand(tos));
5925 __ bic(tos, tos, Operand(kSmiTagMask)); // Bit-clear inverted smi-tag.
5926 frame_->EmitPush(tos);
5927 // The fast case is the first to jump to the continue label, so it gets
5928 // to decide the virtual frame layout.
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00005929 continue_label.Jump();
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +00005930
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00005931 not_smi_label.Bind();
5932 frame_->SpillAll();
5933 __ Move(r0, tos);
erik.corry@gmail.comd88afa22010-09-15 12:33:05 +00005934 GenericUnaryOpStub stub(Token::BIT_NOT,
5935 overwrite,
5936 NO_UNARY_SMI_CODE_IN_STUB);
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00005937 frame_->CallStub(&stub, 0);
5938 frame_->EmitPush(r0);
5939
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00005940 continue_label.Bind();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005941 break;
5942 }
5943
5944 case Token::VOID:
ricow@chromium.org30ce4112010-05-31 10:38:25 +00005945 frame_->Drop();
5946 frame_->EmitPushRoot(Heap::kUndefinedValueRootIndex);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005947 break;
5948
mads.s.ager@gmail.com9a4089a2008-09-01 08:55:01 +00005949 case Token::ADD: {
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00005950 Register tos = frame_->Peek();
mads.s.ager@gmail.com9a4089a2008-09-01 08:55:01 +00005951 // Smi check.
kasperl@chromium.org71affb52009-05-26 05:44:31 +00005952 JumpTarget continue_label;
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00005953 __ tst(tos, Operand(kSmiTagMask));
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00005954 continue_label.Branch(eq);
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00005955
kmillikin@chromium.org13bd2942009-12-16 15:36:05 +00005956 frame_->InvokeBuiltin(Builtins::TO_NUMBER, CALL_JS, 1);
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00005957 frame_->EmitPush(r0);
5958
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00005959 continue_label.Bind();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005960 break;
mads.s.ager@gmail.com9a4089a2008-09-01 08:55:01 +00005961 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005962 default:
5963 UNREACHABLE();
5964 }
5965 }
kasperl@chromium.orge959c182009-07-27 08:59:04 +00005966 ASSERT(!has_valid_frame() ||
5967 (has_cc() && frame_->height() == original_height) ||
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00005968 (!has_cc() && frame_->height() == original_height + 1));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005969}
5970
5971
ager@chromium.orgbeb25712010-11-29 08:02:25 +00005972class DeferredCountOperation: public DeferredCode {
5973 public:
5974 DeferredCountOperation(Register value,
5975 bool is_increment,
5976 bool is_postfix,
5977 int target_size)
5978 : value_(value),
5979 is_increment_(is_increment),
5980 is_postfix_(is_postfix),
5981 target_size_(target_size) {}
5982
5983 virtual void Generate() {
5984 VirtualFrame copied_frame(*frame_state()->frame());
5985
5986 Label slow;
5987 // Check for smi operand.
5988 __ tst(value_, Operand(kSmiTagMask));
5989 __ b(ne, &slow);
5990
5991 // Revert optimistic increment/decrement.
5992 if (is_increment_) {
5993 __ sub(value_, value_, Operand(Smi::FromInt(1)));
5994 } else {
5995 __ add(value_, value_, Operand(Smi::FromInt(1)));
5996 }
5997
5998 // Slow case: Convert to number. At this point the
5999 // value to be incremented is in the value register..
6000 __ bind(&slow);
6001
6002 // Convert the operand to a number.
6003 copied_frame.EmitPush(value_);
6004
6005 copied_frame.InvokeBuiltin(Builtins::TO_NUMBER, CALL_JS, 1);
6006
6007 if (is_postfix_) {
6008 // Postfix: store to result (on the stack).
6009 __ str(r0, MemOperand(sp, target_size_ * kPointerSize));
6010 }
6011
6012 copied_frame.EmitPush(r0);
6013 copied_frame.EmitPush(Operand(Smi::FromInt(1)));
6014
6015 if (is_increment_) {
6016 copied_frame.CallRuntime(Runtime::kNumberAdd, 2);
6017 } else {
6018 copied_frame.CallRuntime(Runtime::kNumberSub, 2);
6019 }
6020
6021 __ Move(value_, r0);
6022
6023 copied_frame.MergeTo(frame_state()->frame());
6024 }
6025
6026 private:
6027 Register value_;
6028 bool is_increment_;
6029 bool is_postfix_;
6030 int target_size_;
6031};
6032
6033
ager@chromium.org7c537e22008-10-16 08:43:32 +00006034void CodeGenerator::VisitCountOperation(CountOperation* node) {
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00006035#ifdef DEBUG
6036 int original_height = frame_->height();
6037#endif
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006038 Comment cmnt(masm_, "[ CountOperation");
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00006039 VirtualFrame::RegisterAllocationScope scope(this);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006040
6041 bool is_postfix = node->is_postfix();
6042 bool is_increment = node->op() == Token::INC;
6043
6044 Variable* var = node->expression()->AsVariableProxy()->AsVariable();
6045 bool is_const = (var != NULL && var->mode() == Variable::CONST);
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00006046 bool is_slot = (var != NULL && var->mode() == Variable::VAR);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006047
whesse@chromium.org4a1fe7d2010-09-27 12:32:04 +00006048 if (!is_const && is_slot && type_info(var->AsSlot()).IsSmi()) {
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00006049 // The type info declares that this variable is always a Smi. That
6050 // means it is a Smi both before and after the increment/decrement.
6051 // Lets make use of that to make a very minimal count.
6052 Reference target(this, node->expression(), !is_const);
6053 ASSERT(!target.is_illegal());
6054 target.GetValue(); // Pushes the value.
6055 Register value = frame_->PopToRegister();
6056 if (is_postfix) frame_->EmitPush(value);
6057 if (is_increment) {
6058 __ add(value, value, Operand(Smi::FromInt(1)));
6059 } else {
6060 __ sub(value, value, Operand(Smi::FromInt(1)));
6061 }
6062 frame_->EmitPush(value);
kmillikin@chromium.org69ea3962010-07-05 11:01:40 +00006063 target.SetValue(NOT_CONST_INIT, LIKELY_SMI);
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00006064 if (is_postfix) frame_->Pop();
6065 ASSERT_EQ(original_height + 1, frame_->height());
6066 return;
6067 }
6068
6069 // If it's a postfix expression and its result is not ignored and the
6070 // reference is non-trivial, then push a placeholder on the stack now
6071 // to hold the result of the expression.
6072 bool placeholder_pushed = false;
6073 if (!is_slot && is_postfix) {
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +00006074 frame_->EmitPush(Operand(Smi::FromInt(0)));
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00006075 placeholder_pushed = true;
mads.s.ager31e71382008-08-13 09:32:07 +00006076 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006077
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +00006078 // A constant reference is not saved to, so a constant reference is not a
6079 // compound assignment reference.
6080 { Reference target(this, node->expression(), !is_const);
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00006081 if (target.is_illegal()) {
6082 // Spoof the virtual frame to have the expected height (one higher
6083 // than on entry).
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00006084 if (!placeholder_pushed) frame_->EmitPush(Operand(Smi::FromInt(0)));
ager@chromium.orgac091b72010-05-05 07:34:42 +00006085 ASSERT_EQ(original_height + 1, frame_->height());
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00006086 return;
6087 }
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00006088
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +00006089 // This pushes 0, 1 or 2 words on the object to be used later when updating
6090 // the target. It also pushes the current value of the target.
ager@chromium.org357bf652010-04-12 11:30:10 +00006091 target.GetValue();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006092
ager@chromium.orgbeb25712010-11-29 08:02:25 +00006093 bool value_is_known_smi = frame_->KnownSmiAt(0);
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +00006094 Register value = frame_->PopToRegister();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006095
6096 // Postfix: Store the old value as the result.
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00006097 if (placeholder_pushed) {
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +00006098 frame_->SetElementAt(value, target.size());
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00006099 } else if (is_postfix) {
6100 frame_->EmitPush(value);
6101 __ mov(VirtualFrame::scratch0(), value);
6102 value = VirtualFrame::scratch0();
ager@chromium.org3bf7b912008-11-17 09:09:45 +00006103 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006104
ager@chromium.orgbeb25712010-11-29 08:02:25 +00006105 // We can't use any type information here since the virtual frame from the
6106 // deferred code may have lost information and we can't merge a virtual
6107 // frame with less specific type knowledge to a virtual frame with more
6108 // specific knowledge that has already used that specific knowledge to
6109 // generate code.
6110 frame_->ForgetTypeInfo();
6111
6112 // The constructor here will capture the current virtual frame and use it to
6113 // merge to after the deferred code has run. No virtual frame changes are
6114 // allowed from here until the 'BindExit' below.
6115 DeferredCode* deferred =
6116 new DeferredCountOperation(value,
6117 is_increment,
6118 is_postfix,
6119 target.size());
6120 if (!value_is_known_smi) {
6121 // Check for smi operand.
6122 __ tst(value, Operand(kSmiTagMask));
6123
6124 deferred->Branch(ne);
6125 }
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00006126
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006127 // Perform optimistic increment/decrement.
6128 if (is_increment) {
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +00006129 __ add(value, value, Operand(Smi::FromInt(1)), SetCC);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006130 } else {
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +00006131 __ sub(value, value, Operand(Smi::FromInt(1)), SetCC);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006132 }
6133
ager@chromium.orgbeb25712010-11-29 08:02:25 +00006134 // If increment/decrement overflows, go to deferred code.
6135 deferred->Branch(vs);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006136
ager@chromium.orgbeb25712010-11-29 08:02:25 +00006137 deferred->BindExit();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006138
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006139 // Store the new value in the target if not const.
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +00006140 // At this point the answer is in the value register.
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +00006141 frame_->EmitPush(value);
6142 // Set the target with the result, leaving the result on
6143 // top of the stack. Removes the target from the stack if
6144 // it has a non-zero size.
kmillikin@chromium.org69ea3962010-07-05 11:01:40 +00006145 if (!is_const) target.SetValue(NOT_CONST_INIT, LIKELY_SMI);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006146 }
6147
6148 // Postfix: Discard the new value and use the old.
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +00006149 if (is_postfix) frame_->Pop();
ager@chromium.orgac091b72010-05-05 07:34:42 +00006150 ASSERT_EQ(original_height + 1, frame_->height());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006151}
6152
6153
ager@chromium.orgb26c50a2010-03-26 09:27:16 +00006154void CodeGenerator::GenerateLogicalBooleanOperation(BinaryOperation* node) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006155 // According to ECMA-262 section 11.11, page 58, the binary logical
6156 // operators must yield the result of one of the two expressions
6157 // before any ToBoolean() conversions. This means that the value
6158 // produced by a && or || operator is not necessarily a boolean.
6159
6160 // NOTE: If the left hand side produces a materialized value (not in
6161 // the CC register), we force the right hand side to do the
6162 // same. This is necessary because we may have to branch to the exit
6163 // after evaluating the left hand side (due to the shortcut
6164 // semantics), but the compiler must (statically) know if the result
6165 // of compiling the binary operation is materialized or not.
ager@chromium.orgb26c50a2010-03-26 09:27:16 +00006166 if (node->op() == Token::AND) {
kasperl@chromium.org71affb52009-05-26 05:44:31 +00006167 JumpTarget is_true;
ricow@chromium.org30ce4112010-05-31 10:38:25 +00006168 LoadCondition(node->left(), &is_true, false_target(), false);
kasperl@chromium.orge959c182009-07-27 08:59:04 +00006169 if (has_valid_frame() && !has_cc()) {
6170 // The left-hand side result is on top of the virtual frame.
kasperl@chromium.org71affb52009-05-26 05:44:31 +00006171 JumpTarget pop_and_continue;
6172 JumpTarget exit;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006173
kmillikin@chromium.org9155e252010-05-26 13:27:57 +00006174 frame_->Dup();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006175 // Avoid popping the result if it converts to 'false' using the
6176 // standard ToBoolean() conversion as described in ECMA-262,
6177 // section 9.2, page 30.
mads.s.ager31e71382008-08-13 09:32:07 +00006178 ToBoolean(&pop_and_continue, &exit);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006179 Branch(false, &exit);
6180
6181 // Pop the result of evaluating the first part.
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00006182 pop_and_continue.Bind();
kmillikin@chromium.org9155e252010-05-26 13:27:57 +00006183 frame_->Pop();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006184
6185 // Evaluate right side expression.
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00006186 is_true.Bind();
ricow@chromium.org30ce4112010-05-31 10:38:25 +00006187 Load(node->right());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006188
6189 // Exit (always with a materialized value).
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00006190 exit.Bind();
kasperl@chromium.orge959c182009-07-27 08:59:04 +00006191 } else if (has_cc() || is_true.is_linked()) {
6192 // The left-hand side is either (a) partially compiled to
6193 // control flow with a final branch left to emit or (b) fully
6194 // compiled to control flow and possibly true.
6195 if (has_cc()) {
6196 Branch(false, false_target());
6197 }
6198 is_true.Bind();
ricow@chromium.org30ce4112010-05-31 10:38:25 +00006199 LoadCondition(node->right(), true_target(), false_target(), false);
kasperl@chromium.orge959c182009-07-27 08:59:04 +00006200 } else {
6201 // Nothing to do.
6202 ASSERT(!has_valid_frame() && !has_cc() && !is_true.is_linked());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006203 }
6204
ager@chromium.orgb26c50a2010-03-26 09:27:16 +00006205 } else {
6206 ASSERT(node->op() == Token::OR);
kasperl@chromium.org71affb52009-05-26 05:44:31 +00006207 JumpTarget is_false;
ricow@chromium.org30ce4112010-05-31 10:38:25 +00006208 LoadCondition(node->left(), true_target(), &is_false, false);
kasperl@chromium.orge959c182009-07-27 08:59:04 +00006209 if (has_valid_frame() && !has_cc()) {
6210 // The left-hand side result is on top of the virtual frame.
kasperl@chromium.org71affb52009-05-26 05:44:31 +00006211 JumpTarget pop_and_continue;
6212 JumpTarget exit;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006213
kmillikin@chromium.org9155e252010-05-26 13:27:57 +00006214 frame_->Dup();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006215 // Avoid popping the result if it converts to 'true' using the
6216 // standard ToBoolean() conversion as described in ECMA-262,
6217 // section 9.2, page 30.
mads.s.ager31e71382008-08-13 09:32:07 +00006218 ToBoolean(&exit, &pop_and_continue);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006219 Branch(true, &exit);
6220
6221 // Pop the result of evaluating the first part.
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00006222 pop_and_continue.Bind();
kmillikin@chromium.org9155e252010-05-26 13:27:57 +00006223 frame_->Pop();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006224
6225 // Evaluate right side expression.
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00006226 is_false.Bind();
ricow@chromium.org30ce4112010-05-31 10:38:25 +00006227 Load(node->right());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006228
6229 // Exit (always with a materialized value).
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00006230 exit.Bind();
kasperl@chromium.orge959c182009-07-27 08:59:04 +00006231 } else if (has_cc() || is_false.is_linked()) {
6232 // The left-hand side is either (a) partially compiled to
6233 // control flow with a final branch left to emit or (b) fully
6234 // compiled to control flow and possibly false.
6235 if (has_cc()) {
6236 Branch(true, true_target());
6237 }
6238 is_false.Bind();
ricow@chromium.org30ce4112010-05-31 10:38:25 +00006239 LoadCondition(node->right(), true_target(), false_target(), false);
kasperl@chromium.orge959c182009-07-27 08:59:04 +00006240 } else {
6241 // Nothing to do.
6242 ASSERT(!has_valid_frame() && !has_cc() && !is_false.is_linked());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006243 }
ager@chromium.orgb26c50a2010-03-26 09:27:16 +00006244 }
6245}
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006246
ager@chromium.orgb26c50a2010-03-26 09:27:16 +00006247
6248void CodeGenerator::VisitBinaryOperation(BinaryOperation* node) {
6249#ifdef DEBUG
6250 int original_height = frame_->height();
6251#endif
ager@chromium.orgb26c50a2010-03-26 09:27:16 +00006252 Comment cmnt(masm_, "[ BinaryOperation");
6253
6254 if (node->op() == Token::AND || node->op() == Token::OR) {
6255 GenerateLogicalBooleanOperation(node);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006256 } else {
6257 // Optimize for the case where (at least) one of the expressions
6258 // is a literal small integer.
6259 Literal* lliteral = node->left()->AsLiteral();
6260 Literal* rliteral = node->right()->AsLiteral();
ager@chromium.org65dad4b2009-04-23 08:48:43 +00006261 // NOTE: The code below assumes that the slow cases (calls to runtime)
6262 // never return a constant/immutable object.
ricow@chromium.org65fae842010-08-25 15:26:24 +00006263 bool overwrite_left = node->left()->ResultOverwriteAllowed();
6264 bool overwrite_right = node->right()->ResultOverwriteAllowed();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006265
6266 if (rliteral != NULL && rliteral->handle()->IsSmi()) {
ager@chromium.org357bf652010-04-12 11:30:10 +00006267 VirtualFrame::RegisterAllocationScope scope(this);
6268 Load(node->left());
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00006269 if (frame_->KnownSmiAt(0)) overwrite_left = false;
kmillikin@chromium.org4111b802010-05-03 10:34:42 +00006270 SmiOperation(node->op(),
6271 rliteral->handle(),
6272 false,
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00006273 overwrite_left ? OVERWRITE_LEFT : NO_OVERWRITE);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006274 } else if (lliteral != NULL && lliteral->handle()->IsSmi()) {
ager@chromium.org357bf652010-04-12 11:30:10 +00006275 VirtualFrame::RegisterAllocationScope scope(this);
6276 Load(node->right());
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00006277 if (frame_->KnownSmiAt(0)) overwrite_right = false;
kmillikin@chromium.org4111b802010-05-03 10:34:42 +00006278 SmiOperation(node->op(),
6279 lliteral->handle(),
6280 true,
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00006281 overwrite_right ? OVERWRITE_RIGHT : NO_OVERWRITE);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006282 } else {
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00006283 GenerateInlineSmi inline_smi =
6284 loop_nesting() > 0 ? GENERATE_INLINE_SMI : DONT_GENERATE_INLINE_SMI;
6285 if (lliteral != NULL) {
6286 ASSERT(!lliteral->handle()->IsSmi());
6287 inline_smi = DONT_GENERATE_INLINE_SMI;
6288 }
6289 if (rliteral != NULL) {
6290 ASSERT(!rliteral->handle()->IsSmi());
6291 inline_smi = DONT_GENERATE_INLINE_SMI;
6292 }
ager@chromium.org357bf652010-04-12 11:30:10 +00006293 VirtualFrame::RegisterAllocationScope scope(this);
ager@chromium.org65dad4b2009-04-23 08:48:43 +00006294 OverwriteMode overwrite_mode = NO_OVERWRITE;
6295 if (overwrite_left) {
6296 overwrite_mode = OVERWRITE_LEFT;
6297 } else if (overwrite_right) {
6298 overwrite_mode = OVERWRITE_RIGHT;
6299 }
ager@chromium.org357bf652010-04-12 11:30:10 +00006300 Load(node->left());
6301 Load(node->right());
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00006302 GenericBinaryOperation(node->op(), overwrite_mode, inline_smi);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006303 }
6304 }
kasperl@chromium.orge959c182009-07-27 08:59:04 +00006305 ASSERT(!has_valid_frame() ||
6306 (has_cc() && frame_->height() == original_height) ||
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00006307 (!has_cc() && frame_->height() == original_height + 1));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006308}
6309
6310
ager@chromium.org7c537e22008-10-16 08:43:32 +00006311void CodeGenerator::VisitThisFunction(ThisFunction* node) {
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00006312#ifdef DEBUG
6313 int original_height = frame_->height();
6314#endif
kmillikin@chromium.org9155e252010-05-26 13:27:57 +00006315 frame_->EmitPush(MemOperand(frame_->Function()));
ager@chromium.orgac091b72010-05-05 07:34:42 +00006316 ASSERT_EQ(original_height + 1, frame_->height());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006317}
6318
6319
ager@chromium.org7c537e22008-10-16 08:43:32 +00006320void CodeGenerator::VisitCompareOperation(CompareOperation* node) {
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00006321#ifdef DEBUG
6322 int original_height = frame_->height();
6323#endif
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006324 Comment cmnt(masm_, "[ CompareOperation");
6325
ager@chromium.org357bf652010-04-12 11:30:10 +00006326 VirtualFrame::RegisterAllocationScope nonspilled_scope(this);
6327
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006328 // Get the expressions from the node.
6329 Expression* left = node->left();
6330 Expression* right = node->right();
6331 Token::Value op = node->op();
6332
ager@chromium.org3bf7b912008-11-17 09:09:45 +00006333 // To make typeof testing for natives implemented in JavaScript really
6334 // efficient, we generate special code for expressions of the form:
6335 // 'typeof <expression> == <string>'.
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006336 UnaryOperation* operation = left->AsUnaryOperation();
6337 if ((op == Token::EQ || op == Token::EQ_STRICT) &&
6338 (operation != NULL && operation->op() == Token::TYPEOF) &&
6339 (right->AsLiteral() != NULL &&
6340 right->AsLiteral()->handle()->IsString())) {
6341 Handle<String> check(String::cast(*right->AsLiteral()->handle()));
6342
ager@chromium.org357bf652010-04-12 11:30:10 +00006343 // Load the operand, move it to a register.
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006344 LoadTypeofExpression(operation->expression());
ager@chromium.org357bf652010-04-12 11:30:10 +00006345 Register tos = frame_->PopToRegister();
6346
ager@chromium.org357bf652010-04-12 11:30:10 +00006347 Register scratch = VirtualFrame::scratch0();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006348
6349 if (check->Equals(Heap::number_symbol())) {
ager@chromium.org357bf652010-04-12 11:30:10 +00006350 __ tst(tos, Operand(kSmiTagMask));
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00006351 true_target()->Branch(eq);
ager@chromium.org357bf652010-04-12 11:30:10 +00006352 __ ldr(tos, FieldMemOperand(tos, HeapObject::kMapOffset));
ager@chromium.orgab99eea2009-08-25 07:05:41 +00006353 __ LoadRoot(ip, Heap::kHeapNumberMapRootIndex);
ager@chromium.org357bf652010-04-12 11:30:10 +00006354 __ cmp(tos, ip);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006355 cc_reg_ = eq;
6356
6357 } else if (check->Equals(Heap::string_symbol())) {
ager@chromium.org357bf652010-04-12 11:30:10 +00006358 __ tst(tos, Operand(kSmiTagMask));
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00006359 false_target()->Branch(eq);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006360
ager@chromium.org357bf652010-04-12 11:30:10 +00006361 __ ldr(tos, FieldMemOperand(tos, HeapObject::kMapOffset));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006362
ager@chromium.org3bf7b912008-11-17 09:09:45 +00006363 // It can be an undetectable string object.
ager@chromium.org357bf652010-04-12 11:30:10 +00006364 __ ldrb(scratch, FieldMemOperand(tos, Map::kBitFieldOffset));
6365 __ and_(scratch, scratch, Operand(1 << Map::kIsUndetectable));
6366 __ cmp(scratch, Operand(1 << Map::kIsUndetectable));
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00006367 false_target()->Branch(eq);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006368
ager@chromium.org357bf652010-04-12 11:30:10 +00006369 __ ldrb(scratch, FieldMemOperand(tos, Map::kInstanceTypeOffset));
6370 __ cmp(scratch, Operand(FIRST_NONSTRING_TYPE));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006371 cc_reg_ = lt;
6372
6373 } else if (check->Equals(Heap::boolean_symbol())) {
ager@chromium.orgab99eea2009-08-25 07:05:41 +00006374 __ LoadRoot(ip, Heap::kTrueValueRootIndex);
ager@chromium.org357bf652010-04-12 11:30:10 +00006375 __ cmp(tos, ip);
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00006376 true_target()->Branch(eq);
ager@chromium.orgab99eea2009-08-25 07:05:41 +00006377 __ LoadRoot(ip, Heap::kFalseValueRootIndex);
ager@chromium.org357bf652010-04-12 11:30:10 +00006378 __ cmp(tos, ip);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006379 cc_reg_ = eq;
6380
6381 } else if (check->Equals(Heap::undefined_symbol())) {
ager@chromium.orgab99eea2009-08-25 07:05:41 +00006382 __ LoadRoot(ip, Heap::kUndefinedValueRootIndex);
ager@chromium.org357bf652010-04-12 11:30:10 +00006383 __ cmp(tos, ip);
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00006384 true_target()->Branch(eq);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006385
ager@chromium.org357bf652010-04-12 11:30:10 +00006386 __ tst(tos, Operand(kSmiTagMask));
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00006387 false_target()->Branch(eq);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006388
ager@chromium.org3bf7b912008-11-17 09:09:45 +00006389 // It can be an undetectable object.
ager@chromium.org357bf652010-04-12 11:30:10 +00006390 __ ldr(tos, FieldMemOperand(tos, HeapObject::kMapOffset));
6391 __ ldrb(scratch, FieldMemOperand(tos, Map::kBitFieldOffset));
6392 __ and_(scratch, scratch, Operand(1 << Map::kIsUndetectable));
6393 __ cmp(scratch, Operand(1 << Map::kIsUndetectable));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006394
6395 cc_reg_ = eq;
6396
6397 } else if (check->Equals(Heap::function_symbol())) {
ager@chromium.org357bf652010-04-12 11:30:10 +00006398 __ tst(tos, Operand(kSmiTagMask));
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00006399 false_target()->Branch(eq);
ager@chromium.org357bf652010-04-12 11:30:10 +00006400 Register map_reg = scratch;
6401 __ CompareObjectType(tos, map_reg, tos, JS_FUNCTION_TYPE);
ager@chromium.orgc4c92722009-11-18 14:12:51 +00006402 true_target()->Branch(eq);
6403 // Regular expressions are callable so typeof == 'function'.
ager@chromium.org357bf652010-04-12 11:30:10 +00006404 __ CompareInstanceType(map_reg, tos, JS_REGEXP_TYPE);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006405 cc_reg_ = eq;
6406
6407 } else if (check->Equals(Heap::object_symbol())) {
ager@chromium.org357bf652010-04-12 11:30:10 +00006408 __ tst(tos, Operand(kSmiTagMask));
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00006409 false_target()->Branch(eq);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006410
ager@chromium.orgab99eea2009-08-25 07:05:41 +00006411 __ LoadRoot(ip, Heap::kNullValueRootIndex);
ager@chromium.org357bf652010-04-12 11:30:10 +00006412 __ cmp(tos, ip);
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00006413 true_target()->Branch(eq);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006414
ager@chromium.org357bf652010-04-12 11:30:10 +00006415 Register map_reg = scratch;
6416 __ CompareObjectType(tos, map_reg, tos, JS_REGEXP_TYPE);
ager@chromium.orgc4c92722009-11-18 14:12:51 +00006417 false_target()->Branch(eq);
6418
ager@chromium.org3bf7b912008-11-17 09:09:45 +00006419 // It can be an undetectable object.
ager@chromium.org357bf652010-04-12 11:30:10 +00006420 __ ldrb(tos, FieldMemOperand(map_reg, Map::kBitFieldOffset));
6421 __ and_(tos, tos, Operand(1 << Map::kIsUndetectable));
6422 __ cmp(tos, Operand(1 << Map::kIsUndetectable));
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00006423 false_target()->Branch(eq);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006424
ager@chromium.org357bf652010-04-12 11:30:10 +00006425 __ ldrb(tos, FieldMemOperand(map_reg, Map::kInstanceTypeOffset));
6426 __ cmp(tos, Operand(FIRST_JS_OBJECT_TYPE));
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00006427 false_target()->Branch(lt);
ager@chromium.org357bf652010-04-12 11:30:10 +00006428 __ cmp(tos, Operand(LAST_JS_OBJECT_TYPE));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006429 cc_reg_ = le;
6430
6431 } else {
ager@chromium.org3bf7b912008-11-17 09:09:45 +00006432 // Uncommon case: typeof testing against a string literal that is
6433 // never returned from the typeof operator.
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00006434 false_target()->Jump();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006435 }
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00006436 ASSERT(!has_valid_frame() ||
6437 (has_cc() && frame_->height() == original_height));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006438 return;
6439 }
6440
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006441 switch (op) {
6442 case Token::EQ:
kasperl@chromium.org2abc4502009-07-02 07:00:29 +00006443 Comparison(eq, left, right, false);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006444 break;
6445
6446 case Token::LT:
kasperl@chromium.org2abc4502009-07-02 07:00:29 +00006447 Comparison(lt, left, right);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006448 break;
6449
6450 case Token::GT:
kasperl@chromium.org2abc4502009-07-02 07:00:29 +00006451 Comparison(gt, left, right);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006452 break;
6453
6454 case Token::LTE:
kasperl@chromium.org2abc4502009-07-02 07:00:29 +00006455 Comparison(le, left, right);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006456 break;
6457
6458 case Token::GTE:
kasperl@chromium.org2abc4502009-07-02 07:00:29 +00006459 Comparison(ge, left, right);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006460 break;
6461
6462 case Token::EQ_STRICT:
kasperl@chromium.org2abc4502009-07-02 07:00:29 +00006463 Comparison(eq, left, right, true);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006464 break;
6465
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00006466 case Token::IN: {
ricow@chromium.org30ce4112010-05-31 10:38:25 +00006467 Load(left);
6468 Load(right);
kmillikin@chromium.org13bd2942009-12-16 15:36:05 +00006469 frame_->InvokeBuiltin(Builtins::IN, CALL_JS, 2);
christian.plesner.hansen@gmail.com5a6af922009-08-12 14:20:51 +00006470 frame_->EmitPush(r0);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006471 break;
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00006472 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006473
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00006474 case Token::INSTANCEOF: {
ricow@chromium.org30ce4112010-05-31 10:38:25 +00006475 Load(left);
6476 Load(right);
ager@chromium.org5f0c45f2010-12-17 08:51:21 +00006477 InstanceofStub stub(InstanceofStub::kNoFlags);
christian.plesner.hansen@gmail.com5a6af922009-08-12 14:20:51 +00006478 frame_->CallStub(&stub, 2);
ager@chromium.orgeadaf222009-06-16 09:43:10 +00006479 // At this point if instanceof succeeded then r0 == 0.
christian.plesner.hansen@gmail.com5a6af922009-08-12 14:20:51 +00006480 __ tst(r0, Operand(r0));
ager@chromium.org7c537e22008-10-16 08:43:32 +00006481 cc_reg_ = eq;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006482 break;
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00006483 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006484
6485 default:
6486 UNREACHABLE();
6487 }
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00006488 ASSERT((has_cc() && frame_->height() == original_height) ||
6489 (!has_cc() && frame_->height() == original_height + 1));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006490}
6491
6492
ricow@chromium.org65fae842010-08-25 15:26:24 +00006493void CodeGenerator::VisitCompareToNull(CompareToNull* node) {
6494#ifdef DEBUG
6495 int original_height = frame_->height();
6496#endif
6497 Comment cmnt(masm_, "[ CompareToNull");
6498
6499 Load(node->expression());
6500 Register tos = frame_->PopToRegister();
6501 __ LoadRoot(ip, Heap::kNullValueRootIndex);
6502 __ cmp(tos, ip);
6503
6504 // The 'null' value is only equal to 'undefined' if using non-strict
6505 // comparisons.
6506 if (!node->is_strict()) {
6507 true_target()->Branch(eq);
6508 __ LoadRoot(ip, Heap::kUndefinedValueRootIndex);
6509 __ cmp(tos, Operand(ip));
6510 true_target()->Branch(eq);
6511
6512 __ tst(tos, Operand(kSmiTagMask));
6513 false_target()->Branch(eq);
6514
6515 // It can be an undetectable object.
6516 __ ldr(tos, FieldMemOperand(tos, HeapObject::kMapOffset));
6517 __ ldrb(tos, FieldMemOperand(tos, Map::kBitFieldOffset));
6518 __ and_(tos, tos, Operand(1 << Map::kIsUndetectable));
6519 __ cmp(tos, Operand(1 << Map::kIsUndetectable));
6520 }
6521
6522 cc_reg_ = eq;
6523 ASSERT(has_cc() && frame_->height() == original_height);
6524}
6525
6526
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00006527class DeferredReferenceGetNamedValue: public DeferredCode {
6528 public:
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00006529 explicit DeferredReferenceGetNamedValue(Register receiver,
ager@chromium.orgbeb25712010-11-29 08:02:25 +00006530 Handle<String> name,
6531 bool is_contextual)
6532 : receiver_(receiver),
6533 name_(name),
6534 is_contextual_(is_contextual),
6535 is_dont_delete_(false) {
6536 set_comment(is_contextual
6537 ? "[ DeferredReferenceGetNamedValue (contextual)"
6538 : "[ DeferredReferenceGetNamedValue");
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00006539 }
6540
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00006541 virtual void Generate();
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00006542
ager@chromium.orgbeb25712010-11-29 08:02:25 +00006543 void set_is_dont_delete(bool value) {
6544 ASSERT(is_contextual_);
6545 is_dont_delete_ = value;
6546 }
6547
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00006548 private:
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00006549 Register receiver_;
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00006550 Handle<String> name_;
ager@chromium.orgbeb25712010-11-29 08:02:25 +00006551 bool is_contextual_;
6552 bool is_dont_delete_;
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00006553};
6554
6555
ricow@chromium.org30ce4112010-05-31 10:38:25 +00006556// Convention for this is that on entry the receiver is in a register that
6557// is not used by the stack. On exit the answer is found in that same
6558// register and the stack has the same height.
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00006559void DeferredReferenceGetNamedValue::Generate() {
ricow@chromium.org30ce4112010-05-31 10:38:25 +00006560#ifdef DEBUG
6561 int expected_height = frame_state()->frame()->height();
6562#endif
6563 VirtualFrame copied_frame(*frame_state()->frame());
6564 copied_frame.SpillAll();
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00006565
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00006566 Register scratch1 = VirtualFrame::scratch0();
6567 Register scratch2 = VirtualFrame::scratch1();
ricow@chromium.org30ce4112010-05-31 10:38:25 +00006568 ASSERT(!receiver_.is(scratch1) && !receiver_.is(scratch2));
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00006569 __ DecrementCounter(&Counters::named_load_inline, 1, scratch1, scratch2);
6570 __ IncrementCounter(&Counters::named_load_inline_miss, 1, scratch1, scratch2);
6571
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00006572 // Ensure receiver in r0 and name in r2 to match load ic calling convention.
6573 __ Move(r0, receiver_);
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00006574 __ mov(r2, Operand(name_));
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00006575
6576 // The rest of the instructions in the deferred code must be together.
6577 { Assembler::BlockConstPoolScope block_const_pool(masm_);
6578 Handle<Code> ic(Builtins::builtin(Builtins::LoadIC_Initialize));
ager@chromium.orgbeb25712010-11-29 08:02:25 +00006579 RelocInfo::Mode mode = is_contextual_
6580 ? RelocInfo::CODE_TARGET_CONTEXT
6581 : RelocInfo::CODE_TARGET;
6582 __ Call(ic, mode);
6583 // We must mark the code just after the call with the correct marker.
6584 MacroAssembler::NopMarkerTypes code_marker;
6585 if (is_contextual_) {
6586 code_marker = is_dont_delete_
6587 ? MacroAssembler::PROPERTY_ACCESS_INLINED_CONTEXT_DONT_DELETE
6588 : MacroAssembler::PROPERTY_ACCESS_INLINED_CONTEXT;
6589 } else {
6590 code_marker = MacroAssembler::PROPERTY_ACCESS_INLINED;
6591 }
6592 __ MarkCode(code_marker);
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00006593
ricow@chromium.org30ce4112010-05-31 10:38:25 +00006594 // At this point the answer is in r0. We move it to the expected register
6595 // if necessary.
6596 __ Move(receiver_, r0);
6597
6598 // Now go back to the frame that we entered with. This will not overwrite
6599 // the receiver register since that register was not in use when we came
6600 // in. The instructions emitted by this merge are skipped over by the
6601 // inline load patching mechanism when looking for the branch instruction
6602 // that tells it where the code to patch is.
6603 copied_frame.MergeTo(frame_state()->frame());
6604
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00006605 // Block the constant pool for one more instruction after leaving this
6606 // constant pool block scope to include the branch instruction ending the
6607 // deferred code.
6608 __ BlockConstPoolFor(1);
6609 }
ricow@chromium.org30ce4112010-05-31 10:38:25 +00006610 ASSERT_EQ(expected_height, frame_state()->frame()->height());
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00006611}
6612
6613
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00006614class DeferredReferenceGetKeyedValue: public DeferredCode {
6615 public:
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +00006616 DeferredReferenceGetKeyedValue(Register key, Register receiver)
6617 : key_(key), receiver_(receiver) {
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00006618 set_comment("[ DeferredReferenceGetKeyedValue");
6619 }
6620
6621 virtual void Generate();
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +00006622
6623 private:
6624 Register key_;
6625 Register receiver_;
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00006626};
6627
6628
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00006629// Takes key and register in r0 and r1 or vice versa. Returns result
6630// in r0.
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00006631void DeferredReferenceGetKeyedValue::Generate() {
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +00006632 ASSERT((key_.is(r0) && receiver_.is(r1)) ||
6633 (key_.is(r1) && receiver_.is(r0)));
6634
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00006635 VirtualFrame copied_frame(*frame_state()->frame());
6636 copied_frame.SpillAll();
6637
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00006638 Register scratch1 = VirtualFrame::scratch0();
6639 Register scratch2 = VirtualFrame::scratch1();
6640 __ DecrementCounter(&Counters::keyed_load_inline, 1, scratch1, scratch2);
6641 __ IncrementCounter(&Counters::keyed_load_inline_miss, 1, scratch1, scratch2);
6642
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +00006643 // Ensure key in r0 and receiver in r1 to match keyed load ic calling
6644 // convention.
6645 if (key_.is(r1)) {
6646 __ Swap(r0, r1, ip);
6647 }
6648
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00006649 // The rest of the instructions in the deferred code must be together.
6650 { Assembler::BlockConstPoolScope block_const_pool(masm_);
sgjesse@chromium.org720dc0b2010-05-10 09:25:39 +00006651 // Call keyed load IC. It has the arguments key and receiver in r0 and r1.
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00006652 Handle<Code> ic(Builtins::builtin(Builtins::KeyedLoadIC_Initialize));
6653 __ Call(ic, RelocInfo::CODE_TARGET);
6654 // The call must be followed by a nop instruction to indicate that the
6655 // keyed load has been inlined.
ager@chromium.orgbeb25712010-11-29 08:02:25 +00006656 __ MarkCode(MacroAssembler::PROPERTY_ACCESS_INLINED);
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00006657
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00006658 // Now go back to the frame that we entered with. This will not overwrite
6659 // the receiver or key registers since they were not in use when we came
6660 // in. The instructions emitted by this merge are skipped over by the
6661 // inline load patching mechanism when looking for the branch instruction
6662 // that tells it where the code to patch is.
6663 copied_frame.MergeTo(frame_state()->frame());
6664
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00006665 // Block the constant pool for one more instruction after leaving this
6666 // constant pool block scope to include the branch instruction ending the
6667 // deferred code.
6668 __ BlockConstPoolFor(1);
6669 }
6670}
6671
6672
6673class DeferredReferenceSetKeyedValue: public DeferredCode {
6674 public:
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00006675 DeferredReferenceSetKeyedValue(Register value,
6676 Register key,
6677 Register receiver)
6678 : value_(value), key_(key), receiver_(receiver) {
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00006679 set_comment("[ DeferredReferenceSetKeyedValue");
6680 }
6681
6682 virtual void Generate();
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00006683
6684 private:
6685 Register value_;
6686 Register key_;
6687 Register receiver_;
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00006688};
6689
6690
6691void DeferredReferenceSetKeyedValue::Generate() {
6692 Register scratch1 = VirtualFrame::scratch0();
6693 Register scratch2 = VirtualFrame::scratch1();
6694 __ DecrementCounter(&Counters::keyed_store_inline, 1, scratch1, scratch2);
6695 __ IncrementCounter(
6696 &Counters::keyed_store_inline_miss, 1, scratch1, scratch2);
6697
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00006698 // Ensure value in r0, key in r1 and receiver in r2 to match keyed store ic
6699 // calling convention.
6700 if (value_.is(r1)) {
6701 __ Swap(r0, r1, ip);
6702 }
6703 ASSERT(receiver_.is(r2));
6704
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00006705 // The rest of the instructions in the deferred code must be together.
6706 { Assembler::BlockConstPoolScope block_const_pool(masm_);
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00006707 // Call keyed store IC. It has the arguments value, key and receiver in r0,
6708 // r1 and r2.
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00006709 Handle<Code> ic(Builtins::builtin(Builtins::KeyedStoreIC_Initialize));
6710 __ Call(ic, RelocInfo::CODE_TARGET);
6711 // The call must be followed by a nop instruction to indicate that the
6712 // keyed store has been inlined.
ager@chromium.orgbeb25712010-11-29 08:02:25 +00006713 __ MarkCode(MacroAssembler::PROPERTY_ACCESS_INLINED);
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00006714
6715 // Block the constant pool for one more instruction after leaving this
6716 // constant pool block scope to include the branch instruction ending the
6717 // deferred code.
6718 __ BlockConstPoolFor(1);
6719 }
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00006720}
6721
6722
whesse@chromium.orgba5a61b2010-07-26 11:44:40 +00006723class DeferredReferenceSetNamedValue: public DeferredCode {
6724 public:
6725 DeferredReferenceSetNamedValue(Register value,
6726 Register receiver,
6727 Handle<String> name)
6728 : value_(value), receiver_(receiver), name_(name) {
6729 set_comment("[ DeferredReferenceSetNamedValue");
6730 }
6731
6732 virtual void Generate();
6733
6734 private:
6735 Register value_;
6736 Register receiver_;
6737 Handle<String> name_;
6738};
6739
6740
6741// Takes value in r0, receiver in r1 and returns the result (the
6742// value) in r0.
6743void DeferredReferenceSetNamedValue::Generate() {
6744 // Record the entry frame and spill.
6745 VirtualFrame copied_frame(*frame_state()->frame());
6746 copied_frame.SpillAll();
6747
6748 // Ensure value in r0, receiver in r1 to match store ic calling
6749 // convention.
6750 ASSERT(value_.is(r0) && receiver_.is(r1));
6751 __ mov(r2, Operand(name_));
6752
6753 // The rest of the instructions in the deferred code must be together.
6754 { Assembler::BlockConstPoolScope block_const_pool(masm_);
6755 // Call keyed store IC. It has the arguments value, key and receiver in r0,
6756 // r1 and r2.
6757 Handle<Code> ic(Builtins::builtin(Builtins::StoreIC_Initialize));
6758 __ Call(ic, RelocInfo::CODE_TARGET);
6759 // The call must be followed by a nop instruction to indicate that the
6760 // named store has been inlined.
ager@chromium.orgbeb25712010-11-29 08:02:25 +00006761 __ MarkCode(MacroAssembler::PROPERTY_ACCESS_INLINED);
whesse@chromium.orgba5a61b2010-07-26 11:44:40 +00006762
6763 // Go back to the frame we entered with. The instructions
6764 // generated by this merge are skipped over by the inline store
6765 // patching mechanism when looking for the branch instruction that
6766 // tells it where the code to patch is.
6767 copied_frame.MergeTo(frame_state()->frame());
6768
6769 // Block the constant pool for one more instruction after leaving this
6770 // constant pool block scope to include the branch instruction ending the
6771 // deferred code.
6772 __ BlockConstPoolFor(1);
6773 }
6774}
6775
6776
ricow@chromium.org30ce4112010-05-31 10:38:25 +00006777// Consumes the top of stack (the receiver) and pushes the result instead.
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00006778void CodeGenerator::EmitNamedLoad(Handle<String> name, bool is_contextual) {
ager@chromium.orgbeb25712010-11-29 08:02:25 +00006779 bool contextual_load_in_builtin =
6780 is_contextual &&
6781 (Bootstrapper::IsActive() ||
6782 (!info_->closure().is_null() && info_->closure()->IsBuiltin()));
6783
6784 if (scope()->is_global_scope() ||
6785 loop_nesting() == 0 ||
6786 contextual_load_in_builtin) {
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00006787 Comment cmnt(masm(), "[ Load from named Property");
6788 // Setup the name register and call load IC.
ager@chromium.orgac091b72010-05-05 07:34:42 +00006789 frame_->CallLoadIC(name,
6790 is_contextual
6791 ? RelocInfo::CODE_TARGET_CONTEXT
6792 : RelocInfo::CODE_TARGET);
ricow@chromium.org30ce4112010-05-31 10:38:25 +00006793 frame_->EmitPush(r0); // Push answer.
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00006794 } else {
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00006795 // Inline the in-object property case.
ager@chromium.orgbeb25712010-11-29 08:02:25 +00006796 Comment cmnt(masm(), is_contextual
6797 ? "[ Inlined contextual property load"
6798 : "[ Inlined named property load");
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00006799
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00006800 // Counter will be decremented in the deferred code. Placed here to avoid
6801 // having it in the instruction stream below where patching will occur.
ager@chromium.orgbeb25712010-11-29 08:02:25 +00006802 if (is_contextual) {
6803 __ IncrementCounter(&Counters::named_load_global_inline, 1,
6804 frame_->scratch0(), frame_->scratch1());
6805 } else {
6806 __ IncrementCounter(&Counters::named_load_inline, 1,
6807 frame_->scratch0(), frame_->scratch1());
6808 }
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00006809
6810 // The following instructions are the inlined load of an in-object property.
6811 // Parts of this code is patched, so the exact instructions generated needs
6812 // to be fixed. Therefore the instruction pool is blocked when generating
6813 // this code
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00006814
6815 // Load the receiver from the stack.
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00006816 Register receiver = frame_->PopToRegister();
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00006817
6818 DeferredReferenceGetNamedValue* deferred =
ager@chromium.orgbeb25712010-11-29 08:02:25 +00006819 new DeferredReferenceGetNamedValue(receiver, name, is_contextual);
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00006820
ager@chromium.orgbeb25712010-11-29 08:02:25 +00006821 bool is_dont_delete = false;
6822 if (is_contextual) {
6823 if (!info_->closure().is_null()) {
6824 // When doing lazy compilation we can check if the global cell
6825 // already exists and use its "don't delete" status as a hint.
6826 AssertNoAllocation no_gc;
6827 v8::internal::GlobalObject* global_object =
6828 info_->closure()->context()->global();
6829 LookupResult lookup;
6830 global_object->LocalLookupRealNamedProperty(*name, &lookup);
6831 if (lookup.IsProperty() && lookup.type() == NORMAL) {
6832 ASSERT(lookup.holder() == global_object);
6833 ASSERT(global_object->property_dictionary()->ValueAt(
6834 lookup.GetDictionaryEntry())->IsJSGlobalPropertyCell());
6835 is_dont_delete = lookup.IsDontDelete();
6836 }
6837 }
6838 if (is_dont_delete) {
6839 __ IncrementCounter(&Counters::dont_delete_hint_hit, 1,
6840 frame_->scratch0(), frame_->scratch1());
6841 }
6842 }
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00006843
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00006844 { Assembler::BlockConstPoolScope block_const_pool(masm_);
ager@chromium.orgbeb25712010-11-29 08:02:25 +00006845 if (!is_contextual) {
6846 // Check that the receiver is a heap object.
6847 __ tst(receiver, Operand(kSmiTagMask));
6848 deferred->Branch(eq);
6849 }
6850
6851 // Check for the_hole_value if necessary.
6852 // Below we rely on the number of instructions generated, and we can't
6853 // cope with the Check macro which does not generate a fixed number of
6854 // instructions.
6855 Label skip, check_the_hole, cont;
6856 if (FLAG_debug_code && is_contextual && is_dont_delete) {
6857 __ b(&skip);
6858 __ bind(&check_the_hole);
6859 __ Check(ne, "DontDelete cells can't contain the hole");
6860 __ b(&cont);
6861 __ bind(&skip);
6862 }
6863
6864#ifdef DEBUG
6865 int InlinedNamedLoadInstructions = 5;
6866 Label check_inlined_codesize;
6867 masm_->bind(&check_inlined_codesize);
6868#endif
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00006869
ricow@chromium.org30ce4112010-05-31 10:38:25 +00006870 Register scratch = VirtualFrame::scratch0();
6871 Register scratch2 = VirtualFrame::scratch1();
6872
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00006873 // Check the map. The null map used below is patched by the inline cache
ricow@chromium.org30ce4112010-05-31 10:38:25 +00006874 // code. Therefore we can't use a LoadRoot call.
6875 __ ldr(scratch, FieldMemOperand(receiver, HeapObject::kMapOffset));
6876 __ mov(scratch2, Operand(Factory::null_value()));
6877 __ cmp(scratch, scratch2);
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00006878 deferred->Branch(ne);
6879
ager@chromium.orgbeb25712010-11-29 08:02:25 +00006880 if (is_contextual) {
6881#ifdef DEBUG
6882 InlinedNamedLoadInstructions += 1;
6883#endif
6884 // Load the (initially invalid) cell and get its value.
6885 masm()->mov(receiver, Operand(Factory::null_value()));
6886 __ ldr(receiver,
6887 FieldMemOperand(receiver, JSGlobalPropertyCell::kValueOffset));
6888
6889 deferred->set_is_dont_delete(is_dont_delete);
6890
6891 if (!is_dont_delete) {
6892#ifdef DEBUG
6893 InlinedNamedLoadInstructions += 3;
6894#endif
6895 __ cmp(receiver, Operand(Factory::the_hole_value()));
6896 deferred->Branch(eq);
6897 } else if (FLAG_debug_code) {
6898#ifdef DEBUG
6899 InlinedNamedLoadInstructions += 3;
6900#endif
6901 __ cmp(receiver, Operand(Factory::the_hole_value()));
6902 __ b(&check_the_hole, eq);
6903 __ bind(&cont);
6904 }
6905 } else {
6906 // Initially use an invalid index. The index will be patched by the
6907 // inline cache code.
6908 __ ldr(receiver, MemOperand(receiver, 0));
6909 }
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00006910
6911 // Make sure that the expected number of instructions are generated.
ager@chromium.orgbeb25712010-11-29 08:02:25 +00006912 // If the code before is updated, the offsets in ic-arm.cc
6913 // LoadIC::PatchInlinedContextualLoad and PatchInlinedLoad need
6914 // to be updated.
6915 ASSERT_EQ(InlinedNamedLoadInstructions,
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00006916 masm_->InstructionsGeneratedSince(&check_inlined_codesize));
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00006917 }
6918
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00006919 deferred->BindExit();
ricow@chromium.org30ce4112010-05-31 10:38:25 +00006920 // At this point the receiver register has the result, either from the
6921 // deferred code or from the inlined code.
6922 frame_->EmitPush(receiver);
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00006923 }
6924}
6925
6926
ager@chromium.orgac091b72010-05-05 07:34:42 +00006927void CodeGenerator::EmitNamedStore(Handle<String> name, bool is_contextual) {
6928#ifdef DEBUG
whesse@chromium.orgba5a61b2010-07-26 11:44:40 +00006929 int expected_height = frame()->height() - (is_contextual ? 1 : 2);
ager@chromium.orgac091b72010-05-05 07:34:42 +00006930#endif
ager@chromium.orgac091b72010-05-05 07:34:42 +00006931
whesse@chromium.orgba5a61b2010-07-26 11:44:40 +00006932 Result result;
6933 if (is_contextual || scope()->is_global_scope() || loop_nesting() == 0) {
6934 frame()->CallStoreIC(name, is_contextual);
6935 } else {
6936 // Inline the in-object property case.
6937 JumpTarget slow, done;
6938
6939 // Get the value and receiver from the stack.
6940 frame()->PopToR0();
6941 Register value = r0;
6942 frame()->PopToR1();
6943 Register receiver = r1;
6944
6945 DeferredReferenceSetNamedValue* deferred =
6946 new DeferredReferenceSetNamedValue(value, receiver, name);
6947
6948 // Check that the receiver is a heap object.
6949 __ tst(receiver, Operand(kSmiTagMask));
6950 deferred->Branch(eq);
6951
6952 // The following instructions are the part of the inlined
6953 // in-object property store code which can be patched. Therefore
6954 // the exact number of instructions generated must be fixed, so
6955 // the constant pool is blocked while generating this code.
6956 { Assembler::BlockConstPoolScope block_const_pool(masm_);
6957 Register scratch0 = VirtualFrame::scratch0();
6958 Register scratch1 = VirtualFrame::scratch1();
6959
6960 // Check the map. Initially use an invalid map to force a
6961 // failure. The map check will be patched in the runtime system.
6962 __ ldr(scratch1, FieldMemOperand(receiver, HeapObject::kMapOffset));
6963
6964#ifdef DEBUG
6965 Label check_inlined_codesize;
6966 masm_->bind(&check_inlined_codesize);
6967#endif
6968 __ mov(scratch0, Operand(Factory::null_value()));
6969 __ cmp(scratch0, scratch1);
6970 deferred->Branch(ne);
6971
6972 int offset = 0;
6973 __ str(value, MemOperand(receiver, offset));
6974
6975 // Update the write barrier and record its size. We do not use
6976 // the RecordWrite macro here because we want the offset
6977 // addition instruction first to make it easy to patch.
6978 Label record_write_start, record_write_done;
6979 __ bind(&record_write_start);
6980 // Add offset into the object.
6981 __ add(scratch0, receiver, Operand(offset));
6982 // Test that the object is not in the new space. We cannot set
6983 // region marks for new space pages.
6984 __ InNewSpace(receiver, scratch1, eq, &record_write_done);
6985 // Record the actual write.
6986 __ RecordWriteHelper(receiver, scratch0, scratch1);
6987 __ bind(&record_write_done);
6988 // Clobber all input registers when running with the debug-code flag
6989 // turned on to provoke errors.
6990 if (FLAG_debug_code) {
6991 __ mov(receiver, Operand(BitCast<int32_t>(kZapValue)));
6992 __ mov(scratch0, Operand(BitCast<int32_t>(kZapValue)));
6993 __ mov(scratch1, Operand(BitCast<int32_t>(kZapValue)));
6994 }
6995 // Check that this is the first inlined write barrier or that
6996 // this inlined write barrier has the same size as all the other
6997 // inlined write barriers.
6998 ASSERT((inlined_write_barrier_size_ == -1) ||
6999 (inlined_write_barrier_size_ ==
7000 masm()->InstructionsGeneratedSince(&record_write_start)));
7001 inlined_write_barrier_size_ =
7002 masm()->InstructionsGeneratedSince(&record_write_start);
7003
7004 // Make sure that the expected number of instructions are generated.
7005 ASSERT_EQ(GetInlinedNamedStoreInstructionsAfterPatch(),
7006 masm()->InstructionsGeneratedSince(&check_inlined_codesize));
7007 }
7008 deferred->BindExit();
7009 }
7010 ASSERT_EQ(expected_height, frame()->height());
ager@chromium.orgac091b72010-05-05 07:34:42 +00007011}
7012
7013
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00007014void CodeGenerator::EmitKeyedLoad() {
7015 if (loop_nesting() == 0) {
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00007016 Comment cmnt(masm_, "[ Load from keyed property");
7017 frame_->CallKeyedLoadIC();
7018 } else {
7019 // Inline the keyed load.
7020 Comment cmnt(masm_, "[ Inlined load from keyed property");
7021
7022 // Counter will be decremented in the deferred code. Placed here to avoid
7023 // having it in the instruction stream below where patching will occur.
7024 __ IncrementCounter(&Counters::keyed_load_inline, 1,
7025 frame_->scratch0(), frame_->scratch1());
7026
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +00007027 // Load the key and receiver from the stack.
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00007028 bool key_is_known_smi = frame_->KnownSmiAt(0);
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +00007029 Register key = frame_->PopToRegister();
7030 Register receiver = frame_->PopToRegister(key);
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00007031
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +00007032 // The deferred code expects key and receiver in registers.
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00007033 DeferredReferenceGetKeyedValue* deferred =
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +00007034 new DeferredReferenceGetKeyedValue(key, receiver);
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00007035
7036 // Check that the receiver is a heap object.
7037 __ tst(receiver, Operand(kSmiTagMask));
7038 deferred->Branch(eq);
7039
7040 // The following instructions are the part of the inlined load keyed
7041 // property code which can be patched. Therefore the exact number of
7042 // instructions generated need to be fixed, so the constant pool is blocked
7043 // while generating this code.
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00007044 { Assembler::BlockConstPoolScope block_const_pool(masm_);
7045 Register scratch1 = VirtualFrame::scratch0();
7046 Register scratch2 = VirtualFrame::scratch1();
7047 // Check the map. The null map used below is patched by the inline cache
7048 // code.
7049 __ ldr(scratch1, FieldMemOperand(receiver, HeapObject::kMapOffset));
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00007050
7051 // Check that the key is a smi.
7052 if (!key_is_known_smi) {
7053 __ tst(key, Operand(kSmiTagMask));
7054 deferred->Branch(ne);
7055 }
7056
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +00007057#ifdef DEBUG
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +00007058 Label check_inlined_codesize;
7059 masm_->bind(&check_inlined_codesize);
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +00007060#endif
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00007061 __ mov(scratch2, Operand(Factory::null_value()));
7062 __ cmp(scratch1, scratch2);
7063 deferred->Branch(ne);
7064
ricow@chromium.org0b9f8502010-08-18 07:45:01 +00007065 // Get the elements array from the receiver.
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00007066 __ ldr(scratch1, FieldMemOperand(receiver, JSObject::kElementsOffset));
ricow@chromium.org0b9f8502010-08-18 07:45:01 +00007067 __ AssertFastElements(scratch1);
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00007068
7069 // Check that key is within bounds. Use unsigned comparison to handle
7070 // negative keys.
7071 __ ldr(scratch2, FieldMemOperand(scratch1, FixedArray::kLengthOffset));
ricow@chromium.org30ce4112010-05-31 10:38:25 +00007072 __ cmp(scratch2, key);
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00007073 deferred->Branch(ls); // Unsigned less equal.
7074
7075 // Load and check that the result is not the hole (key is a smi).
7076 __ LoadRoot(scratch2, Heap::kTheHoleValueRootIndex);
7077 __ add(scratch1,
7078 scratch1,
7079 Operand(FixedArray::kHeaderSize - kHeapObjectTag));
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +00007080 __ ldr(scratch1,
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00007081 MemOperand(scratch1, key, LSL,
7082 kPointerSizeLog2 - (kSmiTagSize + kSmiShiftSize)));
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +00007083 __ cmp(scratch1, scratch2);
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00007084 deferred->Branch(eq);
7085
vegorov@chromium.orgdff694e2010-05-17 09:10:26 +00007086 __ mov(r0, scratch1);
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00007087 // Make sure that the expected number of instructions are generated.
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00007088 ASSERT_EQ(GetInlinedKeyedLoadInstructionsAfterPatch(),
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00007089 masm_->InstructionsGeneratedSince(&check_inlined_codesize));
7090 }
7091
7092 deferred->BindExit();
7093 }
7094}
7095
7096
kmillikin@chromium.org69ea3962010-07-05 11:01:40 +00007097void CodeGenerator::EmitKeyedStore(StaticType* key_type,
7098 WriteBarrierCharacter wb_info) {
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00007099 // Generate inlined version of the keyed store if the code is in a loop
7100 // and the key is likely to be a smi.
7101 if (loop_nesting() > 0 && key_type->IsLikelySmi()) {
7102 // Inline the keyed store.
7103 Comment cmnt(masm_, "[ Inlined store to keyed property");
7104
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00007105 Register scratch1 = VirtualFrame::scratch0();
7106 Register scratch2 = VirtualFrame::scratch1();
7107 Register scratch3 = r3;
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00007108
7109 // Counter will be decremented in the deferred code. Placed here to avoid
7110 // having it in the instruction stream below where patching will occur.
7111 __ IncrementCounter(&Counters::keyed_store_inline, 1,
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00007112 scratch1, scratch2);
7113
kmillikin@chromium.org69ea3962010-07-05 11:01:40 +00007114
7115
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00007116 // Load the value, key and receiver from the stack.
kmillikin@chromium.org69ea3962010-07-05 11:01:40 +00007117 bool value_is_harmless = frame_->KnownSmiAt(0);
7118 if (wb_info == NEVER_NEWSPACE) value_is_harmless = true;
7119 bool key_is_smi = frame_->KnownSmiAt(1);
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00007120 Register value = frame_->PopToRegister();
7121 Register key = frame_->PopToRegister(value);
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00007122 VirtualFrame::SpilledScope spilled(frame_);
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00007123 Register receiver = r2;
7124 frame_->EmitPop(receiver);
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00007125
kmillikin@chromium.org69ea3962010-07-05 11:01:40 +00007126#ifdef DEBUG
7127 bool we_remembered_the_write_barrier = value_is_harmless;
7128#endif
7129
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00007130 // The deferred code expects value, key and receiver in registers.
7131 DeferredReferenceSetKeyedValue* deferred =
7132 new DeferredReferenceSetKeyedValue(value, key, receiver);
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00007133
7134 // Check that the value is a smi. As this inlined code does not set the
7135 // write barrier it is only possible to store smi values.
kmillikin@chromium.org69ea3962010-07-05 11:01:40 +00007136 if (!value_is_harmless) {
7137 // If the value is not likely to be a Smi then let's test the fixed array
7138 // for new space instead. See below.
7139 if (wb_info == LIKELY_SMI) {
7140 __ tst(value, Operand(kSmiTagMask));
7141 deferred->Branch(ne);
7142#ifdef DEBUG
7143 we_remembered_the_write_barrier = true;
7144#endif
7145 }
7146 }
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00007147
kmillikin@chromium.org69ea3962010-07-05 11:01:40 +00007148 if (!key_is_smi) {
7149 // Check that the key is a smi.
7150 __ tst(key, Operand(kSmiTagMask));
7151 deferred->Branch(ne);
7152 }
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00007153
7154 // Check that the receiver is a heap object.
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00007155 __ tst(receiver, Operand(kSmiTagMask));
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00007156 deferred->Branch(eq);
7157
7158 // Check that the receiver is a JSArray.
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00007159 __ CompareObjectType(receiver, scratch1, scratch1, JS_ARRAY_TYPE);
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00007160 deferred->Branch(ne);
7161
7162 // Check that the key is within bounds. Both the key and the length of
7163 // the JSArray are smis. Use unsigned comparison to handle negative keys.
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00007164 __ ldr(scratch1, FieldMemOperand(receiver, JSArray::kLengthOffset));
7165 __ cmp(scratch1, key);
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00007166 deferred->Branch(ls); // Unsigned less equal.
7167
kmillikin@chromium.org69ea3962010-07-05 11:01:40 +00007168 // Get the elements array from the receiver.
7169 __ ldr(scratch1, FieldMemOperand(receiver, JSObject::kElementsOffset));
7170 if (!value_is_harmless && wb_info != LIKELY_SMI) {
7171 Label ok;
7172 __ and_(scratch2, scratch1, Operand(ExternalReference::new_space_mask()));
7173 __ cmp(scratch2, Operand(ExternalReference::new_space_start()));
7174 __ tst(value, Operand(kSmiTagMask), ne);
7175 deferred->Branch(ne);
7176#ifdef DEBUG
7177 we_remembered_the_write_barrier = true;
7178#endif
7179 }
7180 // Check that the elements array is not a dictionary.
7181 __ ldr(scratch2, FieldMemOperand(scratch1, JSObject::kMapOffset));
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00007182 // The following instructions are the part of the inlined store keyed
7183 // property code which can be patched. Therefore the exact number of
7184 // instructions generated need to be fixed, so the constant pool is blocked
7185 // while generating this code.
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00007186 { Assembler::BlockConstPoolScope block_const_pool(masm_);
kmillikin@chromium.org69ea3962010-07-05 11:01:40 +00007187#ifdef DEBUG
7188 Label check_inlined_codesize;
7189 masm_->bind(&check_inlined_codesize);
7190#endif
7191
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00007192 // Read the fixed array map from the constant pool (not from the root
7193 // array) so that the value can be patched. When debugging, we patch this
7194 // comparison to always fail so that we will hit the IC call in the
7195 // deferred code which will allow the debugger to break for fast case
7196 // stores.
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00007197 __ mov(scratch3, Operand(Factory::fixed_array_map()));
7198 __ cmp(scratch2, scratch3);
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00007199 deferred->Branch(ne);
7200
7201 // Store the value.
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00007202 __ add(scratch1, scratch1,
7203 Operand(FixedArray::kHeaderSize - kHeapObjectTag));
7204 __ str(value,
7205 MemOperand(scratch1, key, LSL,
7206 kPointerSizeLog2 - (kSmiTagSize + kSmiShiftSize)));
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00007207
7208 // Make sure that the expected number of instructions are generated.
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00007209 ASSERT_EQ(kInlinedKeyedStoreInstructionsAfterPatch,
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00007210 masm_->InstructionsGeneratedSince(&check_inlined_codesize));
7211 }
7212
kmillikin@chromium.org69ea3962010-07-05 11:01:40 +00007213 ASSERT(we_remembered_the_write_barrier);
7214
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00007215 deferred->BindExit();
7216 } else {
7217 frame()->CallKeyedStoreIC();
7218 }
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +00007219}
7220
7221
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00007222#ifdef DEBUG
7223bool CodeGenerator::HasValidEntryRegisters() { return true; }
7224#endif
7225
7226
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00007227#undef __
ager@chromium.org65dad4b2009-04-23 08:48:43 +00007228#define __ ACCESS_MASM(masm)
7229
ager@chromium.org7c537e22008-10-16 08:43:32 +00007230Handle<String> Reference::GetName() {
7231 ASSERT(type_ == NAMED);
7232 Property* property = expression_->AsProperty();
7233 if (property == NULL) {
7234 // Global variable reference treated as a named property reference.
7235 VariableProxy* proxy = expression_->AsVariableProxy();
7236 ASSERT(proxy->AsVariable() != NULL);
7237 ASSERT(proxy->AsVariable()->is_global());
7238 return proxy->name();
7239 } else {
7240 Literal* raw_name = property->key()->AsLiteral();
7241 ASSERT(raw_name != NULL);
7242 return Handle<String>(String::cast(*raw_name->handle()));
7243 }
7244}
kasperl@chromium.org41044eb2008-10-06 08:24:46 +00007245
ager@chromium.org7c537e22008-10-16 08:43:32 +00007246
ricow@chromium.org30ce4112010-05-31 10:38:25 +00007247void Reference::DupIfPersist() {
7248 if (persist_after_get_) {
7249 switch (type_) {
7250 case KEYED:
7251 cgen_->frame()->Dup2();
7252 break;
7253 case NAMED:
7254 cgen_->frame()->Dup();
7255 // Fall through.
7256 case UNLOADED:
7257 case ILLEGAL:
7258 case SLOT:
7259 // Do nothing.
7260 ;
7261 }
7262 } else {
7263 set_unloaded();
7264 }
7265}
7266
7267
ager@chromium.orgc4c92722009-11-18 14:12:51 +00007268void Reference::GetValue() {
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00007269 ASSERT(cgen_->HasValidEntryRegisters());
ager@chromium.org7c537e22008-10-16 08:43:32 +00007270 ASSERT(!is_illegal());
7271 ASSERT(!cgen_->has_cc());
7272 MacroAssembler* masm = cgen_->masm();
7273 Property* property = expression_->AsProperty();
7274 if (property != NULL) {
christian.plesner.hansen@gmail.com37abdec2009-01-06 14:43:28 +00007275 cgen_->CodeForSourcePosition(property->position());
ager@chromium.org7c537e22008-10-16 08:43:32 +00007276 }
7277
7278 switch (type_) {
7279 case SLOT: {
7280 Comment cmnt(masm, "[ Load from Slot");
whesse@chromium.org4a1fe7d2010-09-27 12:32:04 +00007281 Slot* slot = expression_->AsVariableProxy()->AsVariable()->AsSlot();
ager@chromium.org7c537e22008-10-16 08:43:32 +00007282 ASSERT(slot != NULL);
ricow@chromium.org30ce4112010-05-31 10:38:25 +00007283 DupIfPersist();
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00007284 cgen_->LoadFromSlotCheckForArguments(slot, NOT_INSIDE_TYPEOF);
ager@chromium.org7c537e22008-10-16 08:43:32 +00007285 break;
kasperl@chromium.org41044eb2008-10-06 08:24:46 +00007286 }
7287
ager@chromium.org7c537e22008-10-16 08:43:32 +00007288 case NAMED: {
ager@chromium.org7c537e22008-10-16 08:43:32 +00007289 Variable* var = expression_->AsVariableProxy()->AsVariable();
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00007290 bool is_global = var != NULL;
7291 ASSERT(!is_global || var->is_global());
ricow@chromium.org30ce4112010-05-31 10:38:25 +00007292 Handle<String> name = GetName();
7293 DupIfPersist();
7294 cgen_->EmitNamedLoad(name, is_global);
ager@chromium.org7c537e22008-10-16 08:43:32 +00007295 break;
kasperl@chromium.org41044eb2008-10-06 08:24:46 +00007296 }
7297
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +00007298 case KEYED: {
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00007299 ASSERT(property != NULL);
ricow@chromium.org30ce4112010-05-31 10:38:25 +00007300 DupIfPersist();
lrn@chromium.orgc34f5802010-04-28 12:53:43 +00007301 cgen_->EmitKeyedLoad();
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +00007302 cgen_->frame()->EmitPush(r0);
7303 break;
7304 }
7305
kasperl@chromium.org41044eb2008-10-06 08:24:46 +00007306 default:
7307 UNREACHABLE();
kasperl@chromium.org41044eb2008-10-06 08:24:46 +00007308 }
7309}
7310
7311
kmillikin@chromium.org69ea3962010-07-05 11:01:40 +00007312void Reference::SetValue(InitState init_state, WriteBarrierCharacter wb_info) {
ager@chromium.org7c537e22008-10-16 08:43:32 +00007313 ASSERT(!is_illegal());
7314 ASSERT(!cgen_->has_cc());
7315 MacroAssembler* masm = cgen_->masm();
ager@chromium.org3bf7b912008-11-17 09:09:45 +00007316 VirtualFrame* frame = cgen_->frame();
ager@chromium.org7c537e22008-10-16 08:43:32 +00007317 Property* property = expression_->AsProperty();
7318 if (property != NULL) {
christian.plesner.hansen@gmail.com37abdec2009-01-06 14:43:28 +00007319 cgen_->CodeForSourcePosition(property->position());
kasperl@chromium.org41044eb2008-10-06 08:24:46 +00007320 }
kasperl@chromium.org41044eb2008-10-06 08:24:46 +00007321
ager@chromium.org7c537e22008-10-16 08:43:32 +00007322 switch (type_) {
7323 case SLOT: {
7324 Comment cmnt(masm, "[ Store to Slot");
whesse@chromium.org4a1fe7d2010-09-27 12:32:04 +00007325 Slot* slot = expression_->AsVariableProxy()->AsVariable()->AsSlot();
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00007326 cgen_->StoreToSlot(slot, init_state);
ager@chromium.orgac091b72010-05-05 07:34:42 +00007327 set_unloaded();
ager@chromium.org7c537e22008-10-16 08:43:32 +00007328 break;
kasperl@chromium.org41044eb2008-10-06 08:24:46 +00007329 }
7330
ager@chromium.org7c537e22008-10-16 08:43:32 +00007331 case NAMED: {
7332 Comment cmnt(masm, "[ Store to named Property");
ager@chromium.orgac091b72010-05-05 07:34:42 +00007333 cgen_->EmitNamedStore(GetName(), false);
christian.plesner.hansen@gmail.com5a6af922009-08-12 14:20:51 +00007334 frame->EmitPush(r0);
ager@chromium.org5c838252010-02-19 08:53:10 +00007335 set_unloaded();
ager@chromium.org7c537e22008-10-16 08:43:32 +00007336 break;
7337 }
kasperl@chromium.org41044eb2008-10-06 08:24:46 +00007338
ager@chromium.org7c537e22008-10-16 08:43:32 +00007339 case KEYED: {
7340 Comment cmnt(masm, "[ Store to keyed Property");
7341 Property* property = expression_->AsProperty();
7342 ASSERT(property != NULL);
christian.plesner.hansen@gmail.com37abdec2009-01-06 14:43:28 +00007343 cgen_->CodeForSourcePosition(property->position());
kmillikin@chromium.org69ea3962010-07-05 11:01:40 +00007344 cgen_->EmitKeyedStore(property->key()->type(), wb_info);
christian.plesner.hansen@gmail.com5a6af922009-08-12 14:20:51 +00007345 frame->EmitPush(r0);
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00007346 set_unloaded();
ager@chromium.org7c537e22008-10-16 08:43:32 +00007347 break;
kasperl@chromium.org41044eb2008-10-06 08:24:46 +00007348 }
ager@chromium.org7c537e22008-10-16 08:43:32 +00007349
7350 default:
7351 UNREACHABLE();
kasperl@chromium.org41044eb2008-10-06 08:24:46 +00007352 }
7353}
7354
7355
kmillikin@chromium.org13bd2942009-12-16 15:36:05 +00007356const char* GenericBinaryOpStub::GetName() {
7357 if (name_ != NULL) return name_;
7358 const int len = 100;
7359 name_ = Bootstrapper::AllocateAutoDeletedArray(len);
7360 if (name_ == NULL) return "OOM";
7361 const char* op_name = Token::Name(op_);
7362 const char* overwrite_name;
7363 switch (mode_) {
7364 case NO_OVERWRITE: overwrite_name = "Alloc"; break;
7365 case OVERWRITE_RIGHT: overwrite_name = "OverwriteRight"; break;
7366 case OVERWRITE_LEFT: overwrite_name = "OverwriteLeft"; break;
7367 default: overwrite_name = "UnknownOverwrite"; break;
7368 }
7369
7370 OS::SNPrintF(Vector<char>(name_, len),
ricow@chromium.org5ad5ace2010-06-23 09:06:43 +00007371 "GenericBinaryOpStub_%s_%s%s_%s",
kmillikin@chromium.org13bd2942009-12-16 15:36:05 +00007372 op_name,
7373 overwrite_name,
ricow@chromium.org5ad5ace2010-06-23 09:06:43 +00007374 specialized_on_rhs_ ? "_ConstantRhs" : "",
7375 BinaryOpIC::GetName(runtime_operands_type_));
kmillikin@chromium.org13bd2942009-12-16 15:36:05 +00007376 return name_;
7377}
7378
7379
kasperl@chromium.org41044eb2008-10-06 08:24:46 +00007380#undef __
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00007381
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00007382} } // namespace v8::internal
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00007383
7384#endif // V8_TARGET_ARCH_ARM