Initial port of top-level code generator to ARM. For the constant
true at the top level we generate:
0 stmdb sp!, {r1, r8, fp, lr}
4 add fp, sp, #8
8 ldr ip, [r10, #+4]
12 ldr r2, [r10, #+0]
16 str ip, [sp, #-4]!
20 add lr, pc, #4
24 cmp sp, r2
28 ldrcc pc, [pc, #+68] ;; code: STUB, StackCheck, minor: 0
32 ldr ip, [pc, #+68] ;; object: 0xf5bc4161 <true>
36 str ip, [sp, #-4]!
40 ldr ip, [sp, #+0]
44 str ip, [fp, #-12]
48 add sp, sp, #4
52 ldr ip, [fp, #-12]
56 str ip, [sp, #-4]!
60 ldr r0, [sp], #+4
64 mov sp, fp ;; js return
68 ldmia sp!, {fp, lr}
72 add sp, sp, #4
76 bx lr
80 ldr r0, [r10, #+4]
84 mov sp, fp ;; js return
88 ldmia sp!, {fp, lr}
92 add sp, sp, #4
96 bx lr
100 constant pool begin
104 constant
108 constant
Review URL: http://codereview.chromium.org/264067
git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@3073 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2009-10-15 12:42:16 +00:00
|
|
|
// Copyright 2009 the V8 project authors. All rights reserved.
|
|
|
|
// Redistribution and use in source and binary forms, with or without
|
|
|
|
// modification, are permitted provided that the following conditions are
|
|
|
|
// met:
|
|
|
|
//
|
|
|
|
// * Redistributions of source code must retain the above copyright
|
|
|
|
// notice, this list of conditions and the following disclaimer.
|
|
|
|
// * Redistributions in binary form must reproduce the above
|
|
|
|
// copyright notice, this list of conditions and the following
|
|
|
|
// disclaimer in the documentation and/or other materials provided
|
|
|
|
// with the distribution.
|
|
|
|
// * Neither the name of Google Inc. nor the names of its
|
|
|
|
// contributors may be used to endorse or promote products derived
|
|
|
|
// from this software without specific prior written permission.
|
|
|
|
//
|
|
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
|
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
|
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
|
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
|
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
|
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
|
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
|
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
|
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
|
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
|
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
|
|
|
|
#include "v8.h"
|
|
|
|
|
|
|
|
#include "codegen-inl.h"
|
2009-11-04 17:59:24 +00:00
|
|
|
#include "compiler.h"
|
2009-11-04 14:45:50 +00:00
|
|
|
#include "debug.h"
|
Initial port of top-level code generator to ARM. For the constant
true at the top level we generate:
0 stmdb sp!, {r1, r8, fp, lr}
4 add fp, sp, #8
8 ldr ip, [r10, #+4]
12 ldr r2, [r10, #+0]
16 str ip, [sp, #-4]!
20 add lr, pc, #4
24 cmp sp, r2
28 ldrcc pc, [pc, #+68] ;; code: STUB, StackCheck, minor: 0
32 ldr ip, [pc, #+68] ;; object: 0xf5bc4161 <true>
36 str ip, [sp, #-4]!
40 ldr ip, [sp, #+0]
44 str ip, [fp, #-12]
48 add sp, sp, #4
52 ldr ip, [fp, #-12]
56 str ip, [sp, #-4]!
60 ldr r0, [sp], #+4
64 mov sp, fp ;; js return
68 ldmia sp!, {fp, lr}
72 add sp, sp, #4
76 bx lr
80 ldr r0, [r10, #+4]
84 mov sp, fp ;; js return
88 ldmia sp!, {fp, lr}
92 add sp, sp, #4
96 bx lr
100 constant pool begin
104 constant
108 constant
Review URL: http://codereview.chromium.org/264067
git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@3073 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2009-10-15 12:42:16 +00:00
|
|
|
#include "fast-codegen.h"
|
2009-10-22 10:07:45 +00:00
|
|
|
#include "parser.h"
|
Initial port of top-level code generator to ARM. For the constant
true at the top level we generate:
0 stmdb sp!, {r1, r8, fp, lr}
4 add fp, sp, #8
8 ldr ip, [r10, #+4]
12 ldr r2, [r10, #+0]
16 str ip, [sp, #-4]!
20 add lr, pc, #4
24 cmp sp, r2
28 ldrcc pc, [pc, #+68] ;; code: STUB, StackCheck, minor: 0
32 ldr ip, [pc, #+68] ;; object: 0xf5bc4161 <true>
36 str ip, [sp, #-4]!
40 ldr ip, [sp, #+0]
44 str ip, [fp, #-12]
48 add sp, sp, #4
52 ldr ip, [fp, #-12]
56 str ip, [sp, #-4]!
60 ldr r0, [sp], #+4
64 mov sp, fp ;; js return
68 ldmia sp!, {fp, lr}
72 add sp, sp, #4
76 bx lr
80 ldr r0, [r10, #+4]
84 mov sp, fp ;; js return
88 ldmia sp!, {fp, lr}
92 add sp, sp, #4
96 bx lr
100 constant pool begin
104 constant
108 constant
Review URL: http://codereview.chromium.org/264067
git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@3073 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2009-10-15 12:42:16 +00:00
|
|
|
|
|
|
|
namespace v8 {
|
|
|
|
namespace internal {
|
|
|
|
|
|
|
|
#define __ ACCESS_MASM(masm_)
|
|
|
|
|
|
|
|
// Generate code for a JS function. On entry to the function the receiver
|
|
|
|
// and arguments have been pushed on the stack left to right. The actual
|
|
|
|
// argument count matches the formal parameter count expected by the
|
|
|
|
// function.
|
|
|
|
//
|
|
|
|
// The live registers are:
|
|
|
|
// o r1: the JS function object being called (ie, ourselves)
|
|
|
|
// o cp: our context
|
|
|
|
// o fp: our caller's frame pointer
|
|
|
|
// o sp: stack pointer
|
|
|
|
// o lr: return address
|
|
|
|
//
|
|
|
|
// The function builds a JS frame. Please see JavaScriptFrameConstants in
|
|
|
|
// frames-arm.h for its layout.
|
|
|
|
void FastCodeGenerator::Generate(FunctionLiteral* fun) {
|
|
|
|
function_ = fun;
|
2009-11-03 16:08:35 +00:00
|
|
|
SetFunctionPosition(fun);
|
2009-11-12 11:38:01 +00:00
|
|
|
int locals_count = fun->scope()->num_stack_slots();
|
Initial port of top-level code generator to ARM. For the constant
true at the top level we generate:
0 stmdb sp!, {r1, r8, fp, lr}
4 add fp, sp, #8
8 ldr ip, [r10, #+4]
12 ldr r2, [r10, #+0]
16 str ip, [sp, #-4]!
20 add lr, pc, #4
24 cmp sp, r2
28 ldrcc pc, [pc, #+68] ;; code: STUB, StackCheck, minor: 0
32 ldr ip, [pc, #+68] ;; object: 0xf5bc4161 <true>
36 str ip, [sp, #-4]!
40 ldr ip, [sp, #+0]
44 str ip, [fp, #-12]
48 add sp, sp, #4
52 ldr ip, [fp, #-12]
56 str ip, [sp, #-4]!
60 ldr r0, [sp], #+4
64 mov sp, fp ;; js return
68 ldmia sp!, {fp, lr}
72 add sp, sp, #4
76 bx lr
80 ldr r0, [r10, #+4]
84 mov sp, fp ;; js return
88 ldmia sp!, {fp, lr}
92 add sp, sp, #4
96 bx lr
100 constant pool begin
104 constant
108 constant
Review URL: http://codereview.chromium.org/264067
git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@3073 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2009-10-15 12:42:16 +00:00
|
|
|
|
|
|
|
__ stm(db_w, sp, r1.bit() | cp.bit() | fp.bit() | lr.bit());
|
2009-11-12 11:38:01 +00:00
|
|
|
if (locals_count > 0) {
|
|
|
|
// Load undefined value here, so the value is ready for the loop below.
|
|
|
|
__ LoadRoot(ip, Heap::kUndefinedValueRootIndex);
|
|
|
|
}
|
Initial port of top-level code generator to ARM. For the constant
true at the top level we generate:
0 stmdb sp!, {r1, r8, fp, lr}
4 add fp, sp, #8
8 ldr ip, [r10, #+4]
12 ldr r2, [r10, #+0]
16 str ip, [sp, #-4]!
20 add lr, pc, #4
24 cmp sp, r2
28 ldrcc pc, [pc, #+68] ;; code: STUB, StackCheck, minor: 0
32 ldr ip, [pc, #+68] ;; object: 0xf5bc4161 <true>
36 str ip, [sp, #-4]!
40 ldr ip, [sp, #+0]
44 str ip, [fp, #-12]
48 add sp, sp, #4
52 ldr ip, [fp, #-12]
56 str ip, [sp, #-4]!
60 ldr r0, [sp], #+4
64 mov sp, fp ;; js return
68 ldmia sp!, {fp, lr}
72 add sp, sp, #4
76 bx lr
80 ldr r0, [r10, #+4]
84 mov sp, fp ;; js return
88 ldmia sp!, {fp, lr}
92 add sp, sp, #4
96 bx lr
100 constant pool begin
104 constant
108 constant
Review URL: http://codereview.chromium.org/264067
git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@3073 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2009-10-15 12:42:16 +00:00
|
|
|
// Adjust fp to point to caller's fp.
|
|
|
|
__ add(fp, sp, Operand(2 * kPointerSize));
|
|
|
|
|
|
|
|
{ Comment cmnt(masm_, "[ Allocate locals");
|
|
|
|
for (int i = 0; i < locals_count; i++) {
|
|
|
|
__ push(ip);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-11-12 11:38:01 +00:00
|
|
|
bool function_in_register = true;
|
|
|
|
|
2009-11-26 10:28:32 +00:00
|
|
|
// Possibly allocate a local context.
|
|
|
|
if (fun->scope()->num_heap_slots() > 0) {
|
|
|
|
Comment cmnt(masm_, "[ Allocate local context");
|
|
|
|
// Argument to NewContext is the function, which is in r1.
|
|
|
|
__ push(r1);
|
|
|
|
__ CallRuntime(Runtime::kNewContext, 1);
|
|
|
|
function_in_register = false;
|
|
|
|
// Context is returned in both r0 and cp. It replaces the context
|
|
|
|
// passed to us. It's saved in the stack and kept live in cp.
|
|
|
|
__ str(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
|
|
|
|
// Copy any necessary parameters into the context.
|
|
|
|
int num_parameters = fun->scope()->num_parameters();
|
|
|
|
for (int i = 0; i < num_parameters; i++) {
|
|
|
|
Slot* slot = fun->scope()->parameter(i)->slot();
|
|
|
|
if (slot != NULL && slot->type() == Slot::CONTEXT) {
|
|
|
|
int parameter_offset = StandardFrameConstants::kCallerSPOffset +
|
|
|
|
(num_parameters - 1 - i) * kPointerSize;
|
|
|
|
// Load parameter from stack.
|
|
|
|
__ ldr(r0, MemOperand(fp, parameter_offset));
|
|
|
|
// Store it in the context
|
|
|
|
__ str(r0, MemOperand(cp, Context::SlotOffset(slot->index())));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-11-12 11:38:01 +00:00
|
|
|
Variable* arguments = fun->scope()->arguments()->AsVariable();
|
|
|
|
if (arguments != NULL) {
|
|
|
|
// Function uses arguments object.
|
|
|
|
Comment cmnt(masm_, "[ Allocate arguments object");
|
2009-11-26 10:28:32 +00:00
|
|
|
if (!function_in_register) {
|
|
|
|
// Load this again, if it's used by the local context below.
|
|
|
|
__ ldr(r3, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
|
|
|
|
} else {
|
|
|
|
__ mov(r3, r1);
|
|
|
|
}
|
2009-11-12 11:38:01 +00:00
|
|
|
// Receiver is just before the parameters on the caller's stack.
|
|
|
|
__ add(r2, fp, Operand(StandardFrameConstants::kCallerSPOffset +
|
|
|
|
fun->num_parameters() * kPointerSize));
|
|
|
|
__ mov(r1, Operand(Smi::FromInt(fun->num_parameters())));
|
2009-11-26 10:28:32 +00:00
|
|
|
__ stm(db_w, sp, r3.bit() | r2.bit() | r1.bit());
|
2009-11-12 11:38:01 +00:00
|
|
|
|
|
|
|
// Arguments to ArgumentsAccessStub:
|
|
|
|
// function, receiver address, parameter count.
|
|
|
|
// The stub will rewrite receiever and parameter count if the previous
|
|
|
|
// stack frame was an arguments adapter frame.
|
|
|
|
ArgumentsAccessStub stub(ArgumentsAccessStub::NEW_OBJECT);
|
|
|
|
__ CallStub(&stub);
|
2009-11-26 10:28:32 +00:00
|
|
|
// Duplicate the value; move-to-slot operation might clobber registers.
|
|
|
|
__ mov(r3, r0);
|
|
|
|
Move(arguments->slot(), r0, r1, r2);
|
2009-11-12 11:38:01 +00:00
|
|
|
Slot* dot_arguments_slot =
|
|
|
|
fun->scope()->arguments_shadow()->AsVariable()->slot();
|
2009-11-26 10:28:32 +00:00
|
|
|
Move(dot_arguments_slot, r3, r1, r2);
|
2009-11-05 10:38:26 +00:00
|
|
|
}
|
|
|
|
|
2009-10-27 14:56:50 +00:00
|
|
|
// Check the stack for overflow or break request.
|
|
|
|
// Put the lr setup instruction in the delay slot. The kInstrSize is
|
|
|
|
// added to the implicit 8 byte offset that always applies to operations
|
|
|
|
// with pc and gives a return address 12 bytes down.
|
2009-11-13 09:42:18 +00:00
|
|
|
{ Comment cmnt(masm_, "[ Stack check");
|
2009-11-12 11:38:01 +00:00
|
|
|
__ LoadRoot(r2, Heap::kStackLimitRootIndex);
|
2009-10-27 14:56:50 +00:00
|
|
|
__ add(lr, pc, Operand(Assembler::kInstrSize));
|
|
|
|
__ cmp(sp, Operand(r2));
|
|
|
|
StackCheckStub stub;
|
|
|
|
__ mov(pc,
|
|
|
|
Operand(reinterpret_cast<intptr_t>(stub.GetCode().location()),
|
|
|
|
RelocInfo::CODE_TARGET),
|
|
|
|
LeaveCC,
|
|
|
|
lo);
|
2009-11-13 09:42:18 +00:00
|
|
|
}
|
Initial port of top-level code generator to ARM. For the constant
true at the top level we generate:
0 stmdb sp!, {r1, r8, fp, lr}
4 add fp, sp, #8
8 ldr ip, [r10, #+4]
12 ldr r2, [r10, #+0]
16 str ip, [sp, #-4]!
20 add lr, pc, #4
24 cmp sp, r2
28 ldrcc pc, [pc, #+68] ;; code: STUB, StackCheck, minor: 0
32 ldr ip, [pc, #+68] ;; object: 0xf5bc4161 <true>
36 str ip, [sp, #-4]!
40 ldr ip, [sp, #+0]
44 str ip, [fp, #-12]
48 add sp, sp, #4
52 ldr ip, [fp, #-12]
56 str ip, [sp, #-4]!
60 ldr r0, [sp], #+4
64 mov sp, fp ;; js return
68 ldmia sp!, {fp, lr}
72 add sp, sp, #4
76 bx lr
80 ldr r0, [r10, #+4]
84 mov sp, fp ;; js return
88 ldmia sp!, {fp, lr}
92 add sp, sp, #4
96 bx lr
100 constant pool begin
104 constant
108 constant
Review URL: http://codereview.chromium.org/264067
git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@3073 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2009-10-15 12:42:16 +00:00
|
|
|
|
2009-10-21 09:17:39 +00:00
|
|
|
{ Comment cmnt(masm_, "[ Declarations");
|
|
|
|
VisitDeclarations(fun->scope()->declarations());
|
|
|
|
}
|
|
|
|
|
2009-10-22 11:21:29 +00:00
|
|
|
if (FLAG_trace) {
|
|
|
|
__ CallRuntime(Runtime::kTraceEnter, 0);
|
|
|
|
}
|
|
|
|
|
Initial port of top-level code generator to ARM. For the constant
true at the top level we generate:
0 stmdb sp!, {r1, r8, fp, lr}
4 add fp, sp, #8
8 ldr ip, [r10, #+4]
12 ldr r2, [r10, #+0]
16 str ip, [sp, #-4]!
20 add lr, pc, #4
24 cmp sp, r2
28 ldrcc pc, [pc, #+68] ;; code: STUB, StackCheck, minor: 0
32 ldr ip, [pc, #+68] ;; object: 0xf5bc4161 <true>
36 str ip, [sp, #-4]!
40 ldr ip, [sp, #+0]
44 str ip, [fp, #-12]
48 add sp, sp, #4
52 ldr ip, [fp, #-12]
56 str ip, [sp, #-4]!
60 ldr r0, [sp], #+4
64 mov sp, fp ;; js return
68 ldmia sp!, {fp, lr}
72 add sp, sp, #4
76 bx lr
80 ldr r0, [r10, #+4]
84 mov sp, fp ;; js return
88 ldmia sp!, {fp, lr}
92 add sp, sp, #4
96 bx lr
100 constant pool begin
104 constant
108 constant
Review URL: http://codereview.chromium.org/264067
git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@3073 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2009-10-15 12:42:16 +00:00
|
|
|
{ Comment cmnt(masm_, "[ Body");
|
2009-11-03 14:48:59 +00:00
|
|
|
ASSERT(loop_depth() == 0);
|
Initial port of top-level code generator to ARM. For the constant
true at the top level we generate:
0 stmdb sp!, {r1, r8, fp, lr}
4 add fp, sp, #8
8 ldr ip, [r10, #+4]
12 ldr r2, [r10, #+0]
16 str ip, [sp, #-4]!
20 add lr, pc, #4
24 cmp sp, r2
28 ldrcc pc, [pc, #+68] ;; code: STUB, StackCheck, minor: 0
32 ldr ip, [pc, #+68] ;; object: 0xf5bc4161 <true>
36 str ip, [sp, #-4]!
40 ldr ip, [sp, #+0]
44 str ip, [fp, #-12]
48 add sp, sp, #4
52 ldr ip, [fp, #-12]
56 str ip, [sp, #-4]!
60 ldr r0, [sp], #+4
64 mov sp, fp ;; js return
68 ldmia sp!, {fp, lr}
72 add sp, sp, #4
76 bx lr
80 ldr r0, [r10, #+4]
84 mov sp, fp ;; js return
88 ldmia sp!, {fp, lr}
92 add sp, sp, #4
96 bx lr
100 constant pool begin
104 constant
108 constant
Review URL: http://codereview.chromium.org/264067
git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@3073 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2009-10-15 12:42:16 +00:00
|
|
|
VisitStatements(fun->body());
|
2009-11-03 14:48:59 +00:00
|
|
|
ASSERT(loop_depth() == 0);
|
Initial port of top-level code generator to ARM. For the constant
true at the top level we generate:
0 stmdb sp!, {r1, r8, fp, lr}
4 add fp, sp, #8
8 ldr ip, [r10, #+4]
12 ldr r2, [r10, #+0]
16 str ip, [sp, #-4]!
20 add lr, pc, #4
24 cmp sp, r2
28 ldrcc pc, [pc, #+68] ;; code: STUB, StackCheck, minor: 0
32 ldr ip, [pc, #+68] ;; object: 0xf5bc4161 <true>
36 str ip, [sp, #-4]!
40 ldr ip, [sp, #+0]
44 str ip, [fp, #-12]
48 add sp, sp, #4
52 ldr ip, [fp, #-12]
56 str ip, [sp, #-4]!
60 ldr r0, [sp], #+4
64 mov sp, fp ;; js return
68 ldmia sp!, {fp, lr}
72 add sp, sp, #4
76 bx lr
80 ldr r0, [r10, #+4]
84 mov sp, fp ;; js return
88 ldmia sp!, {fp, lr}
92 add sp, sp, #4
96 bx lr
100 constant pool begin
104 constant
108 constant
Review URL: http://codereview.chromium.org/264067
git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@3073 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2009-10-15 12:42:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
{ Comment cmnt(masm_, "[ return <undefined>;");
|
|
|
|
// Emit a 'return undefined' in case control fell off the end of the
|
|
|
|
// body.
|
|
|
|
__ LoadRoot(r0, Heap::kUndefinedValueRootIndex);
|
2009-10-30 10:22:31 +00:00
|
|
|
}
|
2009-11-04 14:11:39 +00:00
|
|
|
EmitReturnSequence(function_->end_position());
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void FastCodeGenerator::EmitReturnSequence(int position) {
|
|
|
|
Comment cmnt(masm_, "[ Return sequence");
|
|
|
|
if (return_label_.is_bound()) {
|
|
|
|
__ b(&return_label_);
|
|
|
|
} else {
|
|
|
|
__ bind(&return_label_);
|
|
|
|
if (FLAG_trace) {
|
|
|
|
// Push the return value on the stack as the parameter.
|
|
|
|
// Runtime::TraceExit returns its parameter in r0.
|
|
|
|
__ push(r0);
|
|
|
|
__ CallRuntime(Runtime::kTraceExit, 1);
|
2009-10-22 11:21:29 +00:00
|
|
|
}
|
2009-11-04 14:45:50 +00:00
|
|
|
|
2009-11-04 14:11:39 +00:00
|
|
|
// Add a label for checking the size of the code used for returning.
|
|
|
|
Label check_exit_codesize;
|
|
|
|
masm_->bind(&check_exit_codesize);
|
2009-11-04 14:45:50 +00:00
|
|
|
|
|
|
|
// Calculate the exact length of the return sequence and make sure that
|
|
|
|
// the constant pool is not emitted inside of the return sequence.
|
|
|
|
int num_parameters = function_->scope()->num_parameters();
|
|
|
|
int32_t sp_delta = (num_parameters + 1) * kPointerSize;
|
2009-11-30 15:09:49 +00:00
|
|
|
int return_sequence_length = Assembler::kJSReturnSequenceLength;
|
2009-11-04 14:45:50 +00:00
|
|
|
if (!masm_->ImmediateFitsAddrMode1Instruction(sp_delta)) {
|
|
|
|
// Additional mov instruction generated.
|
|
|
|
return_sequence_length++;
|
|
|
|
}
|
|
|
|
masm_->BlockConstPoolFor(return_sequence_length);
|
|
|
|
|
2009-11-04 14:11:39 +00:00
|
|
|
CodeGenerator::RecordPositions(masm_, position);
|
|
|
|
__ RecordJSReturn();
|
|
|
|
__ mov(sp, fp);
|
|
|
|
__ ldm(ia_w, sp, fp.bit() | lr.bit());
|
2009-11-04 14:45:50 +00:00
|
|
|
__ add(sp, sp, Operand(sp_delta));
|
2009-11-04 14:11:39 +00:00
|
|
|
__ Jump(lr);
|
2009-11-04 14:45:50 +00:00
|
|
|
|
2009-11-04 15:24:11 +00:00
|
|
|
// Check that the size of the code used for returning matches what is
|
|
|
|
// expected by the debugger. The add instruction above is an addressing
|
|
|
|
// mode 1 instruction where there are restrictions on which immediate values
|
|
|
|
// can be encoded in the instruction and which immediate values requires
|
|
|
|
// use of an additional instruction for moving the immediate to a temporary
|
|
|
|
// register.
|
|
|
|
ASSERT_EQ(return_sequence_length,
|
|
|
|
masm_->InstructionsGeneratedSince(&check_exit_codesize));
|
2009-11-04 14:33:37 +00:00
|
|
|
}
|
Initial port of top-level code generator to ARM. For the constant
true at the top level we generate:
0 stmdb sp!, {r1, r8, fp, lr}
4 add fp, sp, #8
8 ldr ip, [r10, #+4]
12 ldr r2, [r10, #+0]
16 str ip, [sp, #-4]!
20 add lr, pc, #4
24 cmp sp, r2
28 ldrcc pc, [pc, #+68] ;; code: STUB, StackCheck, minor: 0
32 ldr ip, [pc, #+68] ;; object: 0xf5bc4161 <true>
36 str ip, [sp, #-4]!
40 ldr ip, [sp, #+0]
44 str ip, [fp, #-12]
48 add sp, sp, #4
52 ldr ip, [fp, #-12]
56 str ip, [sp, #-4]!
60 ldr r0, [sp], #+4
64 mov sp, fp ;; js return
68 ldmia sp!, {fp, lr}
72 add sp, sp, #4
76 bx lr
80 ldr r0, [r10, #+4]
84 mov sp, fp ;; js return
88 ldmia sp!, {fp, lr}
92 add sp, sp, #4
96 bx lr
100 constant pool begin
104 constant
108 constant
Review URL: http://codereview.chromium.org/264067
git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@3073 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2009-10-15 12:42:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
Initial implementation of top-level compilation of expressions in test
context. Test contexts are used for the left subexpressions of
short-circuited boolean operators. The right subexpressions inherit
their expression context from the binary op expression.
Compilation of short-circuited operations in effect and test context
is straightforward:
effect(e0 || e1) =
test(e0, L0, L1)
L1: effect(e1)
L0:
test(e0 || e1, L0, L1) =
test(e0, L0, L2)
L2: test(e1, L0, L1)
Because the value of the first subexpression may be needed as the
value of the whole expression in a value context, we introduce a
hybrid value/test contest (the value is needed if true, but not if
false).
value(e0 || e1) =
value/test(e0, L0, L1)
L1: value(e1)
L0:
The compilation of value/test and test/value (introduced by boolean
AND) is:
value/test(e0 || e1, L0, L1) =
value/test(e0, L0, L2)
L2: value/test(e1, L0, L1)
test/value(e0 || e1, L0, L1) =
test(e0, L0, L2)
L2: test/value(e1, L0, L1)
Boolean AND is the dual. The AST nodes themselves (not their parents)
are responsible for producing the proper result (effect, value, or
control flow) depending on their context.
Review URL: http://codereview.chromium.org/339082
git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@3187 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2009-10-30 14:06:48 +00:00
|
|
|
void FastCodeGenerator::Move(Expression::Context context, Register source) {
|
2009-10-30 08:36:46 +00:00
|
|
|
switch (context) {
|
|
|
|
case Expression::kUninitialized:
|
2009-10-29 10:35:29 +00:00
|
|
|
UNREACHABLE();
|
2009-10-30 08:36:46 +00:00
|
|
|
case Expression::kEffect:
|
2009-10-27 13:38:57 +00:00
|
|
|
break;
|
2009-10-30 08:36:46 +00:00
|
|
|
case Expression::kValue:
|
Initial implementation of top-level compilation of expressions in test
context. Test contexts are used for the left subexpressions of
short-circuited boolean operators. The right subexpressions inherit
their expression context from the binary op expression.
Compilation of short-circuited operations in effect and test context
is straightforward:
effect(e0 || e1) =
test(e0, L0, L1)
L1: effect(e1)
L0:
test(e0 || e1, L0, L1) =
test(e0, L0, L2)
L2: test(e1, L0, L1)
Because the value of the first subexpression may be needed as the
value of the whole expression in a value context, we introduce a
hybrid value/test contest (the value is needed if true, but not if
false).
value(e0 || e1) =
value/test(e0, L0, L1)
L1: value(e1)
L0:
The compilation of value/test and test/value (introduced by boolean
AND) is:
value/test(e0 || e1, L0, L1) =
value/test(e0, L0, L2)
L2: value/test(e1, L0, L1)
test/value(e0 || e1, L0, L1) =
test(e0, L0, L2)
L2: test/value(e1, L0, L1)
Boolean AND is the dual. The AST nodes themselves (not their parents)
are responsible for producing the proper result (effect, value, or
control flow) depending on their context.
Review URL: http://codereview.chromium.org/339082
git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@3187 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2009-10-30 14:06:48 +00:00
|
|
|
__ push(source);
|
|
|
|
break;
|
|
|
|
case Expression::kTest:
|
|
|
|
TestAndBranch(source, true_label_, false_label_);
|
|
|
|
break;
|
|
|
|
case Expression::kValueTest: {
|
|
|
|
Label discard;
|
|
|
|
__ push(source);
|
|
|
|
TestAndBranch(source, true_label_, &discard);
|
|
|
|
__ bind(&discard);
|
|
|
|
__ pop();
|
|
|
|
__ jmp(false_label_);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case Expression::kTestValue: {
|
|
|
|
Label discard;
|
|
|
|
__ push(source);
|
|
|
|
TestAndBranch(source, &discard, false_label_);
|
|
|
|
__ bind(&discard);
|
|
|
|
__ pop();
|
|
|
|
__ jmp(true_label_);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-01-04 13:56:31 +00:00
|
|
|
void FastCodeGenerator::MoveTOS(Expression::Context context) {
|
|
|
|
switch (context) {
|
|
|
|
case Expression::kUninitialized:
|
|
|
|
UNREACHABLE();
|
|
|
|
case Expression::kEffect:
|
|
|
|
__ Drop(1);
|
|
|
|
break;
|
|
|
|
case Expression::kValue:
|
|
|
|
break;
|
|
|
|
case Expression::kTest:
|
|
|
|
__ pop(r0);
|
|
|
|
TestAndBranch(r0, true_label_, false_label_);
|
|
|
|
break;
|
|
|
|
case Expression::kValueTest: {
|
|
|
|
Label discard;
|
|
|
|
__ ldr(r0, MemOperand(sp, 0));
|
|
|
|
TestAndBranch(r0, true_label_, &discard);
|
|
|
|
__ bind(&discard);
|
|
|
|
__ Drop(1);
|
|
|
|
__ jmp(false_label_);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case Expression::kTestValue: {
|
|
|
|
Label discard;
|
|
|
|
__ ldr(r0, MemOperand(sp, 0));
|
|
|
|
TestAndBranch(r0, &discard, false_label_);
|
|
|
|
__ bind(&discard);
|
|
|
|
__ Drop(1);
|
|
|
|
__ jmp(true_label_);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-11-26 10:28:32 +00:00
|
|
|
template <>
|
|
|
|
MemOperand FastCodeGenerator::CreateSlotOperand<MemOperand>(
|
|
|
|
Slot* source,
|
|
|
|
Register scratch) {
|
|
|
|
switch (source->type()) {
|
|
|
|
case Slot::PARAMETER:
|
|
|
|
case Slot::LOCAL:
|
|
|
|
return MemOperand(fp, SlotOffset(source));
|
|
|
|
case Slot::CONTEXT: {
|
|
|
|
int context_chain_length =
|
|
|
|
function_->scope()->ContextChainLength(source->var()->scope());
|
|
|
|
__ LoadContext(scratch, context_chain_length);
|
|
|
|
return CodeGenerator::ContextOperand(scratch, source->index());
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case Slot::LOOKUP:
|
|
|
|
UNIMPLEMENTED();
|
|
|
|
// Fall-through.
|
|
|
|
default:
|
|
|
|
UNREACHABLE();
|
|
|
|
return MemOperand(r0, 0); // Dead code to make the compiler happy.
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void FastCodeGenerator::Move(Register dst, Slot* source) {
|
|
|
|
// Use dst as scratch.
|
|
|
|
MemOperand location = CreateSlotOperand<MemOperand>(source, dst);
|
|
|
|
__ ldr(dst, location);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void FastCodeGenerator::Move(Expression::Context context,
|
|
|
|
Slot* source,
|
|
|
|
Register scratch) {
|
Initial implementation of top-level compilation of expressions in test
context. Test contexts are used for the left subexpressions of
short-circuited boolean operators. The right subexpressions inherit
their expression context from the binary op expression.
Compilation of short-circuited operations in effect and test context
is straightforward:
effect(e0 || e1) =
test(e0, L0, L1)
L1: effect(e1)
L0:
test(e0 || e1, L0, L1) =
test(e0, L0, L2)
L2: test(e1, L0, L1)
Because the value of the first subexpression may be needed as the
value of the whole expression in a value context, we introduce a
hybrid value/test contest (the value is needed if true, but not if
false).
value(e0 || e1) =
value/test(e0, L0, L1)
L1: value(e1)
L0:
The compilation of value/test and test/value (introduced by boolean
AND) is:
value/test(e0 || e1, L0, L1) =
value/test(e0, L0, L2)
L2: value/test(e1, L0, L1)
test/value(e0 || e1, L0, L1) =
test(e0, L0, L2)
L2: test/value(e1, L0, L1)
Boolean AND is the dual. The AST nodes themselves (not their parents)
are responsible for producing the proper result (effect, value, or
control flow) depending on their context.
Review URL: http://codereview.chromium.org/339082
git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@3187 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2009-10-30 14:06:48 +00:00
|
|
|
switch (context) {
|
|
|
|
case Expression::kUninitialized:
|
|
|
|
UNREACHABLE();
|
|
|
|
case Expression::kEffect:
|
|
|
|
break;
|
|
|
|
case Expression::kValue: // Fall through.
|
|
|
|
case Expression::kTest: // Fall through.
|
|
|
|
case Expression::kValueTest: // Fall through.
|
|
|
|
case Expression::kTestValue:
|
2009-11-26 10:28:32 +00:00
|
|
|
Move(scratch, source);
|
|
|
|
Move(context, scratch);
|
2009-10-27 13:38:57 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-10-30 08:36:46 +00:00
|
|
|
void FastCodeGenerator::Move(Expression::Context context, Literal* expr) {
|
|
|
|
switch (context) {
|
|
|
|
case Expression::kUninitialized:
|
2009-10-29 10:35:29 +00:00
|
|
|
UNREACHABLE();
|
2009-10-30 08:36:46 +00:00
|
|
|
case Expression::kEffect:
|
2009-10-27 13:38:57 +00:00
|
|
|
break;
|
Initial implementation of top-level compilation of expressions in test
context. Test contexts are used for the left subexpressions of
short-circuited boolean operators. The right subexpressions inherit
their expression context from the binary op expression.
Compilation of short-circuited operations in effect and test context
is straightforward:
effect(e0 || e1) =
test(e0, L0, L1)
L1: effect(e1)
L0:
test(e0 || e1, L0, L1) =
test(e0, L0, L2)
L2: test(e1, L0, L1)
Because the value of the first subexpression may be needed as the
value of the whole expression in a value context, we introduce a
hybrid value/test contest (the value is needed if true, but not if
false).
value(e0 || e1) =
value/test(e0, L0, L1)
L1: value(e1)
L0:
The compilation of value/test and test/value (introduced by boolean
AND) is:
value/test(e0 || e1, L0, L1) =
value/test(e0, L0, L2)
L2: value/test(e1, L0, L1)
test/value(e0 || e1, L0, L1) =
test(e0, L0, L2)
L2: test/value(e1, L0, L1)
Boolean AND is the dual. The AST nodes themselves (not their parents)
are responsible for producing the proper result (effect, value, or
control flow) depending on their context.
Review URL: http://codereview.chromium.org/339082
git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@3187 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2009-10-30 14:06:48 +00:00
|
|
|
case Expression::kValue: // Fall through.
|
|
|
|
case Expression::kTest: // Fall through.
|
|
|
|
case Expression::kValueTest: // Fall through.
|
|
|
|
case Expression::kTestValue:
|
2009-10-27 13:38:57 +00:00
|
|
|
__ mov(ip, Operand(expr->handle()));
|
Initial implementation of top-level compilation of expressions in test
context. Test contexts are used for the left subexpressions of
short-circuited boolean operators. The right subexpressions inherit
their expression context from the binary op expression.
Compilation of short-circuited operations in effect and test context
is straightforward:
effect(e0 || e1) =
test(e0, L0, L1)
L1: effect(e1)
L0:
test(e0 || e1, L0, L1) =
test(e0, L0, L2)
L2: test(e1, L0, L1)
Because the value of the first subexpression may be needed as the
value of the whole expression in a value context, we introduce a
hybrid value/test contest (the value is needed if true, but not if
false).
value(e0 || e1) =
value/test(e0, L0, L1)
L1: value(e1)
L0:
The compilation of value/test and test/value (introduced by boolean
AND) is:
value/test(e0 || e1, L0, L1) =
value/test(e0, L0, L2)
L2: value/test(e1, L0, L1)
test/value(e0 || e1, L0, L1) =
test(e0, L0, L2)
L2: test/value(e1, L0, L1)
Boolean AND is the dual. The AST nodes themselves (not their parents)
are responsible for producing the proper result (effect, value, or
control flow) depending on their context.
Review URL: http://codereview.chromium.org/339082
git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@3187 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2009-10-30 14:06:48 +00:00
|
|
|
Move(context, ip);
|
2009-10-27 13:38:57 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-11-26 10:28:32 +00:00
|
|
|
void FastCodeGenerator::Move(Slot* dst,
|
|
|
|
Register src,
|
|
|
|
Register scratch1,
|
|
|
|
Register scratch2) {
|
|
|
|
switch (dst->type()) {
|
|
|
|
case Slot::PARAMETER:
|
|
|
|
case Slot::LOCAL:
|
|
|
|
__ str(src, MemOperand(fp, SlotOffset(dst)));
|
|
|
|
break;
|
|
|
|
case Slot::CONTEXT: {
|
|
|
|
int context_chain_length =
|
|
|
|
function_->scope()->ContextChainLength(dst->var()->scope());
|
|
|
|
__ LoadContext(scratch1, context_chain_length);
|
|
|
|
int index = Context::SlotOffset(dst->index());
|
|
|
|
__ mov(scratch2, Operand(index));
|
|
|
|
__ str(src, MemOperand(scratch1, index));
|
|
|
|
__ RecordWrite(scratch1, scratch2, src);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case Slot::LOOKUP:
|
|
|
|
UNIMPLEMENTED();
|
|
|
|
default:
|
|
|
|
UNREACHABLE();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2009-10-30 08:36:46 +00:00
|
|
|
void FastCodeGenerator::DropAndMove(Expression::Context context,
|
2009-11-26 10:28:32 +00:00
|
|
|
Register source,
|
|
|
|
int drop_count) {
|
|
|
|
ASSERT(drop_count > 0);
|
2009-10-30 08:36:46 +00:00
|
|
|
switch (context) {
|
|
|
|
case Expression::kUninitialized:
|
2009-10-27 13:38:57 +00:00
|
|
|
UNREACHABLE();
|
2009-10-30 08:36:46 +00:00
|
|
|
case Expression::kEffect:
|
2009-11-26 10:28:32 +00:00
|
|
|
__ add(sp, sp, Operand(drop_count * kPointerSize));
|
2009-10-28 09:56:14 +00:00
|
|
|
break;
|
2009-10-30 08:36:46 +00:00
|
|
|
case Expression::kValue:
|
2009-11-26 10:28:32 +00:00
|
|
|
if (drop_count > 1) {
|
|
|
|
__ add(sp, sp, Operand((drop_count - 1) * kPointerSize));
|
|
|
|
}
|
2009-10-28 09:56:14 +00:00
|
|
|
__ str(source, MemOperand(sp));
|
|
|
|
break;
|
Initial implementation of top-level compilation of expressions in test
context. Test contexts are used for the left subexpressions of
short-circuited boolean operators. The right subexpressions inherit
their expression context from the binary op expression.
Compilation of short-circuited operations in effect and test context
is straightforward:
effect(e0 || e1) =
test(e0, L0, L1)
L1: effect(e1)
L0:
test(e0 || e1, L0, L1) =
test(e0, L0, L2)
L2: test(e1, L0, L1)
Because the value of the first subexpression may be needed as the
value of the whole expression in a value context, we introduce a
hybrid value/test contest (the value is needed if true, but not if
false).
value(e0 || e1) =
value/test(e0, L0, L1)
L1: value(e1)
L0:
The compilation of value/test and test/value (introduced by boolean
AND) is:
value/test(e0 || e1, L0, L1) =
value/test(e0, L0, L2)
L2: value/test(e1, L0, L1)
test/value(e0 || e1, L0, L1) =
test(e0, L0, L2)
L2: test/value(e1, L0, L1)
Boolean AND is the dual. The AST nodes themselves (not their parents)
are responsible for producing the proper result (effect, value, or
control flow) depending on their context.
Review URL: http://codereview.chromium.org/339082
git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@3187 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2009-10-30 14:06:48 +00:00
|
|
|
case Expression::kTest:
|
|
|
|
ASSERT(!source.is(sp));
|
2009-11-26 10:28:32 +00:00
|
|
|
__ add(sp, sp, Operand(drop_count * kPointerSize));
|
Initial implementation of top-level compilation of expressions in test
context. Test contexts are used for the left subexpressions of
short-circuited boolean operators. The right subexpressions inherit
their expression context from the binary op expression.
Compilation of short-circuited operations in effect and test context
is straightforward:
effect(e0 || e1) =
test(e0, L0, L1)
L1: effect(e1)
L0:
test(e0 || e1, L0, L1) =
test(e0, L0, L2)
L2: test(e1, L0, L1)
Because the value of the first subexpression may be needed as the
value of the whole expression in a value context, we introduce a
hybrid value/test contest (the value is needed if true, but not if
false).
value(e0 || e1) =
value/test(e0, L0, L1)
L1: value(e1)
L0:
The compilation of value/test and test/value (introduced by boolean
AND) is:
value/test(e0 || e1, L0, L1) =
value/test(e0, L0, L2)
L2: value/test(e1, L0, L1)
test/value(e0 || e1, L0, L1) =
test(e0, L0, L2)
L2: test/value(e1, L0, L1)
Boolean AND is the dual. The AST nodes themselves (not their parents)
are responsible for producing the proper result (effect, value, or
control flow) depending on their context.
Review URL: http://codereview.chromium.org/339082
git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@3187 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2009-10-30 14:06:48 +00:00
|
|
|
TestAndBranch(source, true_label_, false_label_);
|
|
|
|
break;
|
|
|
|
case Expression::kValueTest: {
|
|
|
|
Label discard;
|
2009-11-26 10:28:32 +00:00
|
|
|
if (drop_count > 1) {
|
|
|
|
__ add(sp, sp, Operand((drop_count - 1) * kPointerSize));
|
|
|
|
}
|
Initial implementation of top-level compilation of expressions in test
context. Test contexts are used for the left subexpressions of
short-circuited boolean operators. The right subexpressions inherit
their expression context from the binary op expression.
Compilation of short-circuited operations in effect and test context
is straightforward:
effect(e0 || e1) =
test(e0, L0, L1)
L1: effect(e1)
L0:
test(e0 || e1, L0, L1) =
test(e0, L0, L2)
L2: test(e1, L0, L1)
Because the value of the first subexpression may be needed as the
value of the whole expression in a value context, we introduce a
hybrid value/test contest (the value is needed if true, but not if
false).
value(e0 || e1) =
value/test(e0, L0, L1)
L1: value(e1)
L0:
The compilation of value/test and test/value (introduced by boolean
AND) is:
value/test(e0 || e1, L0, L1) =
value/test(e0, L0, L2)
L2: value/test(e1, L0, L1)
test/value(e0 || e1, L0, L1) =
test(e0, L0, L2)
L2: test/value(e1, L0, L1)
Boolean AND is the dual. The AST nodes themselves (not their parents)
are responsible for producing the proper result (effect, value, or
control flow) depending on their context.
Review URL: http://codereview.chromium.org/339082
git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@3187 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2009-10-30 14:06:48 +00:00
|
|
|
__ str(source, MemOperand(sp));
|
|
|
|
TestAndBranch(source, true_label_, &discard);
|
|
|
|
__ bind(&discard);
|
|
|
|
__ pop();
|
|
|
|
__ jmp(false_label_);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case Expression::kTestValue: {
|
|
|
|
Label discard;
|
2009-11-26 10:28:32 +00:00
|
|
|
if (drop_count > 1) {
|
|
|
|
__ add(sp, sp, Operand((drop_count - 1) * kPointerSize));
|
|
|
|
}
|
Initial implementation of top-level compilation of expressions in test
context. Test contexts are used for the left subexpressions of
short-circuited boolean operators. The right subexpressions inherit
their expression context from the binary op expression.
Compilation of short-circuited operations in effect and test context
is straightforward:
effect(e0 || e1) =
test(e0, L0, L1)
L1: effect(e1)
L0:
test(e0 || e1, L0, L1) =
test(e0, L0, L2)
L2: test(e1, L0, L1)
Because the value of the first subexpression may be needed as the
value of the whole expression in a value context, we introduce a
hybrid value/test contest (the value is needed if true, but not if
false).
value(e0 || e1) =
value/test(e0, L0, L1)
L1: value(e1)
L0:
The compilation of value/test and test/value (introduced by boolean
AND) is:
value/test(e0 || e1, L0, L1) =
value/test(e0, L0, L2)
L2: value/test(e1, L0, L1)
test/value(e0 || e1, L0, L1) =
test(e0, L0, L2)
L2: test/value(e1, L0, L1)
Boolean AND is the dual. The AST nodes themselves (not their parents)
are responsible for producing the proper result (effect, value, or
control flow) depending on their context.
Review URL: http://codereview.chromium.org/339082
git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@3187 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2009-10-30 14:06:48 +00:00
|
|
|
__ str(source, MemOperand(sp));
|
|
|
|
TestAndBranch(source, &discard, false_label_);
|
|
|
|
__ bind(&discard);
|
|
|
|
__ pop();
|
|
|
|
__ jmp(true_label_);
|
|
|
|
break;
|
|
|
|
}
|
2009-10-28 09:56:14 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
Initial implementation of top-level compilation of expressions in test
context. Test contexts are used for the left subexpressions of
short-circuited boolean operators. The right subexpressions inherit
their expression context from the binary op expression.
Compilation of short-circuited operations in effect and test context
is straightforward:
effect(e0 || e1) =
test(e0, L0, L1)
L1: effect(e1)
L0:
test(e0 || e1, L0, L1) =
test(e0, L0, L2)
L2: test(e1, L0, L1)
Because the value of the first subexpression may be needed as the
value of the whole expression in a value context, we introduce a
hybrid value/test contest (the value is needed if true, but not if
false).
value(e0 || e1) =
value/test(e0, L0, L1)
L1: value(e1)
L0:
The compilation of value/test and test/value (introduced by boolean
AND) is:
value/test(e0 || e1, L0, L1) =
value/test(e0, L0, L2)
L2: value/test(e1, L0, L1)
test/value(e0 || e1, L0, L1) =
test(e0, L0, L2)
L2: test/value(e1, L0, L1)
Boolean AND is the dual. The AST nodes themselves (not their parents)
are responsible for producing the proper result (effect, value, or
control flow) depending on their context.
Review URL: http://codereview.chromium.org/339082
git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@3187 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2009-10-30 14:06:48 +00:00
|
|
|
void FastCodeGenerator::TestAndBranch(Register source,
|
|
|
|
Label* true_label,
|
|
|
|
Label* false_label) {
|
|
|
|
ASSERT_NE(NULL, true_label);
|
|
|
|
ASSERT_NE(NULL, false_label);
|
|
|
|
// Call the runtime to find the boolean value of the source and then
|
|
|
|
// translate it into control flow to the pair of labels.
|
|
|
|
__ push(source);
|
|
|
|
__ CallRuntime(Runtime::kToBool, 1);
|
|
|
|
__ LoadRoot(ip, Heap::kTrueValueRootIndex);
|
|
|
|
__ cmp(r0, ip);
|
|
|
|
__ b(eq, true_label);
|
|
|
|
__ jmp(false_label);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-11-05 17:33:50 +00:00
|
|
|
void FastCodeGenerator::VisitDeclaration(Declaration* decl) {
|
2009-11-13 09:42:18 +00:00
|
|
|
Comment cmnt(masm_, "[ Declaration");
|
2009-11-05 17:33:50 +00:00
|
|
|
Variable* var = decl->proxy()->var();
|
|
|
|
ASSERT(var != NULL); // Must have been resolved.
|
|
|
|
Slot* slot = var->slot();
|
2009-12-07 13:31:47 +00:00
|
|
|
Property* prop = var->AsProperty();
|
|
|
|
|
|
|
|
if (slot != NULL) {
|
|
|
|
switch (slot->type()) {
|
|
|
|
case Slot::PARAMETER: // Fall through.
|
|
|
|
case Slot::LOCAL:
|
|
|
|
if (decl->mode() == Variable::CONST) {
|
|
|
|
__ LoadRoot(ip, Heap::kTheHoleValueRootIndex);
|
|
|
|
__ str(ip, MemOperand(fp, SlotOffset(var->slot())));
|
|
|
|
} else if (decl->fun() != NULL) {
|
|
|
|
Visit(decl->fun());
|
|
|
|
__ pop(ip);
|
|
|
|
__ str(ip, MemOperand(fp, SlotOffset(var->slot())));
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case Slot::CONTEXT:
|
|
|
|
// The variable in the decl always resides in the current context.
|
|
|
|
ASSERT_EQ(0, function_->scope()->ContextChainLength(var->scope()));
|
2009-11-05 17:33:50 +00:00
|
|
|
if (FLAG_debug_code) {
|
|
|
|
// Check if we have the correct context pointer.
|
2009-12-07 13:31:47 +00:00
|
|
|
__ ldr(r1,
|
|
|
|
CodeGenerator::ContextOperand(cp, Context::FCONTEXT_INDEX));
|
2009-11-05 17:33:50 +00:00
|
|
|
__ cmp(r1, cp);
|
|
|
|
__ Check(eq, "Unexpected declaration in current context.");
|
|
|
|
}
|
2009-12-07 13:31:47 +00:00
|
|
|
if (decl->mode() == Variable::CONST) {
|
|
|
|
__ LoadRoot(ip, Heap::kTheHoleValueRootIndex);
|
|
|
|
__ str(ip, CodeGenerator::ContextOperand(cp, slot->index()));
|
|
|
|
// No write barrier since the_hole_value is in old space.
|
|
|
|
} else if (decl->fun() != NULL) {
|
|
|
|
Visit(decl->fun());
|
|
|
|
__ pop(r0);
|
|
|
|
__ str(r0, CodeGenerator::ContextOperand(cp, slot->index()));
|
|
|
|
int offset = Context::SlotOffset(slot->index());
|
|
|
|
__ mov(r2, Operand(offset));
|
|
|
|
// We know that we have written a function, which is not a smi.
|
|
|
|
__ RecordWrite(cp, r2, r0);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case Slot::LOOKUP: {
|
|
|
|
__ mov(r2, Operand(var->name()));
|
|
|
|
// Declaration nodes are always introduced in one of two modes.
|
|
|
|
ASSERT(decl->mode() == Variable::VAR ||
|
|
|
|
decl->mode() == Variable::CONST);
|
|
|
|
PropertyAttributes attr =
|
|
|
|
(decl->mode() == Variable::VAR) ? NONE : READ_ONLY;
|
|
|
|
__ mov(r1, Operand(Smi::FromInt(attr)));
|
|
|
|
// Push initial value, if any.
|
|
|
|
// Note: For variables we must not push an initial value (such as
|
|
|
|
// 'undefined') because we may have a (legal) redeclaration and we
|
|
|
|
// must not destroy the current value.
|
|
|
|
if (decl->mode() == Variable::CONST) {
|
|
|
|
__ LoadRoot(r0, Heap::kTheHoleValueRootIndex);
|
|
|
|
__ stm(db_w, sp, cp.bit() | r2.bit() | r1.bit() | r0.bit());
|
|
|
|
} else if (decl->fun() != NULL) {
|
|
|
|
__ stm(db_w, sp, cp.bit() | r2.bit() | r1.bit());
|
|
|
|
Visit(decl->fun()); // Initial value for function decl.
|
|
|
|
} else {
|
|
|
|
__ mov(r0, Operand(Smi::FromInt(0))); // No initial value!
|
|
|
|
__ stm(db_w, sp, cp.bit() | r2.bit() | r1.bit() | r0.bit());
|
|
|
|
}
|
|
|
|
__ CallRuntime(Runtime::kDeclareContextSlot, 4);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
} else if (prop != NULL) {
|
|
|
|
if (decl->fun() != NULL || decl->mode() == Variable::CONST) {
|
|
|
|
// We are declaring a function or constant that rewrites to a
|
|
|
|
// property. Use (keyed) IC to set the initial value.
|
|
|
|
ASSERT_EQ(Expression::kValue, prop->obj()->context());
|
|
|
|
Visit(prop->obj());
|
|
|
|
ASSERT_EQ(Expression::kValue, prop->key()->context());
|
|
|
|
Visit(prop->key());
|
|
|
|
|
|
|
|
if (decl->fun() != NULL) {
|
|
|
|
ASSERT_EQ(Expression::kValue, decl->fun()->context());
|
2009-11-05 17:33:50 +00:00
|
|
|
Visit(decl->fun());
|
|
|
|
__ pop(r0);
|
2009-12-07 13:31:47 +00:00
|
|
|
} else {
|
|
|
|
__ LoadRoot(r0, Heap::kTheHoleValueRootIndex);
|
2009-11-05 17:33:50 +00:00
|
|
|
}
|
2009-12-07 13:31:47 +00:00
|
|
|
|
|
|
|
Handle<Code> ic(Builtins::builtin(Builtins::KeyedStoreIC_Initialize));
|
|
|
|
__ Call(ic, RelocInfo::CODE_TARGET);
|
|
|
|
|
|
|
|
// Value in r0 is ignored (declarations are statements). Receiver
|
|
|
|
// and key on stack are discarded.
|
|
|
|
__ add(sp, sp, Operand(2 * kPointerSize));
|
|
|
|
}
|
2009-11-05 17:33:50 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-10-21 09:17:39 +00:00
|
|
|
void FastCodeGenerator::DeclareGlobals(Handle<FixedArray> pairs) {
|
|
|
|
// Call the runtime to declare the globals.
|
2009-10-22 10:07:45 +00:00
|
|
|
// The context is the first argument.
|
|
|
|
__ mov(r1, Operand(pairs));
|
2009-10-21 09:17:39 +00:00
|
|
|
__ mov(r0, Operand(Smi::FromInt(is_eval_ ? 1 : 0)));
|
2009-10-22 10:07:45 +00:00
|
|
|
__ stm(db_w, sp, cp.bit() | r1.bit() | r0.bit());
|
2009-10-21 09:17:39 +00:00
|
|
|
__ CallRuntime(Runtime::kDeclareGlobals, 3);
|
|
|
|
// Return value is ignored.
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void FastCodeGenerator::VisitFunctionLiteral(FunctionLiteral* expr) {
|
|
|
|
Comment cmnt(masm_, "[ FunctionLiteral");
|
|
|
|
|
|
|
|
// Build the function boilerplate and instantiate it.
|
2009-11-04 17:59:24 +00:00
|
|
|
Handle<JSFunction> boilerplate =
|
|
|
|
Compiler::BuildBoilerplate(expr, script_, this);
|
2009-10-21 09:17:39 +00:00
|
|
|
if (HasStackOverflow()) return;
|
|
|
|
|
|
|
|
ASSERT(boilerplate->IsBoilerplate());
|
|
|
|
|
|
|
|
// Create a new closure.
|
|
|
|
__ mov(r0, Operand(boilerplate));
|
2009-10-22 10:07:45 +00:00
|
|
|
__ stm(db_w, sp, cp.bit() | r0.bit());
|
2009-10-21 09:17:39 +00:00
|
|
|
__ CallRuntime(Runtime::kNewClosure, 2);
|
2009-10-30 08:36:46 +00:00
|
|
|
Move(expr->context(), r0);
|
2009-10-21 09:17:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-10-16 09:46:09 +00:00
|
|
|
void FastCodeGenerator::VisitVariableProxy(VariableProxy* expr) {
|
|
|
|
Comment cmnt(masm_, "[ VariableProxy");
|
2009-12-11 16:09:16 +00:00
|
|
|
EmitVariableLoad(expr->var(), expr->context());
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void FastCodeGenerator::EmitVariableLoad(Variable* var,
|
|
|
|
Expression::Context context) {
|
|
|
|
Expression* rewrite = var->rewrite();
|
2009-10-21 09:38:21 +00:00
|
|
|
if (rewrite == NULL) {
|
2009-12-11 16:09:16 +00:00
|
|
|
ASSERT(var->is_global());
|
2009-10-21 09:38:21 +00:00
|
|
|
Comment cmnt(masm_, "Global variable");
|
|
|
|
// Use inline caching. Variable name is passed in r2 and the global
|
|
|
|
// object on the stack.
|
|
|
|
__ ldr(ip, CodeGenerator::GlobalObject());
|
|
|
|
__ push(ip);
|
2009-12-11 16:09:16 +00:00
|
|
|
__ mov(r2, Operand(var->name()));
|
2009-10-21 09:38:21 +00:00
|
|
|
Handle<Code> ic(Builtins::builtin(Builtins::LoadIC_Initialize));
|
|
|
|
__ Call(ic, RelocInfo::CODE_TARGET_CONTEXT);
|
2009-12-11 16:09:16 +00:00
|
|
|
DropAndMove(context, r0);
|
2009-11-12 11:38:01 +00:00
|
|
|
} else if (rewrite->AsSlot() != NULL) {
|
2009-11-09 09:56:57 +00:00
|
|
|
Slot* slot = rewrite->AsSlot();
|
2009-11-26 10:28:32 +00:00
|
|
|
if (FLAG_debug_code) {
|
|
|
|
switch (slot->type()) {
|
|
|
|
case Slot::LOCAL:
|
|
|
|
case Slot::PARAMETER: {
|
|
|
|
Comment cmnt(masm_, "Stack slot");
|
|
|
|
break;
|
2009-11-09 09:56:57 +00:00
|
|
|
}
|
2009-11-26 10:28:32 +00:00
|
|
|
case Slot::CONTEXT: {
|
|
|
|
Comment cmnt(masm_, "Context slot");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case Slot::LOOKUP:
|
|
|
|
UNIMPLEMENTED();
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
UNREACHABLE();
|
2009-11-09 09:56:57 +00:00
|
|
|
}
|
|
|
|
}
|
2009-12-11 16:09:16 +00:00
|
|
|
Move(context, slot, r0);
|
2009-11-12 11:38:01 +00:00
|
|
|
} else {
|
2009-11-26 10:28:32 +00:00
|
|
|
// A variable has been rewritten into an explicit access to
|
|
|
|
// an object property.
|
2009-11-12 11:38:01 +00:00
|
|
|
Property* property = rewrite->AsProperty();
|
|
|
|
ASSERT_NOT_NULL(property);
|
2009-11-26 10:28:32 +00:00
|
|
|
|
|
|
|
// Currently the only parameter expressions that can occur are
|
|
|
|
// on the form "slot[literal]".
|
|
|
|
|
|
|
|
// Check that the object is in a slot.
|
|
|
|
Variable* object_var = property->obj()->AsVariableProxy()->AsVariable();
|
|
|
|
ASSERT_NOT_NULL(object_var);
|
|
|
|
Slot* object_slot = object_var->slot();
|
|
|
|
ASSERT_NOT_NULL(object_slot);
|
|
|
|
|
|
|
|
// Load the object.
|
|
|
|
Move(r2, object_slot);
|
|
|
|
|
|
|
|
// Check that the key is a smi.
|
|
|
|
Literal* key_literal = property->key()->AsLiteral();
|
|
|
|
ASSERT_NOT_NULL(key_literal);
|
|
|
|
ASSERT(key_literal->handle()->IsSmi());
|
|
|
|
|
|
|
|
// Load the key.
|
|
|
|
__ mov(r1, Operand(key_literal->handle()));
|
|
|
|
|
|
|
|
// Push both as arguments to ic.
|
|
|
|
__ stm(db_w, sp, r2.bit() | r1.bit());
|
|
|
|
|
|
|
|
// Do a KEYED property load.
|
|
|
|
Handle<Code> ic(Builtins::builtin(Builtins::KeyedLoadIC_Initialize));
|
|
|
|
__ Call(ic, RelocInfo::CODE_TARGET);
|
|
|
|
|
|
|
|
// Drop key and object left on the stack by IC, and push the result.
|
2009-12-11 16:09:16 +00:00
|
|
|
DropAndMove(context, r0, 2);
|
2009-10-27 08:48:01 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-10-29 10:35:29 +00:00
|
|
|
void FastCodeGenerator::VisitRegExpLiteral(RegExpLiteral* expr) {
|
2009-11-03 14:48:59 +00:00
|
|
|
Comment cmnt(masm_, "[ RegExpLiteral");
|
2009-10-29 10:35:29 +00:00
|
|
|
Label done;
|
|
|
|
// Registers will be used as follows:
|
|
|
|
// r4 = JS function, literals array
|
|
|
|
// r3 = literal index
|
|
|
|
// r2 = RegExp pattern
|
|
|
|
// r1 = RegExp flags
|
|
|
|
// r0 = temp + return value (RegExp literal)
|
|
|
|
__ ldr(r0, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
|
|
|
|
__ ldr(r4, FieldMemOperand(r0, JSFunction::kLiteralsOffset));
|
|
|
|
int literal_offset =
|
|
|
|
FixedArray::kHeaderSize + expr->literal_index() * kPointerSize;
|
|
|
|
__ ldr(r0, FieldMemOperand(r4, literal_offset));
|
|
|
|
__ LoadRoot(ip, Heap::kUndefinedValueRootIndex);
|
|
|
|
__ cmp(r0, ip);
|
|
|
|
__ b(ne, &done);
|
|
|
|
__ mov(r3, Operand(Smi::FromInt(expr->literal_index())));
|
|
|
|
__ mov(r2, Operand(expr->pattern()));
|
|
|
|
__ mov(r1, Operand(expr->flags()));
|
|
|
|
__ stm(db_w, sp, r4.bit() | r3.bit() | r2.bit() | r1.bit());
|
|
|
|
__ CallRuntime(Runtime::kMaterializeRegExpLiteral, 4);
|
|
|
|
__ bind(&done);
|
2009-10-30 08:36:46 +00:00
|
|
|
Move(expr->context(), r0);
|
2009-10-29 10:35:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-10-26 13:21:48 +00:00
|
|
|
void FastCodeGenerator::VisitObjectLiteral(ObjectLiteral* expr) {
|
|
|
|
Comment cmnt(masm_, "[ ObjectLiteral");
|
|
|
|
__ ldr(r2, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
|
|
|
|
__ ldr(r2, FieldMemOperand(r2, JSFunction::kLiteralsOffset));
|
|
|
|
__ mov(r1, Operand(Smi::FromInt(expr->literal_index())));
|
|
|
|
__ mov(r0, Operand(expr->constant_properties()));
|
|
|
|
__ stm(db_w, sp, r2.bit() | r1.bit() | r0.bit());
|
|
|
|
if (expr->depth() > 1) {
|
2009-12-09 13:06:08 +00:00
|
|
|
__ CallRuntime(Runtime::kCreateObjectLiteral, 3);
|
2009-10-26 13:21:48 +00:00
|
|
|
} else {
|
2009-12-09 13:06:08 +00:00
|
|
|
__ CallRuntime(Runtime::kCreateObjectLiteralShallow, 3);
|
2009-10-26 13:21:48 +00:00
|
|
|
}
|
|
|
|
|
2009-11-26 21:13:20 +00:00
|
|
|
// If result_saved == true: The result is saved on top of the
|
|
|
|
// stack and in r0.
|
|
|
|
// If result_saved == false: The result not on the stack, just in r0.
|
2009-10-26 13:21:48 +00:00
|
|
|
bool result_saved = false;
|
|
|
|
|
|
|
|
for (int i = 0; i < expr->properties()->length(); i++) {
|
|
|
|
ObjectLiteral::Property* property = expr->properties()->at(i);
|
2009-10-28 13:25:40 +00:00
|
|
|
if (property->IsCompileTimeValue()) continue;
|
|
|
|
|
2009-10-26 13:21:48 +00:00
|
|
|
Literal* key = property->key();
|
|
|
|
Expression* value = property->value();
|
|
|
|
if (!result_saved) {
|
|
|
|
__ push(r0); // Save result on stack
|
|
|
|
result_saved = true;
|
|
|
|
}
|
|
|
|
switch (property->kind()) {
|
2009-10-29 10:35:29 +00:00
|
|
|
case ObjectLiteral::Property::CONSTANT:
|
|
|
|
UNREACHABLE();
|
|
|
|
|
|
|
|
case ObjectLiteral::Property::MATERIALIZED_LITERAL: // Fall through.
|
2009-10-26 13:21:48 +00:00
|
|
|
ASSERT(!CompileTimeValue::IsCompileTimeValue(property->value()));
|
2009-10-29 10:35:29 +00:00
|
|
|
case ObjectLiteral::Property::COMPUTED:
|
|
|
|
if (key->handle()->IsSymbol()) {
|
|
|
|
Visit(value);
|
2009-10-30 08:36:46 +00:00
|
|
|
ASSERT_EQ(Expression::kValue, value->context());
|
|
|
|
__ pop(r0);
|
2009-10-29 10:35:29 +00:00
|
|
|
__ mov(r2, Operand(key->handle()));
|
|
|
|
Handle<Code> ic(Builtins::builtin(Builtins::StoreIC_Initialize));
|
|
|
|
__ Call(ic, RelocInfo::CODE_TARGET);
|
|
|
|
// StoreIC leaves the receiver on the stack.
|
2009-11-26 21:13:20 +00:00
|
|
|
__ ldr(r0, MemOperand(sp)); // Restore result into r0.
|
2009-10-29 10:35:29 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
// Fall through.
|
|
|
|
|
2009-10-26 13:21:48 +00:00
|
|
|
case ObjectLiteral::Property::PROTOTYPE:
|
|
|
|
__ push(r0);
|
|
|
|
Visit(key);
|
2009-10-30 08:36:46 +00:00
|
|
|
ASSERT_EQ(Expression::kValue, key->context());
|
2009-10-26 13:21:48 +00:00
|
|
|
Visit(value);
|
2009-10-30 08:36:46 +00:00
|
|
|
ASSERT_EQ(Expression::kValue, value->context());
|
2009-10-26 13:21:48 +00:00
|
|
|
__ CallRuntime(Runtime::kSetProperty, 3);
|
2009-11-26 21:13:20 +00:00
|
|
|
__ ldr(r0, MemOperand(sp)); // Restore result into r0.
|
2009-10-26 13:21:48 +00:00
|
|
|
break;
|
2009-10-29 10:35:29 +00:00
|
|
|
|
|
|
|
case ObjectLiteral::Property::GETTER: // Fall through.
|
|
|
|
case ObjectLiteral::Property::SETTER:
|
2009-10-26 13:21:48 +00:00
|
|
|
__ push(r0);
|
|
|
|
Visit(key);
|
2009-10-30 08:36:46 +00:00
|
|
|
ASSERT_EQ(Expression::kValue, key->context());
|
2009-10-26 13:21:48 +00:00
|
|
|
__ mov(r1, Operand(property->kind() == ObjectLiteral::Property::SETTER ?
|
|
|
|
Smi::FromInt(1) :
|
|
|
|
Smi::FromInt(0)));
|
|
|
|
__ push(r1);
|
|
|
|
Visit(value);
|
2009-10-30 08:36:46 +00:00
|
|
|
ASSERT_EQ(Expression::kValue, value->context());
|
2009-10-26 13:21:48 +00:00
|
|
|
__ CallRuntime(Runtime::kDefineAccessor, 4);
|
|
|
|
__ ldr(r0, MemOperand(sp)); // Restore result into r0
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2009-10-30 08:36:46 +00:00
|
|
|
switch (expr->context()) {
|
|
|
|
case Expression::kUninitialized:
|
2009-10-29 10:35:29 +00:00
|
|
|
UNREACHABLE();
|
2009-10-30 08:36:46 +00:00
|
|
|
case Expression::kEffect:
|
2009-10-27 13:38:57 +00:00
|
|
|
if (result_saved) __ pop();
|
|
|
|
break;
|
2009-10-30 08:36:46 +00:00
|
|
|
case Expression::kValue:
|
2009-10-27 13:38:57 +00:00
|
|
|
if (!result_saved) __ push(r0);
|
|
|
|
break;
|
Initial implementation of top-level compilation of expressions in test
context. Test contexts are used for the left subexpressions of
short-circuited boolean operators. The right subexpressions inherit
their expression context from the binary op expression.
Compilation of short-circuited operations in effect and test context
is straightforward:
effect(e0 || e1) =
test(e0, L0, L1)
L1: effect(e1)
L0:
test(e0 || e1, L0, L1) =
test(e0, L0, L2)
L2: test(e1, L0, L1)
Because the value of the first subexpression may be needed as the
value of the whole expression in a value context, we introduce a
hybrid value/test contest (the value is needed if true, but not if
false).
value(e0 || e1) =
value/test(e0, L0, L1)
L1: value(e1)
L0:
The compilation of value/test and test/value (introduced by boolean
AND) is:
value/test(e0 || e1, L0, L1) =
value/test(e0, L0, L2)
L2: value/test(e1, L0, L1)
test/value(e0 || e1, L0, L1) =
test(e0, L0, L2)
L2: test/value(e1, L0, L1)
Boolean AND is the dual. The AST nodes themselves (not their parents)
are responsible for producing the proper result (effect, value, or
control flow) depending on their context.
Review URL: http://codereview.chromium.org/339082
git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@3187 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2009-10-30 14:06:48 +00:00
|
|
|
case Expression::kTest:
|
|
|
|
if (result_saved) __ pop(r0);
|
|
|
|
TestAndBranch(r0, true_label_, false_label_);
|
|
|
|
break;
|
|
|
|
case Expression::kValueTest: {
|
|
|
|
Label discard;
|
|
|
|
if (!result_saved) __ push(r0);
|
|
|
|
TestAndBranch(r0, true_label_, &discard);
|
|
|
|
__ bind(&discard);
|
|
|
|
__ pop();
|
|
|
|
__ jmp(false_label_);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case Expression::kTestValue: {
|
|
|
|
Label discard;
|
|
|
|
if (!result_saved) __ push(r0);
|
|
|
|
TestAndBranch(r0, &discard, false_label_);
|
|
|
|
__ bind(&discard);
|
|
|
|
__ pop();
|
|
|
|
__ jmp(true_label_);
|
|
|
|
break;
|
|
|
|
}
|
2009-10-26 13:21:48 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-10-22 10:07:45 +00:00
|
|
|
void FastCodeGenerator::VisitArrayLiteral(ArrayLiteral* expr) {
|
|
|
|
Comment cmnt(masm_, "[ ArrayLiteral");
|
|
|
|
__ ldr(r3, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
|
|
|
|
__ ldr(r3, FieldMemOperand(r3, JSFunction::kLiteralsOffset));
|
|
|
|
__ mov(r2, Operand(Smi::FromInt(expr->literal_index())));
|
2009-12-22 12:41:45 +00:00
|
|
|
__ mov(r1, Operand(expr->constant_elements()));
|
2009-10-22 10:07:45 +00:00
|
|
|
__ stm(db_w, sp, r3.bit() | r2.bit() | r1.bit());
|
|
|
|
if (expr->depth() > 1) {
|
2009-12-09 13:06:08 +00:00
|
|
|
__ CallRuntime(Runtime::kCreateArrayLiteral, 3);
|
2009-10-22 10:07:45 +00:00
|
|
|
} else {
|
2009-12-09 13:06:08 +00:00
|
|
|
__ CallRuntime(Runtime::kCreateArrayLiteralShallow, 3);
|
2009-10-22 10:07:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bool result_saved = false; // Is the result saved to the stack?
|
|
|
|
|
|
|
|
// Emit code to evaluate all the non-constant subexpressions and to store
|
|
|
|
// them into the newly cloned array.
|
|
|
|
ZoneList<Expression*>* subexprs = expr->values();
|
|
|
|
for (int i = 0, len = subexprs->length(); i < len; i++) {
|
|
|
|
Expression* subexpr = subexprs->at(i);
|
|
|
|
// If the subexpression is a literal or a simple materialized literal it
|
|
|
|
// is already set in the cloned array.
|
|
|
|
if (subexpr->AsLiteral() != NULL ||
|
|
|
|
CompileTimeValue::IsCompileTimeValue(subexpr)) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!result_saved) {
|
|
|
|
__ push(r0);
|
|
|
|
result_saved = true;
|
|
|
|
}
|
|
|
|
Visit(subexpr);
|
2009-10-30 08:36:46 +00:00
|
|
|
ASSERT_EQ(Expression::kValue, subexpr->context());
|
2009-10-22 10:07:45 +00:00
|
|
|
|
|
|
|
// Store the subexpression value in the array's elements.
|
|
|
|
__ pop(r0); // Subexpression value.
|
|
|
|
__ ldr(r1, MemOperand(sp)); // Copy of array literal.
|
|
|
|
__ ldr(r1, FieldMemOperand(r1, JSObject::kElementsOffset));
|
|
|
|
int offset = FixedArray::kHeaderSize + (i * kPointerSize);
|
|
|
|
__ str(r0, FieldMemOperand(r1, offset));
|
|
|
|
|
|
|
|
// Update the write barrier for the array store with r0 as the scratch
|
|
|
|
// register.
|
|
|
|
__ mov(r2, Operand(offset));
|
|
|
|
__ RecordWrite(r1, r2, r0);
|
|
|
|
}
|
|
|
|
|
2009-10-30 08:36:46 +00:00
|
|
|
switch (expr->context()) {
|
|
|
|
case Expression::kUninitialized:
|
2009-10-29 10:35:29 +00:00
|
|
|
UNREACHABLE();
|
2009-10-30 08:36:46 +00:00
|
|
|
case Expression::kEffect:
|
2009-10-27 13:38:57 +00:00
|
|
|
if (result_saved) __ pop();
|
|
|
|
break;
|
2009-10-30 08:36:46 +00:00
|
|
|
case Expression::kValue:
|
2009-10-27 13:38:57 +00:00
|
|
|
if (!result_saved) __ push(r0);
|
|
|
|
break;
|
Initial implementation of top-level compilation of expressions in test
context. Test contexts are used for the left subexpressions of
short-circuited boolean operators. The right subexpressions inherit
their expression context from the binary op expression.
Compilation of short-circuited operations in effect and test context
is straightforward:
effect(e0 || e1) =
test(e0, L0, L1)
L1: effect(e1)
L0:
test(e0 || e1, L0, L1) =
test(e0, L0, L2)
L2: test(e1, L0, L1)
Because the value of the first subexpression may be needed as the
value of the whole expression in a value context, we introduce a
hybrid value/test contest (the value is needed if true, but not if
false).
value(e0 || e1) =
value/test(e0, L0, L1)
L1: value(e1)
L0:
The compilation of value/test and test/value (introduced by boolean
AND) is:
value/test(e0 || e1, L0, L1) =
value/test(e0, L0, L2)
L2: value/test(e1, L0, L1)
test/value(e0 || e1, L0, L1) =
test(e0, L0, L2)
L2: test/value(e1, L0, L1)
Boolean AND is the dual. The AST nodes themselves (not their parents)
are responsible for producing the proper result (effect, value, or
control flow) depending on their context.
Review URL: http://codereview.chromium.org/339082
git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@3187 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2009-10-30 14:06:48 +00:00
|
|
|
case Expression::kTest:
|
|
|
|
if (result_saved) __ pop(r0);
|
|
|
|
TestAndBranch(r0, true_label_, false_label_);
|
|
|
|
break;
|
|
|
|
case Expression::kValueTest: {
|
|
|
|
Label discard;
|
|
|
|
if (!result_saved) __ push(r0);
|
|
|
|
TestAndBranch(r0, true_label_, &discard);
|
|
|
|
__ bind(&discard);
|
|
|
|
__ pop();
|
|
|
|
__ jmp(false_label_);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case Expression::kTestValue: {
|
|
|
|
Label discard;
|
|
|
|
if (!result_saved) __ push(r0);
|
|
|
|
TestAndBranch(r0, &discard, false_label_);
|
|
|
|
__ bind(&discard);
|
|
|
|
__ pop();
|
|
|
|
__ jmp(true_label_);
|
|
|
|
break;
|
|
|
|
}
|
2009-10-22 10:07:45 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-12-11 16:09:16 +00:00
|
|
|
void FastCodeGenerator::EmitNamedPropertyLoad(Property* prop,
|
|
|
|
Expression::Context context) {
|
2010-01-04 13:56:31 +00:00
|
|
|
SetSourcePosition(prop->position());
|
2009-12-11 16:09:16 +00:00
|
|
|
Literal* key = prop->key()->AsLiteral();
|
|
|
|
__ mov(r2, Operand(key->handle()));
|
|
|
|
Handle<Code> ic(Builtins::builtin(Builtins::LoadIC_Initialize));
|
|
|
|
__ Call(ic, RelocInfo::CODE_TARGET);
|
|
|
|
Move(context, r0);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-01-04 13:56:31 +00:00
|
|
|
void FastCodeGenerator::EmitKeyedPropertyLoad(Property* prop,
|
|
|
|
Expression::Context context) {
|
|
|
|
SetSourcePosition(prop->position());
|
2009-12-11 16:09:16 +00:00
|
|
|
Handle<Code> ic(Builtins::builtin(Builtins::KeyedLoadIC_Initialize));
|
|
|
|
__ Call(ic, RelocInfo::CODE_TARGET);
|
|
|
|
Move(context, r0);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void FastCodeGenerator::EmitCompoundAssignmentOp(Token::Value op,
|
|
|
|
Expression::Context context) {
|
|
|
|
__ pop(r0);
|
|
|
|
__ pop(r1);
|
|
|
|
GenericBinaryOpStub stub(op,
|
|
|
|
NO_OVERWRITE);
|
|
|
|
__ CallStub(&stub);
|
|
|
|
Move(context, r0);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-01-04 13:56:31 +00:00
|
|
|
void FastCodeGenerator::EmitVariableAssignment(Variable* var,
|
|
|
|
Expression::Context context) {
|
2009-11-02 13:30:24 +00:00
|
|
|
ASSERT(var != NULL);
|
2009-12-04 14:30:27 +00:00
|
|
|
ASSERT(var->is_global() || var->slot() != NULL);
|
2009-11-02 11:01:47 +00:00
|
|
|
if (var->is_global()) {
|
2009-11-02 13:30:24 +00:00
|
|
|
// Assignment to a global variable. Use inline caching for the
|
|
|
|
// assignment. Right-hand-side value is passed in r0, variable name in
|
|
|
|
// r2, and the global object on the stack.
|
2009-11-02 11:01:47 +00:00
|
|
|
__ pop(r0);
|
Added support for assignments to global variables in the toplevel code
generator. We use the normal store IC mechanism with the global
object as the receiver. The following code is generated for 'x=true'
at toplevel.
======== IA32:
27 mov eax,0xf5d06161 ;; object: 0xf5d06161 <true>
32 mov ecx,0xf5d09c35 ;; object: 0xf5d09c35 <String[1]: x>
37 push [esi+0x17]
40 call StoreIC_Initialize (0xf5ce75c0) ;; code: STORE_IC, UNINITIALIZED
45 mov [esp],eax
======== X64:
25 movq rax,0x7f867a7b6199 ;; object: 0x7f867a7b6199 <true>
35 movq rcx,0x7f867a7bae71 ;; object: 0x7f867a7bae71 <String[1]: x>
45 push [rsi+0x2f]
49 call StoreIC_Initialize (0x7f8655929ac0) ;; code: STORE_IC, UNINITIALIZED
54 movq [rsp],rax
======== ARM:
32 e59f0054 ldr r0, [pc, #+84] ;; object: 0xf5b78161 <true>
36 e59f2054 ldr r2, [pc, #+84] ;; object: 0xf5b7bc35 <String[1]: x>
40 e598c017 ldr ip, [r8, #+23]
44 e52dc004 str ip, [sp, #-4]!
48 e1a0e00f mov lr, pc
52 e59ff048 ldr pc, [pc, #+72] ;; debug: statement 0
;; code: STORE_IC, UNINITIALIZED
56 e58d0000 str r0, [sp, #+0]
Review URL: http://codereview.chromium.org/305005
git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@3095 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2009-10-20 13:37:26 +00:00
|
|
|
__ mov(r2, Operand(var->name()));
|
|
|
|
__ ldr(ip, CodeGenerator::GlobalObject());
|
|
|
|
__ push(ip);
|
|
|
|
Handle<Code> ic(Builtins::builtin(Builtins::StoreIC_Initialize));
|
|
|
|
__ Call(ic, RelocInfo::CODE_TARGET);
|
|
|
|
// Overwrite the global object on the stack with the result if needed.
|
2010-01-04 13:56:31 +00:00
|
|
|
DropAndMove(context, r0);
|
2009-11-02 13:30:24 +00:00
|
|
|
|
2009-11-26 10:28:32 +00:00
|
|
|
} else if (var->slot()) {
|
2009-11-09 09:56:57 +00:00
|
|
|
Slot* slot = var->slot();
|
|
|
|
ASSERT_NOT_NULL(slot); // Variables rewritten as properties not handled.
|
|
|
|
switch (slot->type()) {
|
|
|
|
case Slot::LOCAL:
|
|
|
|
case Slot::PARAMETER: {
|
2010-01-04 13:56:31 +00:00
|
|
|
switch (context) {
|
2009-11-09 09:56:57 +00:00
|
|
|
case Expression::kUninitialized:
|
|
|
|
UNREACHABLE();
|
|
|
|
case Expression::kEffect:
|
|
|
|
// Perform assignment and discard value.
|
|
|
|
__ pop(r0);
|
|
|
|
__ str(r0, MemOperand(fp, SlotOffset(var->slot())));
|
|
|
|
break;
|
|
|
|
case Expression::kValue:
|
|
|
|
// Perform assignment and preserve value.
|
|
|
|
__ ldr(r0, MemOperand(sp));
|
|
|
|
__ str(r0, MemOperand(fp, SlotOffset(var->slot())));
|
|
|
|
break;
|
|
|
|
case Expression::kTest:
|
|
|
|
// Perform assignment and test (and discard) value.
|
|
|
|
__ pop(r0);
|
|
|
|
__ str(r0, MemOperand(fp, SlotOffset(var->slot())));
|
|
|
|
TestAndBranch(r0, true_label_, false_label_);
|
|
|
|
break;
|
|
|
|
case Expression::kValueTest: {
|
|
|
|
Label discard;
|
|
|
|
__ ldr(r0, MemOperand(sp));
|
|
|
|
__ str(r0, MemOperand(fp, SlotOffset(var->slot())));
|
|
|
|
TestAndBranch(r0, true_label_, &discard);
|
|
|
|
__ bind(&discard);
|
|
|
|
__ pop();
|
|
|
|
__ jmp(false_label_);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case Expression::kTestValue: {
|
|
|
|
Label discard;
|
|
|
|
__ ldr(r0, MemOperand(sp));
|
|
|
|
__ str(r0, MemOperand(fp, SlotOffset(var->slot())));
|
|
|
|
TestAndBranch(r0, &discard, false_label_);
|
|
|
|
__ bind(&discard);
|
|
|
|
__ pop();
|
|
|
|
__ jmp(true_label_);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2009-11-02 11:01:47 +00:00
|
|
|
break;
|
|
|
|
}
|
2009-11-09 09:56:57 +00:00
|
|
|
|
|
|
|
case Slot::CONTEXT: {
|
|
|
|
int chain_length =
|
|
|
|
function_->scope()->ContextChainLength(slot->var()->scope());
|
|
|
|
if (chain_length > 0) {
|
|
|
|
// Move up the chain of contexts to the context containing the slot.
|
|
|
|
__ ldr(r0, CodeGenerator::ContextOperand(cp, Context::CLOSURE_INDEX));
|
|
|
|
// Load the function context (which is the incoming, outer context).
|
|
|
|
__ ldr(r0, FieldMemOperand(r0, JSFunction::kContextOffset));
|
|
|
|
for (int i = 1; i < chain_length; i++) {
|
|
|
|
__ ldr(r0,
|
|
|
|
CodeGenerator::ContextOperand(r0, Context::CLOSURE_INDEX));
|
|
|
|
__ ldr(r0, FieldMemOperand(r0, JSFunction::kContextOffset));
|
|
|
|
}
|
|
|
|
} else { // Slot is in the current context. Generate optimized code.
|
|
|
|
__ mov(r0, cp);
|
|
|
|
}
|
|
|
|
// The context may be an intermediate context, not a function context.
|
|
|
|
__ ldr(r0, CodeGenerator::ContextOperand(r0, Context::FCONTEXT_INDEX));
|
|
|
|
__ pop(r1);
|
|
|
|
__ str(r1, CodeGenerator::ContextOperand(r0, slot->index()));
|
|
|
|
|
|
|
|
// RecordWrite may destroy all its register arguments.
|
2010-01-04 13:56:31 +00:00
|
|
|
if (context == Expression::kValue) {
|
2009-11-09 09:56:57 +00:00
|
|
|
__ push(r1);
|
2010-01-04 13:56:31 +00:00
|
|
|
} else if (context != Expression::kEffect) {
|
2009-11-09 09:56:57 +00:00
|
|
|
__ mov(r3, r1);
|
|
|
|
}
|
|
|
|
int offset = FixedArray::kHeaderSize + slot->index() * kPointerSize;
|
|
|
|
|
|
|
|
// Update the write barrier for the array store with r0 as the scratch
|
2009-11-13 09:51:49 +00:00
|
|
|
// register. Skip the write barrier if the value written (r1) is a smi.
|
2009-11-09 09:56:57 +00:00
|
|
|
// The smi test is part of RecordWrite on other platforms, not on arm.
|
|
|
|
Label exit;
|
2009-11-13 09:51:49 +00:00
|
|
|
__ tst(r1, Operand(kSmiTagMask));
|
2009-11-09 09:56:57 +00:00
|
|
|
__ b(eq, &exit);
|
|
|
|
|
|
|
|
__ mov(r2, Operand(offset));
|
|
|
|
__ RecordWrite(r0, r2, r1);
|
|
|
|
__ bind(&exit);
|
2010-01-04 13:56:31 +00:00
|
|
|
if (context != Expression::kEffect &&
|
|
|
|
context != Expression::kValue) {
|
|
|
|
Move(context, r3);
|
2009-11-09 09:56:57 +00:00
|
|
|
}
|
2009-11-02 11:01:47 +00:00
|
|
|
break;
|
Added support for assignments to global variables in the toplevel code
generator. We use the normal store IC mechanism with the global
object as the receiver. The following code is generated for 'x=true'
at toplevel.
======== IA32:
27 mov eax,0xf5d06161 ;; object: 0xf5d06161 <true>
32 mov ecx,0xf5d09c35 ;; object: 0xf5d09c35 <String[1]: x>
37 push [esi+0x17]
40 call StoreIC_Initialize (0xf5ce75c0) ;; code: STORE_IC, UNINITIALIZED
45 mov [esp],eax
======== X64:
25 movq rax,0x7f867a7b6199 ;; object: 0x7f867a7b6199 <true>
35 movq rcx,0x7f867a7bae71 ;; object: 0x7f867a7bae71 <String[1]: x>
45 push [rsi+0x2f]
49 call StoreIC_Initialize (0x7f8655929ac0) ;; code: STORE_IC, UNINITIALIZED
54 movq [rsp],rax
======== ARM:
32 e59f0054 ldr r0, [pc, #+84] ;; object: 0xf5b78161 <true>
36 e59f2054 ldr r2, [pc, #+84] ;; object: 0xf5b7bc35 <String[1]: x>
40 e598c017 ldr ip, [r8, #+23]
44 e52dc004 str ip, [sp, #-4]!
48 e1a0e00f mov lr, pc
52 e59ff048 ldr pc, [pc, #+72] ;; debug: statement 0
;; code: STORE_IC, UNINITIALIZED
56 e58d0000 str r0, [sp, #+0]
Review URL: http://codereview.chromium.org/305005
git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@3095 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2009-10-20 13:37:26 +00:00
|
|
|
}
|
2009-11-09 09:56:57 +00:00
|
|
|
|
|
|
|
case Slot::LOOKUP:
|
|
|
|
UNREACHABLE();
|
|
|
|
break;
|
2009-10-19 10:36:42 +00:00
|
|
|
}
|
Added first support for tracking locations of expressions in the
fast-mode code generator.
AST expression nodes are annotated with a location when doing the
initial syntactic check of the AST. In the current implementation,
expression locations are 'temporary' (ie, allocated to the stack) or
'nowhere' (ie, the expression's value is not needed though it must be
evaluated for side effects).
For the assignment '.result = true' on IA32, we had before (with the
true value already on top of the stack):
32 mov eax,[esp]
35 mov [ebp+0xf4],eax
38 pop eax
Now:
32 pop [ebp+0xf4]
======== On x64, before:
37 movq rax,[rsp]
41 movq [rbp-0x18],rax
45 pop rax
Now:
37 pop [rbp-0x18]
======== On ARM, before (with the true value in register ip):
36 str ip, [sp, #-4]!
40 ldr ip, [sp, #+0]
44 str ip, [fp, #-12]
48 add sp, sp, #4
Now:
36 str ip, [fp, #-12]
Review URL: http://codereview.chromium.org/267118
git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@3076 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2009-10-15 16:42:22 +00:00
|
|
|
}
|
Initial port of top-level code generator to ARM. For the constant
true at the top level we generate:
0 stmdb sp!, {r1, r8, fp, lr}
4 add fp, sp, #8
8 ldr ip, [r10, #+4]
12 ldr r2, [r10, #+0]
16 str ip, [sp, #-4]!
20 add lr, pc, #4
24 cmp sp, r2
28 ldrcc pc, [pc, #+68] ;; code: STUB, StackCheck, minor: 0
32 ldr ip, [pc, #+68] ;; object: 0xf5bc4161 <true>
36 str ip, [sp, #-4]!
40 ldr ip, [sp, #+0]
44 str ip, [fp, #-12]
48 add sp, sp, #4
52 ldr ip, [fp, #-12]
56 str ip, [sp, #-4]!
60 ldr r0, [sp], #+4
64 mov sp, fp ;; js return
68 ldmia sp!, {fp, lr}
72 add sp, sp, #4
76 bx lr
80 ldr r0, [r10, #+4]
84 mov sp, fp ;; js return
88 ldmia sp!, {fp, lr}
92 add sp, sp, #4
96 bx lr
100 constant pool begin
104 constant
108 constant
Review URL: http://codereview.chromium.org/264067
git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@3073 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2009-10-15 12:42:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-11-02 13:30:24 +00:00
|
|
|
void FastCodeGenerator::EmitNamedPropertyAssignment(Assignment* expr) {
|
|
|
|
// Assignment to a property, using a named store IC.
|
|
|
|
Property* prop = expr->target()->AsProperty();
|
|
|
|
ASSERT(prop != NULL);
|
|
|
|
ASSERT(prop->key()->AsLiteral() != NULL);
|
|
|
|
|
|
|
|
// If the assignment starts a block of assignments to the same object,
|
|
|
|
// change to slow case to avoid the quadratic behavior of repeatedly
|
|
|
|
// adding fast properties.
|
|
|
|
if (expr->starts_initialization_block()) {
|
|
|
|
__ ldr(ip, MemOperand(sp, kPointerSize)); // Receiver is under value.
|
|
|
|
__ push(ip);
|
|
|
|
__ CallRuntime(Runtime::kToSlowProperties, 1);
|
|
|
|
}
|
|
|
|
|
2009-11-02 11:01:47 +00:00
|
|
|
__ pop(r0);
|
2009-11-02 13:30:24 +00:00
|
|
|
__ mov(r2, Operand(prop->key()->AsLiteral()->handle()));
|
2009-11-02 11:01:47 +00:00
|
|
|
Handle<Code> ic(Builtins::builtin(Builtins::StoreIC_Initialize));
|
|
|
|
__ Call(ic, RelocInfo::CODE_TARGET);
|
2009-11-02 13:30:24 +00:00
|
|
|
|
|
|
|
// If the assignment ends an initialization block, revert to fast case.
|
|
|
|
if (expr->ends_initialization_block()) {
|
|
|
|
__ push(r0); // Result of assignment, saved even if not needed.
|
|
|
|
__ ldr(ip, MemOperand(sp, kPointerSize)); // Receiver is under value.
|
|
|
|
__ push(ip);
|
|
|
|
__ CallRuntime(Runtime::kToFastProperties, 1);
|
|
|
|
__ pop(r0);
|
|
|
|
}
|
|
|
|
|
|
|
|
DropAndMove(expr->context(), r0);
|
2009-11-02 11:01:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-11-02 13:30:24 +00:00
|
|
|
void FastCodeGenerator::EmitKeyedPropertyAssignment(Assignment* expr) {
|
|
|
|
// Assignment to a property, using a keyed store IC.
|
|
|
|
|
|
|
|
// If the assignment starts a block of assignments to the same object,
|
|
|
|
// change to slow case to avoid the quadratic behavior of repeatedly
|
|
|
|
// adding fast properties.
|
|
|
|
if (expr->starts_initialization_block()) {
|
2010-01-04 13:56:31 +00:00
|
|
|
// Receiver is under the key and value.
|
2009-11-02 13:30:24 +00:00
|
|
|
__ ldr(ip, MemOperand(sp, 2 * kPointerSize));
|
|
|
|
__ push(ip);
|
|
|
|
__ CallRuntime(Runtime::kToSlowProperties, 1);
|
|
|
|
}
|
|
|
|
|
2009-11-02 11:01:47 +00:00
|
|
|
__ pop(r0);
|
|
|
|
Handle<Code> ic(Builtins::builtin(Builtins::KeyedStoreIC_Initialize));
|
|
|
|
__ Call(ic, RelocInfo::CODE_TARGET);
|
2009-11-02 13:30:24 +00:00
|
|
|
|
|
|
|
// If the assignment ends an initialization block, revert to fast case.
|
|
|
|
if (expr->ends_initialization_block()) {
|
|
|
|
__ push(r0); // Result of assignment, saved even if not needed.
|
|
|
|
// Reciever is under the key and value.
|
|
|
|
__ ldr(ip, MemOperand(sp, 2 * kPointerSize));
|
|
|
|
__ push(ip);
|
|
|
|
__ CallRuntime(Runtime::kToFastProperties, 1);
|
|
|
|
__ pop(r0);
|
|
|
|
}
|
|
|
|
|
2009-11-02 11:01:47 +00:00
|
|
|
// Receiver and key are still on stack.
|
|
|
|
__ add(sp, sp, Operand(2 * kPointerSize));
|
2009-11-02 13:30:24 +00:00
|
|
|
Move(expr->context(), r0);
|
2009-11-02 11:01:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-10-27 16:11:12 +00:00
|
|
|
void FastCodeGenerator::VisitProperty(Property* expr) {
|
|
|
|
Comment cmnt(masm_, "[ Property");
|
|
|
|
Expression* key = expr->key();
|
|
|
|
uint32_t dummy;
|
|
|
|
|
2009-10-28 10:14:32 +00:00
|
|
|
// Record the source position for the property load.
|
|
|
|
SetSourcePosition(expr->position());
|
|
|
|
|
2009-10-27 16:11:12 +00:00
|
|
|
// Evaluate receiver.
|
|
|
|
Visit(expr->obj());
|
|
|
|
|
|
|
|
if (key->AsLiteral() != NULL && key->AsLiteral()->handle()->IsSymbol() &&
|
|
|
|
!String::cast(*(key->AsLiteral()->handle()))->AsArrayIndex(&dummy)) {
|
|
|
|
// Do a NAMED property load.
|
2009-11-05 10:15:25 +00:00
|
|
|
// The IC expects the property name in r2 and the receiver on the stack.
|
2009-10-27 16:11:12 +00:00
|
|
|
__ mov(r2, Operand(key->AsLiteral()->handle()));
|
|
|
|
Handle<Code> ic(Builtins::builtin(Builtins::LoadIC_Initialize));
|
|
|
|
__ Call(ic, RelocInfo::CODE_TARGET);
|
|
|
|
} else {
|
|
|
|
// Do a KEYED property load.
|
|
|
|
Visit(expr->key());
|
|
|
|
Handle<Code> ic(Builtins::builtin(Builtins::KeyedLoadIC_Initialize));
|
|
|
|
__ Call(ic, RelocInfo::CODE_TARGET);
|
|
|
|
// Drop key and receiver left on the stack by IC.
|
|
|
|
__ pop();
|
|
|
|
}
|
2009-10-30 08:36:46 +00:00
|
|
|
DropAndMove(expr->context(), r0);
|
2009-10-27 16:11:12 +00:00
|
|
|
}
|
|
|
|
|
2009-12-17 10:23:20 +00:00
|
|
|
void FastCodeGenerator::EmitCallWithIC(Call* expr,
|
|
|
|
Handle<Object> ignored,
|
|
|
|
RelocInfo::Mode mode) {
|
2009-10-30 10:22:31 +00:00
|
|
|
// Code common for calls using the IC.
|
2009-10-21 09:17:39 +00:00
|
|
|
ZoneList<Expression*>* args = expr->arguments();
|
|
|
|
int arg_count = args->length();
|
|
|
|
for (int i = 0; i < arg_count; i++) {
|
|
|
|
Visit(args->at(i));
|
2009-10-30 08:36:46 +00:00
|
|
|
ASSERT_EQ(Expression::kValue, args->at(i)->context());
|
2009-10-21 09:17:39 +00:00
|
|
|
}
|
2009-10-30 10:22:31 +00:00
|
|
|
// Record source position for debugger.
|
2009-10-21 09:17:39 +00:00
|
|
|
SetSourcePosition(expr->position());
|
|
|
|
// Call the IC initialization code.
|
|
|
|
Handle<Code> ic = CodeGenerator::ComputeCallInitialize(arg_count,
|
|
|
|
NOT_IN_LOOP);
|
2009-12-17 10:23:20 +00:00
|
|
|
__ Call(ic, mode);
|
2009-10-30 10:22:31 +00:00
|
|
|
// Restore context register.
|
|
|
|
__ ldr(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
|
|
|
|
// Discard the function left on TOS.
|
|
|
|
DropAndMove(expr->context(), r0);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void FastCodeGenerator::EmitCallWithStub(Call* expr) {
|
|
|
|
// Code common for calls using the call stub.
|
|
|
|
ZoneList<Expression*>* args = expr->arguments();
|
|
|
|
int arg_count = args->length();
|
|
|
|
for (int i = 0; i < arg_count; i++) {
|
|
|
|
Visit(args->at(i));
|
|
|
|
}
|
|
|
|
// Record source position for debugger.
|
|
|
|
SetSourcePosition(expr->position());
|
|
|
|
CallFunctionStub stub(arg_count, NOT_IN_LOOP);
|
|
|
|
__ CallStub(&stub);
|
2009-10-21 09:17:39 +00:00
|
|
|
// Restore context register.
|
|
|
|
__ ldr(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
|
2009-10-30 10:22:31 +00:00
|
|
|
// Discard the function left on TOS.
|
2009-10-30 08:36:46 +00:00
|
|
|
DropAndMove(expr->context(), r0);
|
2009-10-21 09:17:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-10-30 10:22:31 +00:00
|
|
|
void FastCodeGenerator::VisitCall(Call* expr) {
|
2009-11-03 12:47:19 +00:00
|
|
|
Comment cmnt(masm_, "[ Call");
|
2009-10-30 10:22:31 +00:00
|
|
|
Expression* fun = expr->expression();
|
2009-11-02 12:04:35 +00:00
|
|
|
Variable* var = fun->AsVariableProxy()->AsVariable();
|
2009-10-30 10:22:31 +00:00
|
|
|
|
2009-11-03 12:47:19 +00:00
|
|
|
if (var != NULL && var->is_possibly_eval()) {
|
|
|
|
// Call to the identifier 'eval'.
|
|
|
|
UNREACHABLE();
|
|
|
|
} else if (var != NULL && !var->is_this() && var->is_global()) {
|
|
|
|
// Call to a global variable.
|
|
|
|
__ mov(r1, Operand(var->name()));
|
|
|
|
// Push global object as receiver for the call IC lookup.
|
|
|
|
__ ldr(r0, CodeGenerator::GlobalObject());
|
|
|
|
__ stm(db_w, sp, r1.bit() | r0.bit());
|
2009-12-17 10:23:20 +00:00
|
|
|
EmitCallWithIC(expr, var->name(), RelocInfo::CODE_TARGET_CONTEXT);
|
2009-11-03 12:47:19 +00:00
|
|
|
} else if (var != NULL && var->slot() != NULL &&
|
|
|
|
var->slot()->type() == Slot::LOOKUP) {
|
|
|
|
// Call to a lookup slot.
|
2009-11-02 12:04:35 +00:00
|
|
|
UNREACHABLE();
|
|
|
|
} else if (fun->AsProperty() != NULL) {
|
2009-11-03 12:47:19 +00:00
|
|
|
// Call to an object property.
|
2009-10-30 10:22:31 +00:00
|
|
|
Property* prop = fun->AsProperty();
|
|
|
|
Literal* key = prop->key()->AsLiteral();
|
|
|
|
if (key != NULL && key->handle()->IsSymbol()) {
|
2009-11-03 12:47:19 +00:00
|
|
|
// Call to a named property, use call IC.
|
2009-10-30 10:22:31 +00:00
|
|
|
__ mov(r0, Operand(key->handle()));
|
|
|
|
__ push(r0);
|
|
|
|
Visit(prop->obj());
|
2009-12-17 10:23:20 +00:00
|
|
|
EmitCallWithIC(expr, key->handle(), RelocInfo::CODE_TARGET);
|
2009-10-30 10:22:31 +00:00
|
|
|
} else {
|
2009-11-03 12:47:19 +00:00
|
|
|
// Call to a keyed property, use keyed load IC followed by function
|
|
|
|
// call.
|
2009-10-30 10:22:31 +00:00
|
|
|
Visit(prop->obj());
|
|
|
|
Visit(prop->key());
|
2009-11-03 12:47:19 +00:00
|
|
|
// Record source code position for IC call.
|
2009-10-30 10:22:31 +00:00
|
|
|
SetSourcePosition(prop->position());
|
|
|
|
Handle<Code> ic(Builtins::builtin(Builtins::KeyedLoadIC_Initialize));
|
|
|
|
__ Call(ic, RelocInfo::CODE_TARGET);
|
|
|
|
// Load receiver object into r1.
|
|
|
|
if (prop->is_synthetic()) {
|
|
|
|
__ ldr(r1, CodeGenerator::GlobalObject());
|
|
|
|
} else {
|
|
|
|
__ ldr(r1, MemOperand(sp, kPointerSize));
|
|
|
|
}
|
|
|
|
// Overwrite (object, key) with (function, receiver).
|
|
|
|
__ str(r0, MemOperand(sp, kPointerSize));
|
|
|
|
__ str(r1, MemOperand(sp));
|
|
|
|
EmitCallWithStub(expr);
|
|
|
|
}
|
2009-11-02 12:04:35 +00:00
|
|
|
} else {
|
2009-11-03 14:48:59 +00:00
|
|
|
// Call to some other expression. If the expression is an anonymous
|
|
|
|
// function literal not called in a loop, mark it as one that should
|
|
|
|
// also use the fast code generator.
|
|
|
|
FunctionLiteral* lit = fun->AsFunctionLiteral();
|
|
|
|
if (lit != NULL &&
|
|
|
|
lit->name()->Equals(Heap::empty_string()) &&
|
|
|
|
loop_depth() == 0) {
|
|
|
|
lit->set_try_fast_codegen(true);
|
|
|
|
}
|
|
|
|
Visit(fun);
|
2009-11-02 12:04:35 +00:00
|
|
|
// Load global receiver object.
|
|
|
|
__ ldr(r1, CodeGenerator::GlobalObject());
|
|
|
|
__ ldr(r1, FieldMemOperand(r1, GlobalObject::kGlobalReceiverOffset));
|
|
|
|
__ push(r1);
|
|
|
|
// Emit function call.
|
|
|
|
EmitCallWithStub(expr);
|
2009-10-30 10:22:31 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-10-30 08:36:46 +00:00
|
|
|
void FastCodeGenerator::VisitCallNew(CallNew* expr) {
|
2009-10-27 14:52:55 +00:00
|
|
|
Comment cmnt(masm_, "[ CallNew");
|
|
|
|
// According to ECMA-262, section 11.2.2, page 44, the function
|
|
|
|
// expression in new calls must be evaluated before the
|
|
|
|
// arguments.
|
|
|
|
// Push function on the stack.
|
2009-10-30 08:36:46 +00:00
|
|
|
Visit(expr->expression());
|
|
|
|
ASSERT_EQ(Expression::kValue, expr->expression()->context());
|
2009-10-27 14:52:55 +00:00
|
|
|
|
|
|
|
// Push global object (receiver).
|
|
|
|
__ ldr(r0, CodeGenerator::GlobalObject());
|
|
|
|
__ push(r0);
|
|
|
|
// Push the arguments ("left-to-right") on the stack.
|
2009-10-30 08:36:46 +00:00
|
|
|
ZoneList<Expression*>* args = expr->arguments();
|
2009-10-27 14:52:55 +00:00
|
|
|
int arg_count = args->length();
|
|
|
|
for (int i = 0; i < arg_count; i++) {
|
|
|
|
Visit(args->at(i));
|
2009-10-30 08:36:46 +00:00
|
|
|
ASSERT_EQ(Expression::kValue, args->at(i)->context());
|
2009-10-29 11:55:03 +00:00
|
|
|
// If location is value, it is already on the stack,
|
2009-10-27 14:52:55 +00:00
|
|
|
// so nothing to do here.
|
|
|
|
}
|
|
|
|
|
|
|
|
// Call the construct call builtin that handles allocation and
|
|
|
|
// constructor invocation.
|
2009-10-30 08:36:46 +00:00
|
|
|
SetSourcePosition(expr->position());
|
2009-10-27 14:52:55 +00:00
|
|
|
|
|
|
|
// Load function, arg_count into r1 and r0.
|
|
|
|
__ mov(r0, Operand(arg_count));
|
2010-01-04 13:56:31 +00:00
|
|
|
// Function is in sp[arg_count + 1].
|
2009-10-27 14:52:55 +00:00
|
|
|
__ ldr(r1, MemOperand(sp, (arg_count + 1) * kPointerSize));
|
|
|
|
|
|
|
|
Handle<Code> construct_builtin(Builtins::builtin(Builtins::JSConstructCall));
|
|
|
|
__ Call(construct_builtin, RelocInfo::CONSTRUCT_CALL);
|
|
|
|
|
|
|
|
// Replace function on TOS with result in r0, or pop it.
|
2009-10-30 08:36:46 +00:00
|
|
|
DropAndMove(expr->context(), r0);
|
2009-10-27 14:52:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-10-21 09:17:39 +00:00
|
|
|
void FastCodeGenerator::VisitCallRuntime(CallRuntime* expr) {
|
|
|
|
Comment cmnt(masm_, "[ CallRuntime");
|
|
|
|
ZoneList<Expression*>* args = expr->arguments();
|
|
|
|
|
2009-11-27 00:28:06 +00:00
|
|
|
if (expr->is_jsruntime()) {
|
|
|
|
// Prepare for calling JS runtime function.
|
|
|
|
__ mov(r1, Operand(expr->name()));
|
|
|
|
__ ldr(r0, CodeGenerator::GlobalObject());
|
|
|
|
__ ldr(r0, FieldMemOperand(r0, GlobalObject::kBuiltinsOffset));
|
|
|
|
__ stm(db_w, sp, r1.bit() | r0.bit());
|
|
|
|
}
|
2009-10-21 09:17:39 +00:00
|
|
|
|
|
|
|
// Push the arguments ("left-to-right").
|
|
|
|
int arg_count = args->length();
|
|
|
|
for (int i = 0; i < arg_count; i++) {
|
|
|
|
Visit(args->at(i));
|
2009-10-30 08:36:46 +00:00
|
|
|
ASSERT_EQ(Expression::kValue, args->at(i)->context());
|
2009-10-21 09:17:39 +00:00
|
|
|
}
|
|
|
|
|
2009-11-27 00:28:06 +00:00
|
|
|
if (expr->is_jsruntime()) {
|
|
|
|
// Call the JS runtime function.
|
|
|
|
Handle<Code> ic = CodeGenerator::ComputeCallInitialize(arg_count,
|
|
|
|
NOT_IN_LOOP);
|
|
|
|
__ Call(ic, RelocInfo::CODE_TARGET);
|
|
|
|
// Restore context register.
|
|
|
|
__ ldr(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
|
|
|
|
// Discard the function left on TOS.
|
|
|
|
DropAndMove(expr->context(), r0);
|
|
|
|
} else {
|
|
|
|
// Call the C runtime function.
|
|
|
|
__ CallRuntime(expr->function(), arg_count);
|
|
|
|
Move(expr->context(), r0);
|
|
|
|
}
|
2009-10-21 09:17:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-10-30 11:32:42 +00:00
|
|
|
void FastCodeGenerator::VisitUnaryOperation(UnaryOperation* expr) {
|
|
|
|
switch (expr->op()) {
|
2009-11-05 10:15:25 +00:00
|
|
|
case Token::VOID: {
|
|
|
|
Comment cmnt(masm_, "[ UnaryOperation (VOID)");
|
2009-10-30 11:32:42 +00:00
|
|
|
Visit(expr->expression());
|
|
|
|
ASSERT_EQ(Expression::kEffect, expr->expression()->context());
|
|
|
|
switch (expr->context()) {
|
|
|
|
case Expression::kUninitialized:
|
|
|
|
UNREACHABLE();
|
|
|
|
break;
|
Initial implementation of top-level compilation of expressions in test
context. Test contexts are used for the left subexpressions of
short-circuited boolean operators. The right subexpressions inherit
their expression context from the binary op expression.
Compilation of short-circuited operations in effect and test context
is straightforward:
effect(e0 || e1) =
test(e0, L0, L1)
L1: effect(e1)
L0:
test(e0 || e1, L0, L1) =
test(e0, L0, L2)
L2: test(e1, L0, L1)
Because the value of the first subexpression may be needed as the
value of the whole expression in a value context, we introduce a
hybrid value/test contest (the value is needed if true, but not if
false).
value(e0 || e1) =
value/test(e0, L0, L1)
L1: value(e1)
L0:
The compilation of value/test and test/value (introduced by boolean
AND) is:
value/test(e0 || e1, L0, L1) =
value/test(e0, L0, L2)
L2: value/test(e1, L0, L1)
test/value(e0 || e1, L0, L1) =
test(e0, L0, L2)
L2: test/value(e1, L0, L1)
Boolean AND is the dual. The AST nodes themselves (not their parents)
are responsible for producing the proper result (effect, value, or
control flow) depending on their context.
Review URL: http://codereview.chromium.org/339082
git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@3187 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2009-10-30 14:06:48 +00:00
|
|
|
case Expression::kEffect:
|
|
|
|
break;
|
2009-10-30 11:32:42 +00:00
|
|
|
case Expression::kValue:
|
|
|
|
__ LoadRoot(ip, Heap::kUndefinedValueRootIndex);
|
|
|
|
__ push(ip);
|
|
|
|
break;
|
Initial implementation of top-level compilation of expressions in test
context. Test contexts are used for the left subexpressions of
short-circuited boolean operators. The right subexpressions inherit
their expression context from the binary op expression.
Compilation of short-circuited operations in effect and test context
is straightforward:
effect(e0 || e1) =
test(e0, L0, L1)
L1: effect(e1)
L0:
test(e0 || e1, L0, L1) =
test(e0, L0, L2)
L2: test(e1, L0, L1)
Because the value of the first subexpression may be needed as the
value of the whole expression in a value context, we introduce a
hybrid value/test contest (the value is needed if true, but not if
false).
value(e0 || e1) =
value/test(e0, L0, L1)
L1: value(e1)
L0:
The compilation of value/test and test/value (introduced by boolean
AND) is:
value/test(e0 || e1, L0, L1) =
value/test(e0, L0, L2)
L2: value/test(e1, L0, L1)
test/value(e0 || e1, L0, L1) =
test(e0, L0, L2)
L2: test/value(e1, L0, L1)
Boolean AND is the dual. The AST nodes themselves (not their parents)
are responsible for producing the proper result (effect, value, or
control flow) depending on their context.
Review URL: http://codereview.chromium.org/339082
git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@3187 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2009-10-30 14:06:48 +00:00
|
|
|
case Expression::kTestValue:
|
|
|
|
// Value is false so it's needed.
|
|
|
|
__ LoadRoot(ip, Heap::kUndefinedValueRootIndex);
|
|
|
|
__ push(ip);
|
|
|
|
case Expression::kTest: // Fall through.
|
|
|
|
case Expression::kValueTest:
|
|
|
|
__ jmp(false_label_);
|
2009-10-30 11:32:42 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
2009-11-05 10:15:25 +00:00
|
|
|
}
|
2009-10-30 11:32:42 +00:00
|
|
|
|
2009-11-02 10:17:12 +00:00
|
|
|
case Token::NOT: {
|
2009-11-05 10:15:25 +00:00
|
|
|
Comment cmnt(masm_, "[ UnaryOperation (NOT)");
|
2009-11-02 10:17:12 +00:00
|
|
|
ASSERT_EQ(Expression::kTest, expr->expression()->context());
|
|
|
|
|
|
|
|
Label push_true;
|
|
|
|
Label push_false;
|
|
|
|
Label done;
|
|
|
|
Label* saved_true = true_label_;
|
|
|
|
Label* saved_false = false_label_;
|
|
|
|
switch (expr->context()) {
|
|
|
|
case Expression::kUninitialized:
|
|
|
|
UNREACHABLE();
|
|
|
|
break;
|
|
|
|
|
|
|
|
case Expression::kValue:
|
|
|
|
true_label_ = &push_false;
|
|
|
|
false_label_ = &push_true;
|
|
|
|
Visit(expr->expression());
|
|
|
|
__ bind(&push_true);
|
|
|
|
__ LoadRoot(ip, Heap::kTrueValueRootIndex);
|
|
|
|
__ push(ip);
|
|
|
|
__ jmp(&done);
|
|
|
|
__ bind(&push_false);
|
|
|
|
__ LoadRoot(ip, Heap::kFalseValueRootIndex);
|
|
|
|
__ push(ip);
|
|
|
|
__ bind(&done);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case Expression::kEffect:
|
|
|
|
true_label_ = &done;
|
|
|
|
false_label_ = &done;
|
|
|
|
Visit(expr->expression());
|
|
|
|
__ bind(&done);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case Expression::kTest:
|
|
|
|
true_label_ = saved_false;
|
|
|
|
false_label_ = saved_true;
|
|
|
|
Visit(expr->expression());
|
|
|
|
break;
|
|
|
|
|
|
|
|
case Expression::kValueTest:
|
|
|
|
true_label_ = saved_false;
|
|
|
|
false_label_ = &push_true;
|
|
|
|
Visit(expr->expression());
|
|
|
|
__ bind(&push_true);
|
|
|
|
__ LoadRoot(ip, Heap::kTrueValueRootIndex);
|
|
|
|
__ push(ip);
|
|
|
|
__ jmp(saved_true);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case Expression::kTestValue:
|
|
|
|
true_label_ = &push_false;
|
|
|
|
false_label_ = saved_true;
|
|
|
|
Visit(expr->expression());
|
|
|
|
__ bind(&push_false);
|
|
|
|
__ LoadRoot(ip, Heap::kFalseValueRootIndex);
|
|
|
|
__ push(ip);
|
|
|
|
__ jmp(saved_false);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
true_label_ = saved_true;
|
|
|
|
false_label_ = saved_false;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2009-11-05 10:15:25 +00:00
|
|
|
case Token::TYPEOF: {
|
|
|
|
Comment cmnt(masm_, "[ UnaryOperation (TYPEOF)");
|
|
|
|
ASSERT_EQ(Expression::kValue, expr->expression()->context());
|
|
|
|
|
|
|
|
VariableProxy* proxy = expr->expression()->AsVariableProxy();
|
2009-11-05 12:45:53 +00:00
|
|
|
if (proxy != NULL &&
|
|
|
|
!proxy->var()->is_this() &&
|
|
|
|
proxy->var()->is_global()) {
|
2009-11-05 10:15:25 +00:00
|
|
|
Comment cmnt(masm_, "Global variable");
|
|
|
|
__ ldr(r0, CodeGenerator::GlobalObject());
|
|
|
|
__ push(r0);
|
|
|
|
__ mov(r2, Operand(proxy->name()));
|
|
|
|
Handle<Code> ic(Builtins::builtin(Builtins::LoadIC_Initialize));
|
|
|
|
// Use a regular load, not a contextual load, to avoid a reference
|
|
|
|
// error.
|
|
|
|
__ Call(ic, RelocInfo::CODE_TARGET);
|
|
|
|
__ str(r0, MemOperand(sp));
|
|
|
|
} else if (proxy != NULL &&
|
|
|
|
proxy->var()->slot() != NULL &&
|
|
|
|
proxy->var()->slot()->type() == Slot::LOOKUP) {
|
|
|
|
__ mov(r0, Operand(proxy->name()));
|
|
|
|
__ stm(db_w, sp, cp.bit() | r0.bit());
|
|
|
|
__ CallRuntime(Runtime::kLoadContextSlotNoReferenceError, 2);
|
|
|
|
__ push(r0);
|
|
|
|
} else {
|
|
|
|
// This expression cannot throw a reference error at the top level.
|
|
|
|
Visit(expr->expression());
|
|
|
|
}
|
|
|
|
|
|
|
|
__ CallRuntime(Runtime::kTypeof, 1);
|
|
|
|
Move(expr->context(), r0);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2009-10-30 11:32:42 +00:00
|
|
|
default:
|
|
|
|
UNREACHABLE();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-11-02 10:22:22 +00:00
|
|
|
void FastCodeGenerator::VisitCountOperation(CountOperation* expr) {
|
2009-11-03 14:48:59 +00:00
|
|
|
Comment cmnt(masm_, "[ CountOperation");
|
2009-11-02 10:22:22 +00:00
|
|
|
|
2010-01-04 13:56:31 +00:00
|
|
|
// Expression can only be a property, a global or a (parameter or local)
|
|
|
|
// slot. Variables with rewrite to .arguments are treated as KEYED_PROPERTY.
|
|
|
|
enum LhsKind { VARIABLE, NAMED_PROPERTY, KEYED_PROPERTY };
|
|
|
|
LhsKind assign_type = VARIABLE;
|
|
|
|
Property* prop = expr->expression()->AsProperty();
|
|
|
|
// In case of a property we use the uninitialized expression context
|
|
|
|
// of the key to detect a named property.
|
|
|
|
if (prop != NULL) {
|
|
|
|
assign_type = (prop->key()->context() == Expression::kUninitialized)
|
|
|
|
? NAMED_PROPERTY
|
|
|
|
: KEYED_PROPERTY;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Evaluate expression and get value.
|
|
|
|
if (assign_type == VARIABLE) {
|
|
|
|
ASSERT(expr->expression()->AsVariableProxy()->var() != NULL);
|
|
|
|
EmitVariableLoad(expr->expression()->AsVariableProxy()->var(),
|
|
|
|
Expression::kValue);
|
|
|
|
} else {
|
|
|
|
// Reserve space for result of postfix operation.
|
|
|
|
if (expr->is_postfix() && expr->context() != Expression::kEffect) {
|
|
|
|
ASSERT(expr->context() != Expression::kUninitialized);
|
|
|
|
__ mov(ip, Operand(Smi::FromInt(0)));
|
|
|
|
__ push(ip);
|
|
|
|
}
|
|
|
|
Visit(prop->obj());
|
|
|
|
ASSERT_EQ(Expression::kValue, prop->obj()->context());
|
|
|
|
if (assign_type == NAMED_PROPERTY) {
|
|
|
|
EmitNamedPropertyLoad(prop, Expression::kValue);
|
|
|
|
} else {
|
|
|
|
Visit(prop->key());
|
|
|
|
ASSERT_EQ(Expression::kValue, prop->key()->context());
|
|
|
|
EmitKeyedPropertyLoad(prop, Expression::kValue);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Convert to number.
|
2009-11-02 10:22:22 +00:00
|
|
|
__ InvokeBuiltin(Builtins::TO_NUMBER, CALL_JS);
|
|
|
|
|
2010-01-04 13:56:31 +00:00
|
|
|
// Save result for postfix expressions.
|
|
|
|
if (expr->is_postfix()) {
|
|
|
|
switch (expr->context()) {
|
|
|
|
case Expression::kUninitialized:
|
|
|
|
UNREACHABLE();
|
|
|
|
case Expression::kEffect:
|
|
|
|
// Do not save result.
|
|
|
|
break;
|
|
|
|
case Expression::kValue: // Fall through
|
|
|
|
case Expression::kTest: // Fall through
|
|
|
|
case Expression::kTestValue: // Fall through
|
|
|
|
case Expression::kValueTest:
|
|
|
|
// Save the result on the stack. If we have a named or keyed property
|
|
|
|
// we store the result under the receiver that is currently on top
|
|
|
|
// of the stack.
|
|
|
|
switch (assign_type) {
|
|
|
|
case VARIABLE:
|
|
|
|
__ push(r0);
|
|
|
|
break;
|
|
|
|
case NAMED_PROPERTY:
|
|
|
|
__ str(r0, MemOperand(sp, kPointerSize));
|
|
|
|
break;
|
|
|
|
case KEYED_PROPERTY:
|
|
|
|
__ str(r0, MemOperand(sp, 2 * kPointerSize));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2009-11-02 10:22:22 +00:00
|
|
|
}
|
2010-01-04 13:56:31 +00:00
|
|
|
|
2009-11-02 10:22:22 +00:00
|
|
|
// Call runtime for +1/-1.
|
|
|
|
if (expr->op() == Token::INC) {
|
2010-01-04 14:15:47 +00:00
|
|
|
__ mov(ip, Operand(Smi::FromInt(1)));
|
2009-11-02 10:22:22 +00:00
|
|
|
} else {
|
2010-01-04 14:15:47 +00:00
|
|
|
__ mov(ip, Operand(Smi::FromInt(-1)));
|
2009-11-02 10:22:22 +00:00
|
|
|
}
|
2010-01-04 14:15:47 +00:00
|
|
|
__ stm(db_w, sp, ip.bit() | r0.bit());
|
|
|
|
__ CallRuntime(Runtime::kNumberAdd, 2);
|
2009-11-02 10:22:22 +00:00
|
|
|
|
2010-01-04 13:56:31 +00:00
|
|
|
// Store the value returned in r0.
|
|
|
|
switch (assign_type) {
|
|
|
|
case VARIABLE:
|
|
|
|
__ push(r0);
|
|
|
|
if (expr->is_postfix()) {
|
|
|
|
EmitVariableAssignment(expr->expression()->AsVariableProxy()->var(),
|
|
|
|
Expression::kEffect);
|
|
|
|
// For all contexts except kEffect: We have the result on
|
|
|
|
// top of the stack.
|
|
|
|
if (expr->context() != Expression::kEffect) {
|
|
|
|
MoveTOS(expr->context());
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
EmitVariableAssignment(expr->expression()->AsVariableProxy()->var(),
|
|
|
|
expr->context());
|
|
|
|
}
|
2009-11-02 10:22:22 +00:00
|
|
|
break;
|
2010-01-04 13:56:31 +00:00
|
|
|
case NAMED_PROPERTY: {
|
|
|
|
__ mov(r2, Operand(prop->key()->AsLiteral()->handle()));
|
|
|
|
Handle<Code> ic(Builtins::builtin(Builtins::StoreIC_Initialize));
|
|
|
|
__ Call(ic, RelocInfo::CODE_TARGET);
|
|
|
|
if (expr->is_postfix()) {
|
|
|
|
__ Drop(1); // Result is on the stack under the receiver.
|
|
|
|
if (expr->context() != Expression::kEffect) {
|
|
|
|
MoveTOS(expr->context());
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
DropAndMove(expr->context(), r0);
|
|
|
|
}
|
2009-11-02 10:22:22 +00:00
|
|
|
break;
|
|
|
|
}
|
2010-01-04 13:56:31 +00:00
|
|
|
case KEYED_PROPERTY: {
|
|
|
|
Handle<Code> ic(Builtins::builtin(Builtins::KeyedStoreIC_Initialize));
|
|
|
|
__ Call(ic, RelocInfo::CODE_TARGET);
|
|
|
|
if (expr->is_postfix()) {
|
|
|
|
__ Drop(2); // Result is on the stack under the key and the receiver.
|
|
|
|
if (expr->context() != Expression::kEffect) {
|
|
|
|
MoveTOS(expr->context());
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
DropAndMove(expr->context(), r0, 2);
|
|
|
|
}
|
2009-11-02 10:22:22 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-10-23 10:42:14 +00:00
|
|
|
void FastCodeGenerator::VisitBinaryOperation(BinaryOperation* expr) {
|
2009-11-03 14:48:59 +00:00
|
|
|
Comment cmnt(masm_, "[ BinaryOperation");
|
2009-10-29 11:55:03 +00:00
|
|
|
switch (expr->op()) {
|
|
|
|
case Token::COMMA:
|
2009-10-30 08:36:46 +00:00
|
|
|
ASSERT_EQ(Expression::kEffect, expr->left()->context());
|
|
|
|
ASSERT_EQ(expr->context(), expr->right()->context());
|
2009-10-29 11:55:03 +00:00
|
|
|
Visit(expr->left());
|
|
|
|
Visit(expr->right());
|
|
|
|
break;
|
|
|
|
|
|
|
|
case Token::OR:
|
|
|
|
case Token::AND:
|
|
|
|
EmitLogicalOperation(expr);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case Token::ADD:
|
|
|
|
case Token::SUB:
|
|
|
|
case Token::DIV:
|
|
|
|
case Token::MOD:
|
|
|
|
case Token::MUL:
|
|
|
|
case Token::BIT_OR:
|
|
|
|
case Token::BIT_AND:
|
|
|
|
case Token::BIT_XOR:
|
|
|
|
case Token::SHL:
|
|
|
|
case Token::SHR:
|
|
|
|
case Token::SAR: {
|
2009-10-30 08:36:46 +00:00
|
|
|
ASSERT_EQ(Expression::kValue, expr->left()->context());
|
|
|
|
ASSERT_EQ(Expression::kValue, expr->right()->context());
|
2009-10-29 11:55:03 +00:00
|
|
|
|
|
|
|
Visit(expr->left());
|
|
|
|
Visit(expr->right());
|
|
|
|
__ pop(r0);
|
|
|
|
__ pop(r1);
|
|
|
|
GenericBinaryOpStub stub(expr->op(),
|
|
|
|
NO_OVERWRITE);
|
|
|
|
__ CallStub(&stub);
|
2009-10-30 08:36:46 +00:00
|
|
|
Move(expr->context(), r0);
|
2009-10-29 11:55:03 +00:00
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
UNREACHABLE();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-11-02 15:01:06 +00:00
|
|
|
void FastCodeGenerator::VisitCompareOperation(CompareOperation* expr) {
|
2009-11-03 14:48:59 +00:00
|
|
|
Comment cmnt(masm_, "[ CompareOperation");
|
2009-11-02 15:01:06 +00:00
|
|
|
ASSERT_EQ(Expression::kValue, expr->left()->context());
|
|
|
|
ASSERT_EQ(Expression::kValue, expr->right()->context());
|
|
|
|
Visit(expr->left());
|
|
|
|
Visit(expr->right());
|
|
|
|
|
|
|
|
// Convert current context to test context: Pre-test code.
|
|
|
|
Label push_true;
|
|
|
|
Label push_false;
|
|
|
|
Label done;
|
|
|
|
Label* saved_true = true_label_;
|
|
|
|
Label* saved_false = false_label_;
|
|
|
|
switch (expr->context()) {
|
|
|
|
case Expression::kUninitialized:
|
|
|
|
UNREACHABLE();
|
|
|
|
break;
|
|
|
|
|
|
|
|
case Expression::kValue:
|
|
|
|
true_label_ = &push_true;
|
|
|
|
false_label_ = &push_false;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case Expression::kEffect:
|
|
|
|
true_label_ = &done;
|
|
|
|
false_label_ = &done;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case Expression::kTest:
|
|
|
|
break;
|
|
|
|
|
|
|
|
case Expression::kValueTest:
|
|
|
|
true_label_ = &push_true;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case Expression::kTestValue:
|
|
|
|
false_label_ = &push_false;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
// Convert current context to test context: End pre-test code.
|
|
|
|
|
|
|
|
switch (expr->op()) {
|
|
|
|
case Token::IN: {
|
|
|
|
__ InvokeBuiltin(Builtins::IN, CALL_JS);
|
|
|
|
__ LoadRoot(ip, Heap::kTrueValueRootIndex);
|
|
|
|
__ cmp(r0, ip);
|
|
|
|
__ b(eq, true_label_);
|
|
|
|
__ jmp(false_label_);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case Token::INSTANCEOF: {
|
|
|
|
InstanceofStub stub;
|
|
|
|
__ CallStub(&stub);
|
|
|
|
__ tst(r0, r0);
|
|
|
|
__ b(eq, true_label_); // The stub returns 0 for true.
|
|
|
|
__ jmp(false_label_);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
default: {
|
|
|
|
Condition cc = eq;
|
|
|
|
bool strict = false;
|
|
|
|
switch (expr->op()) {
|
|
|
|
case Token::EQ_STRICT:
|
|
|
|
strict = true;
|
|
|
|
// Fall through
|
|
|
|
case Token::EQ:
|
|
|
|
cc = eq;
|
|
|
|
__ pop(r0);
|
|
|
|
__ pop(r1);
|
|
|
|
break;
|
|
|
|
case Token::LT:
|
|
|
|
cc = lt;
|
|
|
|
__ pop(r0);
|
|
|
|
__ pop(r1);
|
|
|
|
break;
|
|
|
|
case Token::GT:
|
|
|
|
// Reverse left and right sizes to obtain ECMA-262 conversion order.
|
|
|
|
cc = lt;
|
|
|
|
__ pop(r1);
|
|
|
|
__ pop(r0);
|
|
|
|
break;
|
|
|
|
case Token::LTE:
|
|
|
|
// Reverse left and right sizes to obtain ECMA-262 conversion order.
|
|
|
|
cc = ge;
|
|
|
|
__ pop(r1);
|
|
|
|
__ pop(r0);
|
|
|
|
break;
|
|
|
|
case Token::GTE:
|
|
|
|
cc = ge;
|
|
|
|
__ pop(r0);
|
|
|
|
__ pop(r1);
|
|
|
|
break;
|
|
|
|
case Token::IN:
|
|
|
|
case Token::INSTANCEOF:
|
|
|
|
default:
|
|
|
|
UNREACHABLE();
|
|
|
|
}
|
|
|
|
|
|
|
|
// The comparison stub expects the smi vs. smi case to be handled
|
|
|
|
// before it is called.
|
|
|
|
Label slow_case;
|
|
|
|
__ orr(r2, r0, Operand(r1));
|
|
|
|
__ tst(r2, Operand(kSmiTagMask));
|
|
|
|
__ b(ne, &slow_case);
|
|
|
|
__ cmp(r1, r0);
|
|
|
|
__ b(cc, true_label_);
|
|
|
|
__ jmp(false_label_);
|
|
|
|
|
|
|
|
__ bind(&slow_case);
|
|
|
|
CompareStub stub(cc, strict);
|
|
|
|
__ CallStub(&stub);
|
|
|
|
__ tst(r0, r0);
|
|
|
|
__ b(cc, true_label_);
|
|
|
|
__ jmp(false_label_);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Convert current context to test context: Post-test code.
|
|
|
|
switch (expr->context()) {
|
|
|
|
case Expression::kUninitialized:
|
|
|
|
UNREACHABLE();
|
|
|
|
break;
|
|
|
|
|
|
|
|
case Expression::kValue:
|
|
|
|
__ bind(&push_true);
|
|
|
|
__ LoadRoot(ip, Heap::kTrueValueRootIndex);
|
|
|
|
__ push(ip);
|
|
|
|
__ jmp(&done);
|
|
|
|
__ bind(&push_false);
|
|
|
|
__ LoadRoot(ip, Heap::kFalseValueRootIndex);
|
|
|
|
__ push(ip);
|
|
|
|
__ bind(&done);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case Expression::kEffect:
|
|
|
|
__ bind(&done);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case Expression::kTest:
|
|
|
|
break;
|
|
|
|
|
|
|
|
case Expression::kValueTest:
|
|
|
|
__ bind(&push_true);
|
|
|
|
__ LoadRoot(ip, Heap::kTrueValueRootIndex);
|
|
|
|
__ push(ip);
|
|
|
|
__ jmp(saved_true);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case Expression::kTestValue:
|
|
|
|
__ bind(&push_false);
|
|
|
|
__ LoadRoot(ip, Heap::kFalseValueRootIndex);
|
|
|
|
__ push(ip);
|
|
|
|
__ jmp(saved_false);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
true_label_ = saved_true;
|
|
|
|
false_label_ = saved_false;
|
|
|
|
// Convert current context to test context: End post-test code.
|
|
|
|
}
|
|
|
|
|
2009-12-14 11:09:25 +00:00
|
|
|
|
2009-12-07 15:10:39 +00:00
|
|
|
void FastCodeGenerator::VisitThisFunction(ThisFunction* expr) {
|
|
|
|
__ ldr(r0, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
|
|
|
|
Move(expr->context(), r0);
|
|
|
|
}
|
|
|
|
|
2009-11-02 15:01:06 +00:00
|
|
|
|
2009-12-10 14:06:08 +00:00
|
|
|
Register FastCodeGenerator::result_register() { return r0; }
|
|
|
|
|
2009-12-16 09:51:07 +00:00
|
|
|
|
|
|
|
Register FastCodeGenerator::context_register() { return cp; }
|
|
|
|
|
|
|
|
|
|
|
|
void FastCodeGenerator::StoreToFrameField(int frame_offset, Register value) {
|
|
|
|
ASSERT_EQ(POINTER_SIZE_ALIGN(frame_offset), frame_offset);
|
|
|
|
__ str(value, MemOperand(fp, frame_offset));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void FastCodeGenerator::LoadContextField(Register dst, int context_index) {
|
|
|
|
__ ldr(dst, CodeGenerator::ContextOperand(cp, context_index));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-12-14 11:09:25 +00:00
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
// Non-local control flow support.
|
|
|
|
|
|
|
|
void FastCodeGenerator::EnterFinallyBlock() {
|
|
|
|
ASSERT(!result_register().is(r1));
|
2009-12-16 09:51:07 +00:00
|
|
|
// Store result register while executing finally block.
|
|
|
|
__ push(result_register());
|
2009-12-14 11:09:25 +00:00
|
|
|
// Cook return address in link register to stack (smi encoded Code* delta)
|
|
|
|
__ sub(r1, lr, Operand(masm_->CodeObject()));
|
|
|
|
ASSERT_EQ(1, kSmiTagSize + kSmiShiftSize);
|
|
|
|
ASSERT_EQ(0, kSmiTag);
|
|
|
|
__ add(r1, r1, Operand(r1)); // Convert to smi.
|
|
|
|
__ push(r1);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void FastCodeGenerator::ExitFinallyBlock() {
|
|
|
|
ASSERT(!result_register().is(r1));
|
|
|
|
// Restore result register from stack.
|
|
|
|
__ pop(r1);
|
2009-12-16 09:51:07 +00:00
|
|
|
// Uncook return address and return.
|
|
|
|
__ pop(result_register());
|
2009-12-14 11:09:25 +00:00
|
|
|
ASSERT_EQ(1, kSmiTagSize + kSmiShiftSize);
|
|
|
|
__ mov(r1, Operand(r1, ASR, 1)); // Un-smi-tag value.
|
|
|
|
__ add(pc, r1, Operand(masm_->CodeObject()));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#undef __
|
2009-11-02 15:01:06 +00:00
|
|
|
|
Initial port of top-level code generator to ARM. For the constant
true at the top level we generate:
0 stmdb sp!, {r1, r8, fp, lr}
4 add fp, sp, #8
8 ldr ip, [r10, #+4]
12 ldr r2, [r10, #+0]
16 str ip, [sp, #-4]!
20 add lr, pc, #4
24 cmp sp, r2
28 ldrcc pc, [pc, #+68] ;; code: STUB, StackCheck, minor: 0
32 ldr ip, [pc, #+68] ;; object: 0xf5bc4161 <true>
36 str ip, [sp, #-4]!
40 ldr ip, [sp, #+0]
44 str ip, [fp, #-12]
48 add sp, sp, #4
52 ldr ip, [fp, #-12]
56 str ip, [sp, #-4]!
60 ldr r0, [sp], #+4
64 mov sp, fp ;; js return
68 ldmia sp!, {fp, lr}
72 add sp, sp, #4
76 bx lr
80 ldr r0, [r10, #+4]
84 mov sp, fp ;; js return
88 ldmia sp!, {fp, lr}
92 add sp, sp, #4
96 bx lr
100 constant pool begin
104 constant
108 constant
Review URL: http://codereview.chromium.org/264067
git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@3073 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2009-10-15 12:42:16 +00:00
|
|
|
} } // namespace v8::internal
|