Port the initial fast code generator to x64. For the constant true in
top-level code we generate:
0 push rbp
1 movq rbp,rsp
4 push rsi
5 push rdi
6 push [r13+0x8]
10 cmpq rsp,[r13+0x0]
14 jnc 25 (0x7ff2c378ff19)
20 call 0x7ff2c377d260 ;; code: STUB, StackCheck, minor: 0
25 movq r10,0x7ff2e8608199 ;; object: 0x7ff2e8608199 <true>
35 push r10
37 movq rax,[rsp]
41 movq [rbp-0x18],rax
45 pop rax
46 push [rbp-0x18]
50 pop rax
51 movq rsp,rbp ;; js return
54 pop rbp
55 ret 0x8
58 int3
59 int3
60 int3
61 int3
62 int3
63 int3
64 movq rax,[r13+0x8]
68 movq rsp,rbp ;; js return
71 pop rbp
72 ret 0x8
75 int3
76 int3
77 int3
78 int3
79 int3
80 int3
Review URL: http://codereview.chromium.org/264066
git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@3071 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2009-10-15 11:21:26 +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"
|
|
|
|
#include "debug.h"
|
|
|
|
#include "fast-codegen.h"
|
2009-10-22 10:07:45 +00:00
|
|
|
#include "parser.h"
|
Port the initial fast code generator to x64. For the constant true in
top-level code we generate:
0 push rbp
1 movq rbp,rsp
4 push rsi
5 push rdi
6 push [r13+0x8]
10 cmpq rsp,[r13+0x0]
14 jnc 25 (0x7ff2c378ff19)
20 call 0x7ff2c377d260 ;; code: STUB, StackCheck, minor: 0
25 movq r10,0x7ff2e8608199 ;; object: 0x7ff2e8608199 <true>
35 push r10
37 movq rax,[rsp]
41 movq [rbp-0x18],rax
45 pop rax
46 push [rbp-0x18]
50 pop rax
51 movq rsp,rbp ;; js return
54 pop rbp
55 ret 0x8
58 int3
59 int3
60 int3
61 int3
62 int3
63 int3
64 movq rax,[r13+0x8]
68 movq rsp,rbp ;; js return
71 pop rbp
72 ret 0x8
75 int3
76 int3
77 int3
78 int3
79 int3
80 int3
Review URL: http://codereview.chromium.org/264066
git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@3071 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2009-10-15 11:21:26 +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, with the
|
|
|
|
// return address on top of them. The actual argument count matches the
|
|
|
|
// formal parameter count expected by the function.
|
|
|
|
//
|
|
|
|
// The live registers are:
|
|
|
|
// o rdi: the JS function object being called (ie, ourselves)
|
|
|
|
// o rsi: our context
|
|
|
|
// o rbp: our caller's frame pointer
|
|
|
|
// o rsp: stack pointer (pointing to return address)
|
|
|
|
//
|
|
|
|
// The function builds a JS frame. Please see JavaScriptFrameConstants in
|
|
|
|
// frames-x64.h for its layout.
|
|
|
|
void FastCodeGenerator::Generate(FunctionLiteral* fun) {
|
|
|
|
function_ = fun;
|
2009-10-15 15:27:37 +00:00
|
|
|
SetFunctionPosition(fun);
|
Port the initial fast code generator to x64. For the constant true in
top-level code we generate:
0 push rbp
1 movq rbp,rsp
4 push rsi
5 push rdi
6 push [r13+0x8]
10 cmpq rsp,[r13+0x0]
14 jnc 25 (0x7ff2c378ff19)
20 call 0x7ff2c377d260 ;; code: STUB, StackCheck, minor: 0
25 movq r10,0x7ff2e8608199 ;; object: 0x7ff2e8608199 <true>
35 push r10
37 movq rax,[rsp]
41 movq [rbp-0x18],rax
45 pop rax
46 push [rbp-0x18]
50 pop rax
51 movq rsp,rbp ;; js return
54 pop rbp
55 ret 0x8
58 int3
59 int3
60 int3
61 int3
62 int3
63 int3
64 movq rax,[r13+0x8]
68 movq rsp,rbp ;; js return
71 pop rbp
72 ret 0x8
75 int3
76 int3
77 int3
78 int3
79 int3
80 int3
Review URL: http://codereview.chromium.org/264066
git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@3071 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2009-10-15 11:21:26 +00:00
|
|
|
|
|
|
|
__ push(rbp); // Caller's frame pointer.
|
|
|
|
__ movq(rbp, rsp);
|
|
|
|
__ push(rsi); // Callee's context.
|
|
|
|
__ push(rdi); // Callee's JS Function.
|
|
|
|
|
|
|
|
{ Comment cmnt(masm_, "[ Allocate locals");
|
|
|
|
int locals_count = fun->scope()->num_stack_slots();
|
|
|
|
for (int i = 0; i < locals_count; i++) {
|
|
|
|
__ PushRoot(Heap::kUndefinedValueRootIndex);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
{ Comment cmnt(masm_, "[ Stack check");
|
|
|
|
Label ok;
|
|
|
|
__ CompareRoot(rsp, Heap::kStackLimitRootIndex);
|
|
|
|
__ j(above_equal, &ok);
|
|
|
|
StackCheckStub stub;
|
|
|
|
__ CallStub(&stub);
|
|
|
|
__ bind(&ok);
|
|
|
|
}
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
Port the initial fast code generator to x64. For the constant true in
top-level code we generate:
0 push rbp
1 movq rbp,rsp
4 push rsi
5 push rdi
6 push [r13+0x8]
10 cmpq rsp,[r13+0x0]
14 jnc 25 (0x7ff2c378ff19)
20 call 0x7ff2c377d260 ;; code: STUB, StackCheck, minor: 0
25 movq r10,0x7ff2e8608199 ;; object: 0x7ff2e8608199 <true>
35 push r10
37 movq rax,[rsp]
41 movq [rbp-0x18],rax
45 pop rax
46 push [rbp-0x18]
50 pop rax
51 movq rsp,rbp ;; js return
54 pop rbp
55 ret 0x8
58 int3
59 int3
60 int3
61 int3
62 int3
63 int3
64 movq rax,[r13+0x8]
68 movq rsp,rbp ;; js return
71 pop rbp
72 ret 0x8
75 int3
76 int3
77 int3
78 int3
79 int3
80 int3
Review URL: http://codereview.chromium.org/264066
git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@3071 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2009-10-15 11:21:26 +00:00
|
|
|
{ Comment cmnt(masm_, "[ Body");
|
|
|
|
VisitStatements(fun->body());
|
|
|
|
}
|
|
|
|
|
|
|
|
{ Comment cmnt(masm_, "[ return <undefined>;");
|
|
|
|
// Emit a 'return undefined' in case control fell off the end of the
|
|
|
|
// body.
|
|
|
|
__ LoadRoot(rax, Heap::kUndefinedValueRootIndex);
|
2009-10-30 10:22:31 +00:00
|
|
|
}
|
|
|
|
{ Comment cmnt(masm_, "Return sequence");
|
2009-10-15 15:27:37 +00:00
|
|
|
SetReturnPosition(fun);
|
2009-10-22 11:21:29 +00:00
|
|
|
|
2009-10-30 10:22:31 +00:00
|
|
|
if (return_label_.is_bound()) {
|
|
|
|
__ jmp(&return_label_);
|
|
|
|
} else {
|
|
|
|
__ bind(&return_label_);
|
|
|
|
|
|
|
|
if (FLAG_trace) {
|
|
|
|
__ push(rax);
|
|
|
|
__ CallRuntime(Runtime::kTraceExit, 1);
|
|
|
|
}
|
|
|
|
__ RecordJSReturn();
|
|
|
|
|
|
|
|
// Do not use the leave instruction here because it is too short to
|
|
|
|
// patch with the code required by the debugger.
|
|
|
|
__ movq(rsp, rbp);
|
|
|
|
__ pop(rbp);
|
|
|
|
__ ret((fun->scope()->num_parameters() + 1) * kPointerSize);
|
Port the initial fast code generator to x64. For the constant true in
top-level code we generate:
0 push rbp
1 movq rbp,rsp
4 push rsi
5 push rdi
6 push [r13+0x8]
10 cmpq rsp,[r13+0x0]
14 jnc 25 (0x7ff2c378ff19)
20 call 0x7ff2c377d260 ;; code: STUB, StackCheck, minor: 0
25 movq r10,0x7ff2e8608199 ;; object: 0x7ff2e8608199 <true>
35 push r10
37 movq rax,[rsp]
41 movq [rbp-0x18],rax
45 pop rax
46 push [rbp-0x18]
50 pop rax
51 movq rsp,rbp ;; js return
54 pop rbp
55 ret 0x8
58 int3
59 int3
60 int3
61 int3
62 int3
63 int3
64 movq rax,[r13+0x8]
68 movq rsp,rbp ;; js return
71 pop rbp
72 ret 0x8
75 int3
76 int3
77 int3
78 int3
79 int3
80 int3
Review URL: http://codereview.chromium.org/264066
git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@3071 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2009-10-15 11:21:26 +00:00
|
|
|
#ifdef ENABLE_DEBUGGER_SUPPORT
|
2009-10-30 10:22:31 +00:00
|
|
|
// Add padding that will be overwritten by a debugger breakpoint. We
|
|
|
|
// have just generated "movq rsp, rbp; pop rbp; ret k" with length 7
|
|
|
|
// (3 + 1 + 3).
|
|
|
|
const int kPadding = Debug::kX64JSReturnSequenceLength - 7;
|
|
|
|
for (int i = 0; i < kPadding; ++i) {
|
|
|
|
masm_->int3();
|
|
|
|
}
|
Port the initial fast code generator to x64. For the constant true in
top-level code we generate:
0 push rbp
1 movq rbp,rsp
4 push rsi
5 push rdi
6 push [r13+0x8]
10 cmpq rsp,[r13+0x0]
14 jnc 25 (0x7ff2c378ff19)
20 call 0x7ff2c377d260 ;; code: STUB, StackCheck, minor: 0
25 movq r10,0x7ff2e8608199 ;; object: 0x7ff2e8608199 <true>
35 push r10
37 movq rax,[rsp]
41 movq [rbp-0x18],rax
45 pop rax
46 push [rbp-0x18]
50 pop rax
51 movq rsp,rbp ;; js return
54 pop rbp
55 ret 0x8
58 int3
59 int3
60 int3
61 int3
62 int3
63 int3
64 movq rax,[r13+0x8]
68 movq rsp,rbp ;; js return
71 pop rbp
72 ret 0x8
75 int3
76 int3
77 int3
78 int3
79 int3
80 int3
Review URL: http://codereview.chromium.org/264066
git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@3071 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2009-10-15 11:21:26 +00:00
|
|
|
#endif
|
2009-10-30 10:22:31 +00:00
|
|
|
}
|
Port the initial fast code generator to x64. For the constant true in
top-level code we generate:
0 push rbp
1 movq rbp,rsp
4 push rsi
5 push rdi
6 push [r13+0x8]
10 cmpq rsp,[r13+0x0]
14 jnc 25 (0x7ff2c378ff19)
20 call 0x7ff2c377d260 ;; code: STUB, StackCheck, minor: 0
25 movq r10,0x7ff2e8608199 ;; object: 0x7ff2e8608199 <true>
35 push r10
37 movq rax,[rsp]
41 movq [rbp-0x18],rax
45 pop rax
46 push [rbp-0x18]
50 pop rax
51 movq rsp,rbp ;; js return
54 pop rbp
55 ret 0x8
58 int3
59 int3
60 int3
61 int3
62 int3
63 int3
64 movq rax,[r13+0x8]
68 movq rsp,rbp ;; js return
71 pop rbp
72 ret 0x8
75 int3
76 int3
77 int3
78 int3
79 int3
80 int3
Review URL: http://codereview.chromium.org/264066
git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@3071 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2009-10-15 11:21:26 +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) {
|
|
|
|
switch (context) {
|
|
|
|
case Expression::kUninitialized:
|
|
|
|
UNREACHABLE();
|
|
|
|
case Expression::kEffect:
|
|
|
|
break;
|
|
|
|
case Expression::kValue:
|
|
|
|
__ 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);
|
|
|
|
__ addq(rsp, Immediate(kPointerSize));
|
|
|
|
__ jmp(false_label_);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case Expression::kTestValue: {
|
|
|
|
Label discard;
|
|
|
|
__ push(source);
|
|
|
|
TestAndBranch(source, &discard, false_label_);
|
|
|
|
__ bind(&discard);
|
|
|
|
__ addq(rsp, Immediate(kPointerSize));
|
|
|
|
__ jmp(true_label_);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-10-30 08:36:46 +00:00
|
|
|
void FastCodeGenerator::Move(Expression::Context context, Slot* source) {
|
|
|
|
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:
|
2009-10-27 13:38:57 +00:00
|
|
|
__ push(Operand(rbp, SlotOffset(source)));
|
|
|
|
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: // Fall through.
|
|
|
|
case Expression::kValueTest: // Fall through.
|
|
|
|
case Expression::kTestValue:
|
|
|
|
__ movq(rax, Operand(rbp, SlotOffset(source)));
|
|
|
|
Move(context, rax);
|
|
|
|
break;
|
2009-10-27 13:38:57 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
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;
|
2009-10-30 08:36:46 +00:00
|
|
|
case Expression::kValue:
|
2009-10-27 13:38:57 +00:00
|
|
|
__ Push(expr->handle());
|
|
|
|
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: // Fall through.
|
|
|
|
case Expression::kValueTest: // Fall through.
|
|
|
|
case Expression::kTestValue:
|
|
|
|
__ Move(rax, expr->handle());
|
|
|
|
Move(context, rax);
|
|
|
|
break;
|
2009-10-27 13:38:57 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-10-30 08:36:46 +00:00
|
|
|
void FastCodeGenerator::DropAndMove(Expression::Context context,
|
|
|
|
Register source) {
|
|
|
|
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-10-28 09:56:14 +00:00
|
|
|
__ addq(rsp, Immediate(kPointerSize));
|
|
|
|
break;
|
2009-10-30 08:36:46 +00:00
|
|
|
case Expression::kValue:
|
2009-10-28 09:56:14 +00:00
|
|
|
__ movq(Operand(rsp, 0), source);
|
|
|
|
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(rsp));
|
|
|
|
__ addq(rsp, Immediate(kPointerSize));
|
|
|
|
TestAndBranch(source, true_label_, false_label_);
|
|
|
|
break;
|
|
|
|
case Expression::kValueTest: {
|
|
|
|
Label discard;
|
|
|
|
__ movq(Operand(rsp, 0), source);
|
|
|
|
TestAndBranch(source, true_label_, &discard);
|
|
|
|
__ bind(&discard);
|
|
|
|
__ addq(rsp, Immediate(kPointerSize));
|
|
|
|
__ jmp(false_label_);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case Expression::kTestValue: {
|
|
|
|
Label discard;
|
|
|
|
__ movq(Operand(rsp, 0), source);
|
|
|
|
TestAndBranch(source, &discard, false_label_);
|
|
|
|
__ bind(&discard);
|
|
|
|
__ addq(rsp, Immediate(kPointerSize));
|
|
|
|
__ 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);
|
|
|
|
// Use the shared ToBoolean stub to compile the value in the register into
|
|
|
|
// control flow to the code generator's true and false labels. Perform
|
|
|
|
// the fast checks assumed by the stub.
|
|
|
|
|
|
|
|
// The undefined value is false.
|
|
|
|
__ CompareRoot(source, Heap::kUndefinedValueRootIndex);
|
|
|
|
__ j(equal, false_label);
|
|
|
|
__ CompareRoot(source, Heap::kTrueValueRootIndex); // True is true.
|
|
|
|
__ j(equal, true_label);
|
|
|
|
__ CompareRoot(source, Heap::kFalseValueRootIndex); // False is false.
|
|
|
|
__ j(equal, false_label);
|
|
|
|
ASSERT_EQ(0, kSmiTag);
|
|
|
|
__ SmiCompare(source, Smi::FromInt(0)); // The smi zero is false.
|
|
|
|
__ j(equal, false_label);
|
|
|
|
Condition is_smi = masm_->CheckSmi(source); // All other smis are true.
|
|
|
|
__ j(is_smi, true_label);
|
|
|
|
|
|
|
|
// Call the stub for all other cases.
|
|
|
|
__ push(source);
|
|
|
|
ToBooleanStub stub;
|
|
|
|
__ CallStub(&stub);
|
|
|
|
__ testq(rax, rax); // The stub returns nonzero for true.
|
|
|
|
__ j(not_zero, true_label);
|
|
|
|
__ jmp(false_label);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
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
|
|
|
__ push(rsi); // The context is the first argument.
|
2009-10-21 09:17:39 +00:00
|
|
|
__ Push(pairs);
|
|
|
|
__ Push(Smi::FromInt(is_eval_ ? 1 : 0));
|
|
|
|
__ CallRuntime(Runtime::kDeclareGlobals, 3);
|
|
|
|
// Return value is ignored.
|
|
|
|
}
|
|
|
|
|
|
|
|
|
Port the initial fast code generator to x64. For the constant true in
top-level code we generate:
0 push rbp
1 movq rbp,rsp
4 push rsi
5 push rdi
6 push [r13+0x8]
10 cmpq rsp,[r13+0x0]
14 jnc 25 (0x7ff2c378ff19)
20 call 0x7ff2c377d260 ;; code: STUB, StackCheck, minor: 0
25 movq r10,0x7ff2e8608199 ;; object: 0x7ff2e8608199 <true>
35 push r10
37 movq rax,[rsp]
41 movq [rbp-0x18],rax
45 pop rax
46 push [rbp-0x18]
50 pop rax
51 movq rsp,rbp ;; js return
54 pop rbp
55 ret 0x8
58 int3
59 int3
60 int3
61 int3
62 int3
63 int3
64 movq rax,[r13+0x8]
68 movq rsp,rbp ;; js return
71 pop rbp
72 ret 0x8
75 int3
76 int3
77 int3
78 int3
79 int3
80 int3
Review URL: http://codereview.chromium.org/264066
git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@3071 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2009-10-15 11:21:26 +00:00
|
|
|
void FastCodeGenerator::VisitReturnStatement(ReturnStatement* stmt) {
|
|
|
|
Comment cmnt(masm_, "[ ReturnStatement");
|
2009-10-15 15:27:37 +00:00
|
|
|
SetStatementPosition(stmt);
|
2009-10-19 10:36:42 +00:00
|
|
|
Expression* expr = stmt->expression();
|
2009-10-27 08:48:01 +00:00
|
|
|
if (expr->AsLiteral() != NULL) {
|
2009-10-19 10:36:42 +00:00
|
|
|
__ Move(rax, expr->AsLiteral()->handle());
|
2009-10-27 08:48:01 +00:00
|
|
|
} else {
|
|
|
|
Visit(expr);
|
2009-10-30 08:36:46 +00:00
|
|
|
ASSERT_EQ(Expression::kValue, expr->context());
|
|
|
|
__ pop(rax);
|
2009-10-19 10:36:42 +00:00
|
|
|
}
|
2009-10-27 08:48:01 +00:00
|
|
|
|
2009-10-30 10:22:31 +00:00
|
|
|
if (return_label_.is_bound()) {
|
|
|
|
__ jmp(&return_label_);
|
|
|
|
} else {
|
|
|
|
__ bind(&return_label_);
|
|
|
|
|
|
|
|
if (FLAG_trace) {
|
|
|
|
__ push(rax);
|
|
|
|
__ CallRuntime(Runtime::kTraceExit, 1);
|
|
|
|
}
|
2009-10-22 11:21:29 +00:00
|
|
|
|
2009-10-30 10:22:31 +00:00
|
|
|
__ RecordJSReturn();
|
|
|
|
// Do not use the leave instruction here because it is too short to
|
|
|
|
// patch with the code required by the debugger.
|
|
|
|
__ movq(rsp, rbp);
|
|
|
|
__ pop(rbp);
|
|
|
|
__ ret((function_->scope()->num_parameters() + 1) * kPointerSize);
|
Port the initial fast code generator to x64. For the constant true in
top-level code we generate:
0 push rbp
1 movq rbp,rsp
4 push rsi
5 push rdi
6 push [r13+0x8]
10 cmpq rsp,[r13+0x0]
14 jnc 25 (0x7ff2c378ff19)
20 call 0x7ff2c377d260 ;; code: STUB, StackCheck, minor: 0
25 movq r10,0x7ff2e8608199 ;; object: 0x7ff2e8608199 <true>
35 push r10
37 movq rax,[rsp]
41 movq [rbp-0x18],rax
45 pop rax
46 push [rbp-0x18]
50 pop rax
51 movq rsp,rbp ;; js return
54 pop rbp
55 ret 0x8
58 int3
59 int3
60 int3
61 int3
62 int3
63 int3
64 movq rax,[r13+0x8]
68 movq rsp,rbp ;; js return
71 pop rbp
72 ret 0x8
75 int3
76 int3
77 int3
78 int3
79 int3
80 int3
Review URL: http://codereview.chromium.org/264066
git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@3071 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2009-10-15 11:21:26 +00:00
|
|
|
#ifdef ENABLE_DEBUGGER_SUPPORT
|
2009-10-30 10:22:31 +00:00
|
|
|
// Add padding that will be overwritten by a debugger breakpoint. We
|
|
|
|
// have just generated "movq rsp, rbp; pop rbp; ret k" with length 7
|
|
|
|
// (3 + 1 + 3).
|
|
|
|
const int kPadding = Debug::kX64JSReturnSequenceLength - 7;
|
|
|
|
for (int i = 0; i < kPadding; ++i) {
|
|
|
|
masm_->int3();
|
|
|
|
}
|
Port the initial fast code generator to x64. For the constant true in
top-level code we generate:
0 push rbp
1 movq rbp,rsp
4 push rsi
5 push rdi
6 push [r13+0x8]
10 cmpq rsp,[r13+0x0]
14 jnc 25 (0x7ff2c378ff19)
20 call 0x7ff2c377d260 ;; code: STUB, StackCheck, minor: 0
25 movq r10,0x7ff2e8608199 ;; object: 0x7ff2e8608199 <true>
35 push r10
37 movq rax,[rsp]
41 movq [rbp-0x18],rax
45 pop rax
46 push [rbp-0x18]
50 pop rax
51 movq rsp,rbp ;; js return
54 pop rbp
55 ret 0x8
58 int3
59 int3
60 int3
61 int3
62 int3
63 int3
64 movq rax,[r13+0x8]
68 movq rsp,rbp ;; js return
71 pop rbp
72 ret 0x8
75 int3
76 int3
77 int3
78 int3
79 int3
80 int3
Review URL: http://codereview.chromium.org/264066
git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@3071 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2009-10-15 11:21:26 +00:00
|
|
|
#endif
|
2009-10-30 10:22:31 +00:00
|
|
|
}
|
Port the initial fast code generator to x64. For the constant true in
top-level code we generate:
0 push rbp
1 movq rbp,rsp
4 push rsi
5 push rdi
6 push [r13+0x8]
10 cmpq rsp,[r13+0x0]
14 jnc 25 (0x7ff2c378ff19)
20 call 0x7ff2c377d260 ;; code: STUB, StackCheck, minor: 0
25 movq r10,0x7ff2e8608199 ;; object: 0x7ff2e8608199 <true>
35 push r10
37 movq rax,[rsp]
41 movq [rbp-0x18],rax
45 pop rax
46 push [rbp-0x18]
50 pop rax
51 movq rsp,rbp ;; js return
54 pop rbp
55 ret 0x8
58 int3
59 int3
60 int3
61 int3
62 int3
63 int3
64 movq rax,[r13+0x8]
68 movq rsp,rbp ;; js return
71 pop rbp
72 ret 0x8
75 int3
76 int3
77 int3
78 int3
79 int3
80 int3
Review URL: http://codereview.chromium.org/264066
git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@3071 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2009-10-15 11:21:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-10-21 09:17:39 +00:00
|
|
|
void FastCodeGenerator::VisitFunctionLiteral(FunctionLiteral* expr) {
|
|
|
|
Comment cmnt(masm_, "[ FunctionLiteral");
|
|
|
|
|
|
|
|
// Build the function boilerplate and instantiate it.
|
|
|
|
Handle<JSFunction> boilerplate = BuildBoilerplate(expr);
|
|
|
|
if (HasStackOverflow()) return;
|
|
|
|
|
|
|
|
ASSERT(boilerplate->IsBoilerplate());
|
|
|
|
|
|
|
|
// Create a new closure.
|
|
|
|
__ push(rsi);
|
2009-10-22 10:07:45 +00:00
|
|
|
__ Push(boilerplate);
|
2009-10-21 09:17:39 +00:00
|
|
|
__ CallRuntime(Runtime::kNewClosure, 2);
|
2009-10-30 08:36:46 +00:00
|
|
|
Move(expr->context(), rax);
|
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");
|
|
|
|
Expression* rewrite = expr->var()->rewrite();
|
2009-10-21 09:38:21 +00:00
|
|
|
if (rewrite == NULL) {
|
|
|
|
Comment cmnt(masm_, "Global variable");
|
|
|
|
// Use inline caching. Variable name is passed in rcx and the global
|
|
|
|
// object on the stack.
|
|
|
|
__ push(CodeGenerator::GlobalObject());
|
|
|
|
__ Move(rcx, expr->name());
|
|
|
|
Handle<Code> ic(Builtins::builtin(Builtins::LoadIC_Initialize));
|
|
|
|
__ Call(ic, RelocInfo::CODE_TARGET_CONTEXT);
|
|
|
|
|
|
|
|
// A test rax instruction following the call is used by the IC to
|
|
|
|
// indicate that the inobject property case was inlined. Ensure there
|
|
|
|
// is no test rax instruction here.
|
2009-10-30 08:36:46 +00:00
|
|
|
DropAndMove(expr->context(), rax);
|
2009-10-21 09:38:21 +00:00
|
|
|
} else {
|
|
|
|
Comment cmnt(masm_, "Stack slot");
|
2009-10-30 08:36:46 +00:00
|
|
|
Move(expr->context(), rewrite->AsSlot());
|
2009-10-27 08:48:01 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-10-29 10:35:29 +00:00
|
|
|
void FastCodeGenerator::VisitRegExpLiteral(RegExpLiteral* expr) {
|
|
|
|
Comment cmnt(masm_, "[ RegExp Literal");
|
|
|
|
Label done;
|
|
|
|
// Registers will be used as follows:
|
|
|
|
// rdi = JS function.
|
|
|
|
// rbx = literals array.
|
|
|
|
// rax = regexp literal.
|
|
|
|
__ movq(rdi, Operand(rbp, JavaScriptFrameConstants::kFunctionOffset));
|
|
|
|
__ movq(rbx, FieldOperand(rdi, JSFunction::kLiteralsOffset));
|
|
|
|
int literal_offset =
|
|
|
|
FixedArray::kHeaderSize + expr->literal_index() * kPointerSize;
|
|
|
|
__ movq(rax, FieldOperand(rbx, literal_offset));
|
|
|
|
__ CompareRoot(rax, Heap::kUndefinedValueRootIndex);
|
|
|
|
__ j(not_equal, &done);
|
|
|
|
// Create regexp literal using runtime function
|
|
|
|
// Result will be in rax.
|
|
|
|
__ push(rbx);
|
|
|
|
__ Push(Smi::FromInt(expr->literal_index()));
|
|
|
|
__ Push(expr->pattern());
|
|
|
|
__ Push(expr->flags());
|
|
|
|
__ CallRuntime(Runtime::kMaterializeRegExpLiteral, 4);
|
|
|
|
// Label done:
|
|
|
|
__ bind(&done);
|
2009-10-30 08:36:46 +00:00
|
|
|
Move(expr->context(), rax);
|
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");
|
|
|
|
Label boilerplate_exists;
|
|
|
|
|
|
|
|
__ movq(rdi, Operand(rbp, JavaScriptFrameConstants::kFunctionOffset));
|
|
|
|
__ movq(rbx, FieldOperand(rdi, JSFunction::kLiteralsOffset));
|
|
|
|
int literal_offset =
|
|
|
|
FixedArray::kHeaderSize + expr->literal_index() * kPointerSize;
|
|
|
|
__ movq(rax, FieldOperand(rbx, literal_offset));
|
|
|
|
__ CompareRoot(rax, Heap::kUndefinedValueRootIndex);
|
|
|
|
__ j(not_equal, &boilerplate_exists);
|
|
|
|
// Create boilerplate if it does not exist.
|
|
|
|
// Literal array (0).
|
|
|
|
__ push(rbx);
|
|
|
|
// Literal index (1).
|
|
|
|
__ Push(Smi::FromInt(expr->literal_index()));
|
|
|
|
// Constant properties (2).
|
|
|
|
__ Push(expr->constant_properties());
|
|
|
|
__ CallRuntime(Runtime::kCreateObjectLiteralBoilerplate, 3);
|
|
|
|
__ bind(&boilerplate_exists);
|
|
|
|
// rax contains boilerplate.
|
|
|
|
// Clone boilerplate.
|
|
|
|
__ push(rax);
|
|
|
|
if (expr->depth() == 1) {
|
|
|
|
__ CallRuntime(Runtime::kCloneShallowLiteralBoilerplate, 1);
|
|
|
|
} else {
|
|
|
|
__ CallRuntime(Runtime::kCloneLiteralBoilerplate, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
// If result_saved == true: the result is saved on top of the stack.
|
|
|
|
// If result_saved == false: the result is not on the stack, just in rax.
|
|
|
|
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(rax); // Save result on the stack
|
|
|
|
result_saved = true;
|
|
|
|
}
|
|
|
|
switch (property->kind()) {
|
|
|
|
case ObjectLiteral::Property::MATERIALIZED_LITERAL: // fall through
|
|
|
|
ASSERT(!CompileTimeValue::IsCompileTimeValue(value));
|
|
|
|
case ObjectLiteral::Property::COMPUTED:
|
|
|
|
if (key->handle()->IsSymbol()) {
|
|
|
|
Visit(value);
|
2009-10-30 08:36:46 +00:00
|
|
|
ASSERT_EQ(Expression::kValue, value->context());
|
2009-10-26 13:21:48 +00:00
|
|
|
__ pop(rax);
|
|
|
|
__ Move(rcx, key->handle());
|
|
|
|
Handle<Code> ic(Builtins::builtin(Builtins::StoreIC_Initialize));
|
|
|
|
__ call(ic, RelocInfo::CODE_TARGET);
|
|
|
|
// StoreIC leaves the receiver on the stack.
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
// fall through
|
|
|
|
case ObjectLiteral::Property::PROTOTYPE:
|
|
|
|
__ push(rax);
|
|
|
|
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);
|
|
|
|
__ movq(rax, Operand(rsp, 0)); // Restore result into rax.
|
|
|
|
break;
|
|
|
|
case ObjectLiteral::Property::SETTER: // fall through
|
|
|
|
case ObjectLiteral::Property::GETTER:
|
|
|
|
__ push(rax);
|
|
|
|
Visit(key);
|
2009-10-30 08:36:46 +00:00
|
|
|
ASSERT_EQ(Expression::kValue, key->context());
|
2009-10-26 13:21:48 +00:00
|
|
|
__ Push(property->kind() == ObjectLiteral::Property::SETTER ?
|
|
|
|
Smi::FromInt(1) :
|
|
|
|
Smi::FromInt(0));
|
|
|
|
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);
|
|
|
|
__ movq(rax, Operand(rsp, 0)); // Restore result into rax.
|
|
|
|
break;
|
|
|
|
default: UNREACHABLE();
|
|
|
|
}
|
|
|
|
}
|
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) __ addq(rsp, Immediate(kPointerSize));
|
|
|
|
break;
|
2009-10-30 08:36:46 +00:00
|
|
|
case Expression::kValue:
|
2009-10-27 13:38:57 +00:00
|
|
|
if (!result_saved) __ push(rax);
|
|
|
|
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(rax);
|
|
|
|
TestAndBranch(rax, true_label_, false_label_);
|
|
|
|
break;
|
|
|
|
case Expression::kValueTest: {
|
|
|
|
Label discard;
|
|
|
|
if (!result_saved) __ push(rax);
|
|
|
|
TestAndBranch(rax, true_label_, &discard);
|
|
|
|
__ bind(&discard);
|
|
|
|
__ addq(rsp, Immediate(kPointerSize));
|
|
|
|
__ jmp(false_label_);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case Expression::kTestValue: {
|
|
|
|
Label discard;
|
|
|
|
if (!result_saved) __ push(rax);
|
|
|
|
TestAndBranch(rax, &discard, false_label_);
|
|
|
|
__ bind(&discard);
|
|
|
|
__ addq(rsp, Immediate(kPointerSize));
|
|
|
|
__ 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");
|
|
|
|
Label make_clone;
|
|
|
|
|
|
|
|
// Fetch the function's literals array.
|
|
|
|
__ movq(rbx, Operand(rbp, JavaScriptFrameConstants::kFunctionOffset));
|
|
|
|
__ movq(rbx, FieldOperand(rbx, JSFunction::kLiteralsOffset));
|
|
|
|
// Check if the literal's boilerplate has been instantiated.
|
|
|
|
int offset =
|
|
|
|
FixedArray::kHeaderSize + (expr->literal_index() * kPointerSize);
|
|
|
|
__ movq(rax, FieldOperand(rbx, offset));
|
|
|
|
__ CompareRoot(rax, Heap::kUndefinedValueRootIndex);
|
|
|
|
__ j(not_equal, &make_clone);
|
|
|
|
|
|
|
|
// Instantiate the boilerplate.
|
|
|
|
__ push(rbx);
|
|
|
|
__ Push(Smi::FromInt(expr->literal_index()));
|
|
|
|
__ Push(expr->literals());
|
|
|
|
__ CallRuntime(Runtime::kCreateArrayLiteralBoilerplate, 3);
|
|
|
|
|
|
|
|
__ bind(&make_clone);
|
|
|
|
// Clone the boilerplate.
|
|
|
|
__ push(rax);
|
|
|
|
if (expr->depth() > 1) {
|
|
|
|
__ CallRuntime(Runtime::kCloneLiteralBoilerplate, 1);
|
|
|
|
} else {
|
|
|
|
__ CallRuntime(Runtime::kCloneShallowLiteralBoilerplate, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
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(rax);
|
|
|
|
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(rax); // Subexpression value.
|
|
|
|
__ movq(rbx, Operand(rsp, 0)); // Copy of array literal.
|
|
|
|
__ movq(rbx, FieldOperand(rbx, JSObject::kElementsOffset));
|
|
|
|
int offset = FixedArray::kHeaderSize + (i * kPointerSize);
|
|
|
|
__ movq(FieldOperand(rbx, offset), rax);
|
|
|
|
|
|
|
|
// Update the write barrier for the array store.
|
|
|
|
__ RecordWrite(rbx, offset, rax, rcx);
|
|
|
|
}
|
|
|
|
|
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) __ addq(rsp, Immediate(kPointerSize));
|
|
|
|
break;
|
2009-10-30 08:36:46 +00:00
|
|
|
case Expression::kValue:
|
2009-10-27 13:38:57 +00:00
|
|
|
if (!result_saved) __ push(rax);
|
|
|
|
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(rax);
|
|
|
|
TestAndBranch(rax, true_label_, false_label_);
|
|
|
|
break;
|
|
|
|
case Expression::kValueTest: {
|
|
|
|
Label discard;
|
|
|
|
if (!result_saved) __ push(rax);
|
|
|
|
TestAndBranch(rax, true_label_, &discard);
|
|
|
|
__ bind(&discard);
|
|
|
|
__ addq(rsp, Immediate(kPointerSize));
|
|
|
|
__ jmp(false_label_);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case Expression::kTestValue: {
|
|
|
|
Label discard;
|
|
|
|
if (!result_saved) __ push(rax);
|
|
|
|
TestAndBranch(rax, &discard, false_label_);
|
|
|
|
__ bind(&discard);
|
|
|
|
__ addq(rsp, Immediate(kPointerSize));
|
|
|
|
__ jmp(true_label_);
|
|
|
|
break;
|
|
|
|
}
|
2009-10-22 10:07:45 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-11-02 11:01:47 +00:00
|
|
|
void FastCodeGenerator::EmitVariableAssignment(Expression::Context context,
|
|
|
|
Variable* var) {
|
|
|
|
if (var->is_global()) {
|
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
|
|
|
// Assignment to a global variable, use inline caching. Right-hand-side
|
|
|
|
// value is passed in rax, variable name in rcx, and the global object
|
|
|
|
// on the stack.
|
2009-11-02 11:01:47 +00:00
|
|
|
__ pop(rax);
|
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
|
|
|
__ Move(rcx, var->name());
|
|
|
|
__ push(CodeGenerator::GlobalObject());
|
|
|
|
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.
|
2009-11-02 11:01:47 +00:00
|
|
|
DropAndMove(context, rax);
|
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
|
|
|
} else {
|
2009-11-02 11:01:47 +00:00
|
|
|
switch (context) {
|
|
|
|
case Expression::kUninitialized:
|
|
|
|
UNREACHABLE();
|
|
|
|
case Expression::kEffect:
|
|
|
|
// Perform assignment and discard value.
|
|
|
|
__ pop(Operand(rbp, SlotOffset(var->slot())));
|
|
|
|
break;
|
|
|
|
case Expression::kValue:
|
|
|
|
// Perform assignment and preserve value.
|
|
|
|
__ movq(rax, Operand(rsp, 0));
|
|
|
|
__ movq(Operand(rbp, SlotOffset(var->slot())), rax);
|
|
|
|
break;
|
|
|
|
case Expression::kTest:
|
|
|
|
// Perform assignment and test (and discard) value.
|
|
|
|
__ pop(rax);
|
|
|
|
__ movq(Operand(rbp, SlotOffset(var->slot())), rax);
|
|
|
|
TestAndBranch(rax, true_label_, false_label_);
|
|
|
|
break;
|
|
|
|
case Expression::kValueTest: {
|
|
|
|
Label discard;
|
|
|
|
__ movq(rax, Operand(rsp, 0));
|
|
|
|
__ movq(Operand(rbp, SlotOffset(var->slot())), rax);
|
|
|
|
TestAndBranch(rax, true_label_, &discard);
|
|
|
|
__ bind(&discard);
|
|
|
|
__ addq(rsp, Immediate(kPointerSize));
|
|
|
|
__ jmp(false_label_);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case Expression::kTestValue: {
|
|
|
|
Label discard;
|
|
|
|
__ movq(rax, Operand(rsp, 0));
|
|
|
|
__ movq(Operand(rbp, SlotOffset(var->slot())), rax);
|
|
|
|
TestAndBranch(rax, &discard, false_label_);
|
|
|
|
__ bind(&discard);
|
|
|
|
__ addq(rsp, Immediate(kPointerSize));
|
|
|
|
__ jmp(true_label_);
|
|
|
|
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-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
|
|
|
}
|
Port the initial fast code generator to x64. For the constant true in
top-level code we generate:
0 push rbp
1 movq rbp,rsp
4 push rsi
5 push rdi
6 push [r13+0x8]
10 cmpq rsp,[r13+0x0]
14 jnc 25 (0x7ff2c378ff19)
20 call 0x7ff2c377d260 ;; code: STUB, StackCheck, minor: 0
25 movq r10,0x7ff2e8608199 ;; object: 0x7ff2e8608199 <true>
35 push r10
37 movq rax,[rsp]
41 movq [rbp-0x18],rax
45 pop rax
46 push [rbp-0x18]
50 pop rax
51 movq rsp,rbp ;; js return
54 pop rbp
55 ret 0x8
58 int3
59 int3
60 int3
61 int3
62 int3
63 int3
64 movq rax,[r13+0x8]
68 movq rsp,rbp ;; js return
71 pop rbp
72 ret 0x8
75 int3
76 int3
77 int3
78 int3
79 int3
80 int3
Review URL: http://codereview.chromium.org/264066
git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@3071 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2009-10-15 11:21:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-11-02 11:01:47 +00:00
|
|
|
void FastCodeGenerator::EmitNamedPropertyAssignment(
|
|
|
|
Expression::Context context,
|
|
|
|
Handle<Object> name) {
|
|
|
|
__ pop(rax);
|
|
|
|
__ Move(rcx, name);
|
|
|
|
Handle<Code> ic(Builtins::builtin(Builtins::StoreIC_Initialize));
|
|
|
|
__ Call(ic, RelocInfo::CODE_TARGET);
|
|
|
|
DropAndMove(context, rax);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void FastCodeGenerator::EmitKeyedPropertyAssignment(
|
|
|
|
Expression::Context context) {
|
|
|
|
__ pop(rax);
|
|
|
|
Handle<Code> ic(Builtins::builtin(Builtins::KeyedStoreIC_Initialize));
|
|
|
|
__ Call(ic, RelocInfo::CODE_TARGET);
|
|
|
|
// This nop signals to the IC that there is no inlined code at the call
|
|
|
|
// site for it to patch.
|
|
|
|
__ nop();
|
|
|
|
// Receiver and key are still on stack.
|
|
|
|
__ addq(rsp, Immediate(2 * kPointerSize));
|
|
|
|
Move(context, rax);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
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());
|
|
|
|
|
2009-10-30 10:22:31 +00:00
|
|
|
|
2009-10-27 16:11:12 +00:00
|
|
|
if (key->AsLiteral() != NULL && key->AsLiteral()->handle()->IsSymbol() &&
|
|
|
|
!String::cast(*(key->AsLiteral()->handle()))->AsArrayIndex(&dummy)) {
|
|
|
|
// Do a NAMED property load.
|
|
|
|
// The IC expects the property name in rcx and the receiver on the stack.
|
|
|
|
__ Move(rcx, key->AsLiteral()->handle());
|
|
|
|
Handle<Code> ic(Builtins::builtin(Builtins::LoadIC_Initialize));
|
|
|
|
__ call(ic, RelocInfo::CODE_TARGET);
|
2009-10-30 07:56:38 +00:00
|
|
|
// By emitting a nop we make sure that we do not have a "test rax,..."
|
2009-10-27 16:11:12 +00:00
|
|
|
// instruction after the call it is treated specially by the LoadIC code.
|
|
|
|
__ nop();
|
|
|
|
} else {
|
|
|
|
// Do a KEYED property load.
|
|
|
|
Visit(expr->key());
|
|
|
|
Handle<Code> ic(Builtins::builtin(Builtins::KeyedLoadIC_Initialize));
|
|
|
|
__ call(ic, RelocInfo::CODE_TARGET);
|
2009-10-30 07:56:38 +00:00
|
|
|
// By emitting a nop we make sure that we do not have a "test rax,..."
|
2009-10-27 16:11:12 +00:00
|
|
|
// instruction after the call it is treated specially by the LoadIC code.
|
|
|
|
__ nop();
|
|
|
|
// Drop key left on the stack by IC.
|
|
|
|
__ addq(rsp, Immediate(kPointerSize));
|
|
|
|
}
|
2009-10-30 08:36:46 +00:00
|
|
|
DropAndMove(expr->context(), rax);
|
2009-10-27 16:11:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-10-30 10:22:31 +00:00
|
|
|
void FastCodeGenerator::EmitCallWithIC(Call* expr, RelocInfo::Mode reloc_info) {
|
|
|
|
// 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-10-30 10:22:31 +00:00
|
|
|
__ call(ic, reloc_info);
|
2009-10-21 09:17:39 +00:00
|
|
|
// Restore context register.
|
|
|
|
__ movq(rsi, Operand(rbp, StandardFrameConstants::kContextOffset));
|
|
|
|
// Discard the function left on TOS.
|
2009-10-30 08:36:46 +00:00
|
|
|
DropAndMove(expr->context(), rax);
|
2009-10-21 09:17:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-10-30 10:22:31 +00:00
|
|
|
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);
|
|
|
|
// Restore context register.
|
|
|
|
__ movq(rsi, Operand(rbp, StandardFrameConstants::kContextOffset));
|
|
|
|
// Discard the function left on TOS.
|
|
|
|
DropAndMove(expr->context(), rax);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void FastCodeGenerator::VisitCall(Call* expr) {
|
|
|
|
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-02 12:04:35 +00:00
|
|
|
if (var != NULL &&
|
|
|
|
var->is_possibly_eval()) {
|
|
|
|
// Call to eval.
|
|
|
|
UNREACHABLE();
|
|
|
|
} else if (fun->AsProperty() != NULL) {
|
2009-10-30 10:22:31 +00:00
|
|
|
// Call on a property.
|
|
|
|
Property* prop = fun->AsProperty();
|
|
|
|
Literal* key = prop->key()->AsLiteral();
|
|
|
|
if (key != NULL && key->handle()->IsSymbol()) {
|
|
|
|
// Call on a named property: foo.x(1,2,3)
|
|
|
|
__ Push(key->handle());
|
|
|
|
Visit(prop->obj());
|
|
|
|
// Use call IC
|
|
|
|
EmitCallWithIC(expr, RelocInfo::CODE_TARGET);
|
|
|
|
} else {
|
|
|
|
// Call on a keyed property: foo[key](1,2,3)
|
|
|
|
// Use a keyed load IC followed by a call IC.
|
|
|
|
Visit(prop->obj());
|
|
|
|
Visit(prop->key());
|
|
|
|
// Record source position of property.
|
|
|
|
SetSourcePosition(prop->position());
|
|
|
|
Handle<Code> ic(Builtins::builtin(Builtins::KeyedLoadIC_Initialize));
|
|
|
|
__ call(ic, RelocInfo::CODE_TARGET);
|
|
|
|
// By emitting a nop we make sure that we do not have a "test eax,..."
|
|
|
|
// instruction after the call it is treated specially by the LoadIC code.
|
|
|
|
__ nop();
|
|
|
|
// Drop key left on the stack by IC.
|
|
|
|
__ addq(rsp, Immediate(kPointerSize));
|
|
|
|
// Pop receiver.
|
|
|
|
__ pop(rbx);
|
|
|
|
// Push result (function).
|
|
|
|
__ push(rax);
|
|
|
|
// Push receiver object on stack.
|
|
|
|
if (prop->is_synthetic()) {
|
|
|
|
__ push(CodeGenerator::GlobalObject());
|
|
|
|
} else {
|
|
|
|
__ push(rbx);
|
|
|
|
}
|
|
|
|
EmitCallWithStub(expr);
|
|
|
|
}
|
2009-11-02 12:04:35 +00:00
|
|
|
} else if (var != NULL) {
|
2009-10-30 10:22:31 +00:00
|
|
|
// Call on a global variable
|
|
|
|
ASSERT(var != NULL && !var->is_this() && var->is_global());
|
|
|
|
ASSERT(!var->is_possibly_eval());
|
|
|
|
__ Push(var->name());
|
|
|
|
// Push global object (receiver).
|
|
|
|
__ push(CodeGenerator::GlobalObject());
|
|
|
|
EmitCallWithIC(expr, RelocInfo::CODE_TARGET_CONTEXT);
|
2009-11-02 12:04:35 +00:00
|
|
|
} else if (var != NULL && var->slot() != NULL &&
|
|
|
|
var->slot()->type() == Slot::LOOKUP) {
|
|
|
|
// Call inside a with-statement
|
2009-10-30 10:22:31 +00:00
|
|
|
UNREACHABLE();
|
2009-11-02 12:04:35 +00:00
|
|
|
} else {
|
|
|
|
// Call with an arbitrary function expression.
|
|
|
|
Visit(expr->expression());
|
|
|
|
// Load global receiver object.
|
|
|
|
__ movq(rbx, CodeGenerator::GlobalObject());
|
|
|
|
__ push(FieldOperand(rbx, GlobalObject::kGlobalReceiverOffset));
|
|
|
|
// 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-29 11:55:03 +00:00
|
|
|
// If location is value, already on the stack,
|
2009-10-27 14:52:55 +00:00
|
|
|
|
|
|
|
// Push global object (receiver).
|
|
|
|
__ push(CodeGenerator::GlobalObject());
|
|
|
|
|
|
|
|
// 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 rdi and rax.
|
|
|
|
__ Set(rax, arg_count);
|
|
|
|
// Function is in rsp[arg_count + 1].
|
|
|
|
__ movq(rdi, Operand(rsp, rax, times_pointer_size, kPointerSize));
|
|
|
|
|
|
|
|
Handle<Code> construct_builtin(Builtins::builtin(Builtins::JSConstructCall));
|
|
|
|
__ Call(construct_builtin, RelocInfo::CONSTRUCT_CALL);
|
|
|
|
|
|
|
|
// Replace function on TOS with result in rax, or pop it.
|
2009-10-30 08:36:46 +00:00
|
|
|
DropAndMove(expr->context(), rax);
|
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();
|
|
|
|
Runtime::Function* function = expr->function();
|
|
|
|
|
|
|
|
ASSERT(function != NULL);
|
|
|
|
|
|
|
|
// 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
|
|
|
}
|
|
|
|
|
|
|
|
__ CallRuntime(function, arg_count);
|
2009-10-30 08:36:46 +00:00
|
|
|
Move(expr->context(), rax);
|
2009-10-21 09:17:39 +00:00
|
|
|
}
|
|
|
|
|
2009-11-02 10:22:22 +00:00
|
|
|
void FastCodeGenerator::VisitCountOperation(CountOperation* expr) {
|
|
|
|
VariableProxy* v = expr->expression()->AsVariableProxy();
|
|
|
|
ASSERT(v->AsVariable() != NULL);
|
|
|
|
ASSERT(v->AsVariable()->is_global());
|
|
|
|
|
|
|
|
Visit(v);
|
|
|
|
|
|
|
|
__ InvokeBuiltin(Builtins::TO_NUMBER, CALL_FUNCTION);
|
|
|
|
|
|
|
|
switch (expr->context()) {
|
|
|
|
case Expression::kUninitialized:
|
|
|
|
UNREACHABLE();
|
|
|
|
case Expression::kValue: // Fall through
|
|
|
|
case Expression::kTest: // Fall through
|
|
|
|
case Expression::kTestValue: // Fall through
|
|
|
|
case Expression::kValueTest:
|
|
|
|
// Duplicate the result on the stack.
|
|
|
|
__ push(rax);
|
|
|
|
break;
|
|
|
|
case Expression::kEffect:
|
|
|
|
// Do not save result.
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
// Call runtime for +1/-1.
|
|
|
|
__ push(rax);
|
|
|
|
__ Push(Smi::FromInt(1));
|
|
|
|
if (expr->op() == Token::INC) {
|
|
|
|
__ CallRuntime(Runtime::kNumberAdd, 2);
|
|
|
|
} else {
|
|
|
|
__ CallRuntime(Runtime::kNumberSub, 2);
|
|
|
|
}
|
|
|
|
// Call Store IC.
|
|
|
|
__ Move(rcx, v->AsVariable()->name());
|
|
|
|
__ push(CodeGenerator::GlobalObject());
|
|
|
|
Handle<Code> ic(Builtins::builtin(Builtins::StoreIC_Initialize));
|
|
|
|
__ call(ic, RelocInfo::CODE_TARGET);
|
|
|
|
// Restore up stack after store IC
|
|
|
|
__ addq(rsp, Immediate(kPointerSize));
|
|
|
|
|
|
|
|
switch (expr->context()) {
|
|
|
|
case Expression::kUninitialized:
|
|
|
|
UNREACHABLE();
|
|
|
|
case Expression::kEffect: // Fall through
|
|
|
|
case Expression::kValue:
|
|
|
|
// Do nothing. Result in either on the stack for value context
|
|
|
|
// or discarded for effect context.
|
|
|
|
break;
|
|
|
|
case Expression::kTest:
|
|
|
|
__ pop(rax);
|
|
|
|
TestAndBranch(rax, true_label_, false_label_);
|
|
|
|
break;
|
|
|
|
case Expression::kValueTest: {
|
|
|
|
Label discard;
|
|
|
|
__ movq(rax, Operand(rsp, 0));
|
|
|
|
TestAndBranch(rax, true_label_, &discard);
|
|
|
|
__ bind(&discard);
|
|
|
|
__ addq(rsp, Immediate(kPointerSize));
|
|
|
|
__ jmp(false_label_);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case Expression::kTestValue: {
|
|
|
|
Label discard;
|
|
|
|
__ movq(rax, Operand(rsp, 0));
|
|
|
|
TestAndBranch(rax, &discard, false_label_);
|
|
|
|
__ bind(&discard);
|
|
|
|
__ addq(rsp, Immediate(kPointerSize));
|
|
|
|
__ jmp(true_label_);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-10-21 09:17:39 +00:00
|
|
|
|
2009-10-30 11:32:42 +00:00
|
|
|
void FastCodeGenerator::VisitUnaryOperation(UnaryOperation* expr) {
|
|
|
|
Comment cmnt(masm_, "[ UnaryOperation");
|
|
|
|
|
|
|
|
switch (expr->op()) {
|
|
|
|
case Token::VOID:
|
|
|
|
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:
|
|
|
|
__ PushRoot(Heap::kUndefinedValueRootIndex);
|
|
|
|
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.
|
|
|
|
__ PushRoot(Heap::kUndefinedValueRootIndex);
|
|
|
|
// Fall through.
|
|
|
|
case Expression::kTest: // Fall through.
|
|
|
|
case Expression::kValueTest:
|
|
|
|
__ jmp(false_label_);
|
2009-10-30 11:32:42 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2009-11-02 10:17:12 +00:00
|
|
|
case Token::NOT: {
|
|
|
|
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);
|
|
|
|
__ PushRoot(Heap::kTrueValueRootIndex);
|
|
|
|
__ jmp(&done);
|
|
|
|
__ bind(&push_false);
|
|
|
|
__ PushRoot(Heap::kFalseValueRootIndex);
|
|
|
|
__ 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);
|
|
|
|
__ PushRoot(Heap::kTrueValueRootIndex);
|
|
|
|
__ jmp(saved_true);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case Expression::kTestValue:
|
|
|
|
true_label_ = &push_false;
|
|
|
|
false_label_ = saved_true;
|
|
|
|
Visit(expr->expression());
|
|
|
|
__ bind(&push_false);
|
|
|
|
__ PushRoot(Heap::kFalseValueRootIndex);
|
|
|
|
__ jmp(saved_false);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
true_label_ = saved_true;
|
|
|
|
false_label_ = saved_false;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2009-10-30 11:32:42 +00:00
|
|
|
default:
|
|
|
|
UNREACHABLE();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-10-23 10:42:14 +00:00
|
|
|
void FastCodeGenerator::VisitBinaryOperation(BinaryOperation* expr) {
|
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());
|
|
|
|
GenericBinaryOpStub stub(expr->op(),
|
|
|
|
NO_OVERWRITE,
|
|
|
|
NO_GENERIC_BINARY_FLAGS);
|
|
|
|
__ CallStub(&stub);
|
2009-10-30 08:36:46 +00:00
|
|
|
Move(expr->context(), rax);
|
2009-10-29 11:55:03 +00:00
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
UNREACHABLE();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
Port the initial fast code generator to x64. For the constant true in
top-level code we generate:
0 push rbp
1 movq rbp,rsp
4 push rsi
5 push rdi
6 push [r13+0x8]
10 cmpq rsp,[r13+0x0]
14 jnc 25 (0x7ff2c378ff19)
20 call 0x7ff2c377d260 ;; code: STUB, StackCheck, minor: 0
25 movq r10,0x7ff2e8608199 ;; object: 0x7ff2e8608199 <true>
35 push r10
37 movq rax,[rsp]
41 movq [rbp-0x18],rax
45 pop rax
46 push [rbp-0x18]
50 pop rax
51 movq rsp,rbp ;; js return
54 pop rbp
55 ret 0x8
58 int3
59 int3
60 int3
61 int3
62 int3
63 int3
64 movq rax,[r13+0x8]
68 movq rsp,rbp ;; js return
71 pop rbp
72 ret 0x8
75 int3
76 int3
77 int3
78 int3
79 int3
80 int3
Review URL: http://codereview.chromium.org/264066
git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@3071 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2009-10-15 11:21:26 +00:00
|
|
|
} } // namespace v8::internal
|