]> git.saurik.com Git - apple/javascriptcore.git/blob - jit/JITStubs.cpp
projects / apple / javascriptcore.git / blob
? search:


bf5168b45c2d8907fb51292c9fea081c585a7898
[apple/javascriptcore.git] / jit / JITStubs.cpp
1 /*
2 * Copyright (C) 2008, 2009 Apple Inc. All rights reserved.
3 * Copyright (C) 2008 Cameron Zwarich <cwzwarich@uwaterloo.ca>
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of
15 * its contributors may be used to endorse or promote products derived
16 * from this software without specific prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
19 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
20 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
21 * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
22 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
23 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
24 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
25 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29
30 #include "config.h"
31 #include "JITStubs.h"
32
33 #if ENABLE(JIT)
34
35 #include "Arguments.h"
36 #include "CallFrame.h"
37 #include "CodeBlock.h"
38 #include "Collector.h"
39 #include "Debugger.h"
40 #include "ExceptionHelpers.h"
41 #include "GlobalEvalFunction.h"
42 #include "JIT.h"
43 #include "JSActivation.h"
44 #include "JSArray.h"
45 #include "JSByteArray.h"
46 #include "JSFunction.h"
47 #include "JSNotAnObject.h"
48 #include "JSPropertyNameIterator.h"
49 #include "JSStaticScopeObject.h"
50 #include "JSString.h"
51 #include "ObjectPrototype.h"
52 #include "Operations.h"
53 #include "Parser.h"
54 #include "Profiler.h"
55 #include "RegExpObject.h"
56 #include "RegExpPrototype.h"
57 #include "Register.h"
58 #include "SamplingTool.h"
59 #include <wtf/StdLibExtras.h>
60 #include <stdarg.h>
61 #include <stdio.h>
62
63 using namespace std;
64
65 namespace JSC {
66
67 #if OS(DARWIN) || OS(WINDOWS)
68 #define SYMBOL_STRING(name) "_" #name
69 #else
70 #define SYMBOL_STRING(name) #name
71 #endif
72
73 #if OS(IPHONE_OS)
74 #define THUMB_FUNC_PARAM(name) SYMBOL_STRING(name)
75 #else
76 #define THUMB_FUNC_PARAM(name)
77 #endif
78
79 #if OS(LINUX) && CPU(X86_64)
80 #define SYMBOL_STRING_RELOCATION(name) #name "@plt"
81 #else
82 #define SYMBOL_STRING_RELOCATION(name) SYMBOL_STRING(name)
83 #endif
84
85 #if OS(DARWIN)
86 // Mach-O platform
87 #define HIDE_SYMBOL(name) ".private_extern _" #name
88 #elif OS(AIX)
89 // IBM's own file format
90 #define HIDE_SYMBOL(name) ".lglobl " #name
91 #elif OS(LINUX) \
92 || OS(FREEBSD) \
93 || OS(OPENBSD) \
94 || OS(SOLARIS) \
95 || (OS(HPUX) && CPU(IA64)) \
96 || OS(SYMBIAN) \
97 || OS(NETBSD)
98 // ELF platform
99 #define HIDE_SYMBOL(name) ".hidden " #name
100 #else
101 #define HIDE_SYMBOL(name)
102 #endif
103
104 #if USE(JSVALUE32_64)
105
106 #if COMPILER(GCC) && CPU(X86)
107
108 // These ASSERTs remind you that, if you change the layout of JITStackFrame, you
109 // need to change the assembly trampolines below to match.
110 COMPILE_ASSERT(offsetof(struct JITStackFrame, code) % 16 == 0x0, JITStackFrame_maintains_16byte_stack_alignment);
111 COMPILE_ASSERT(offsetof(struct JITStackFrame, savedEBX) == 0x3c, JITStackFrame_stub_argument_space_matches_ctiTrampoline);
112 COMPILE_ASSERT(offsetof(struct JITStackFrame, callFrame) == 0x58, JITStackFrame_callFrame_offset_matches_ctiTrampoline);
113 COMPILE_ASSERT(offsetof(struct JITStackFrame, code) == 0x50, JITStackFrame_code_offset_matches_ctiTrampoline);
114
115 asm volatile (
116 ".text\n"
117 ".globl " SYMBOL_STRING(ctiTrampoline) "\n"
118 HIDE_SYMBOL(ctiTrampoline) "\n"
119 SYMBOL_STRING(ctiTrampoline) ":" "\n"
120 "pushl %ebp" "\n"
121 "movl %esp, %ebp" "\n"
122 "pushl %esi" "\n"
123 "pushl %edi" "\n"
124 "pushl %ebx" "\n"
125 "subl $0x3c, %esp" "\n"
126 "movl $512, %esi" "\n"
127 "movl 0x58(%esp), %edi" "\n"
128 "call *0x50(%esp)" "\n"
129 "addl $0x3c, %esp" "\n"
130 "popl %ebx" "\n"
131 "popl %edi" "\n"
132 "popl %esi" "\n"
133 "popl %ebp" "\n"
134 "ret" "\n"
135 );
136
137 asm volatile (
138 ".globl " SYMBOL_STRING(ctiVMThrowTrampoline) "\n"
139 HIDE_SYMBOL(ctiVMThrowTrampoline) "\n"
140 SYMBOL_STRING(ctiVMThrowTrampoline) ":" "\n"
141 #if !USE(JIT_STUB_ARGUMENT_VA_LIST)
142 "movl %esp, %ecx" "\n"
143 #endif
144 "call " SYMBOL_STRING_RELOCATION(cti_vm_throw) "\n"
145 "addl $0x3c, %esp" "\n"
146 "popl %ebx" "\n"
147 "popl %edi" "\n"
148 "popl %esi" "\n"
149 "popl %ebp" "\n"
150 "ret" "\n"
151 );
152
153 asm volatile (
154 ".globl " SYMBOL_STRING(ctiOpThrowNotCaught) "\n"
155 HIDE_SYMBOL(ctiOpThrowNotCaught) "\n"
156 SYMBOL_STRING(ctiOpThrowNotCaught) ":" "\n"
157 "addl $0x3c, %esp" "\n"
158 "popl %ebx" "\n"
159 "popl %edi" "\n"
160 "popl %esi" "\n"
161 "popl %ebp" "\n"
162 "ret" "\n"
163 );
164
165 #elif COMPILER(GCC) && CPU(X86_64)
166
167 #if USE(JIT_STUB_ARGUMENT_VA_LIST)
168 #error "JIT_STUB_ARGUMENT_VA_LIST not supported on x86-64."
169 #endif
170
171 // These ASSERTs remind you that, if you change the layout of JITStackFrame, you
172 // need to change the assembly trampolines below to match.
173 COMPILE_ASSERT(offsetof(struct JITStackFrame, code) % 32 == 0x0, JITStackFrame_maintains_32byte_stack_alignment);
174 COMPILE_ASSERT(offsetof(struct JITStackFrame, savedRBX) == 0x48, JITStackFrame_stub_argument_space_matches_ctiTrampoline);
175 COMPILE_ASSERT(offsetof(struct JITStackFrame, callFrame) == 0x90, JITStackFrame_callFrame_offset_matches_ctiTrampoline);
176 COMPILE_ASSERT(offsetof(struct JITStackFrame, code) == 0x80, JITStackFrame_code_offset_matches_ctiTrampoline);
177
178 asm volatile (
179 ".globl " SYMBOL_STRING(ctiTrampoline) "\n"
180 HIDE_SYMBOL(ctiTrampoline) "\n"
181 SYMBOL_STRING(ctiTrampoline) ":" "\n"
182 "pushq %rbp" "\n"
183 "movq %rsp, %rbp" "\n"
184 "pushq %r12" "\n"
185 "pushq %r13" "\n"
186 "pushq %r14" "\n"
187 "pushq %r15" "\n"
188 "pushq %rbx" "\n"
189 "subq $0x48, %rsp" "\n"
190 "movq $512, %r12" "\n"
191 "movq $0xFFFF000000000000, %r14" "\n"
192 "movq $0xFFFF000000000002, %r15" "\n"
193 "movq 0x90(%rsp), %r13" "\n"
194 "call *0x80(%rsp)" "\n"
195 "addq $0x48, %rsp" "\n"
196 "popq %rbx" "\n"
197 "popq %r15" "\n"
198 "popq %r14" "\n"
199 "popq %r13" "\n"
200 "popq %r12" "\n"
201 "popq %rbp" "\n"
202 "ret" "\n"
203 );
204
205 asm volatile (
206 ".globl " SYMBOL_STRING(ctiVMThrowTrampoline) "\n"
207 HIDE_SYMBOL(ctiVMThrowTrampoline) "\n"
208 SYMBOL_STRING(ctiVMThrowTrampoline) ":" "\n"
209 "movq %rsp, %rdi" "\n"
210 "call " SYMBOL_STRING_RELOCATION(cti_vm_throw) "\n"
211 "addq $0x48, %rsp" "\n"
212 "popq %rbx" "\n"
213 "popq %r15" "\n"
214 "popq %r14" "\n"
215 "popq %r13" "\n"
216 "popq %r12" "\n"
217 "popq %rbp" "\n"
218 "ret" "\n"
219 );
220
221 asm volatile (
222 ".globl " SYMBOL_STRING(ctiOpThrowNotCaught) "\n"
223 HIDE_SYMBOL(ctiOpThrowNotCaught) "\n"
224 SYMBOL_STRING(ctiOpThrowNotCaught) ":" "\n"
225 "addq $0x48, %rsp" "\n"
226 "popq %rbx" "\n"
227 "popq %r15" "\n"
228 "popq %r14" "\n"
229 "popq %r13" "\n"
230 "popq %r12" "\n"
231 "popq %rbp" "\n"
232 "ret" "\n"
233 );
234
235 #elif COMPILER(GCC) && CPU(ARM_THUMB2)
236
237 #if USE(JIT_STUB_ARGUMENT_VA_LIST)
238 #error "JIT_STUB_ARGUMENT_VA_LIST not supported on ARMv7."
239 #endif
240
241 asm volatile (
242 ".text" "\n"
243 ".align 2" "\n"
244 ".globl " SYMBOL_STRING(ctiTrampoline) "\n"
245 HIDE_SYMBOL(ctiTrampoline) "\n"
246 ".thumb" "\n"
247 ".thumb_func " THUMB_FUNC_PARAM(ctiTrampoline) "\n"
248 SYMBOL_STRING(ctiTrampoline) ":" "\n"
249 "sub sp, sp, #0x3c" "\n"
250 "str lr, [sp, #0x20]" "\n"
251 "str r4, [sp, #0x24]" "\n"
252 "str r5, [sp, #0x28]" "\n"
253 "str r6, [sp, #0x2c]" "\n"
254 "str r1, [sp, #0x30]" "\n"
255 "str r2, [sp, #0x34]" "\n"
256 "str r3, [sp, #0x38]" "\n"
257 "cpy r5, r2" "\n"
258 "mov r6, #512" "\n"
259 "blx r0" "\n"
260 "ldr r6, [sp, #0x2c]" "\n"
261 "ldr r5, [sp, #0x28]" "\n"
262 "ldr r4, [sp, #0x24]" "\n"
263 "ldr lr, [sp, #0x20]" "\n"
264 "add sp, sp, #0x3c" "\n"
265 "bx lr" "\n"
266 );
267
268 asm volatile (
269 ".text" "\n"
270 ".align 2" "\n"
271 ".globl " SYMBOL_STRING(ctiVMThrowTrampoline) "\n"
272 HIDE_SYMBOL(ctiVMThrowTrampoline) "\n"
273 ".thumb" "\n"
274 ".thumb_func " THUMB_FUNC_PARAM(ctiVMThrowTrampoline) "\n"
275 SYMBOL_STRING(ctiVMThrowTrampoline) ":" "\n"
276 "cpy r0, sp" "\n"
277 "bl " SYMBOL_STRING_RELOCATION(cti_vm_throw) "\n"
278 "ldr r6, [sp, #0x2c]" "\n"
279 "ldr r5, [sp, #0x28]" "\n"
280 "ldr r4, [sp, #0x24]" "\n"
281 "ldr lr, [sp, #0x20]" "\n"
282 "add sp, sp, #0x3c" "\n"
283 "bx lr" "\n"
284 );
285
286 asm volatile (
287 ".text" "\n"
288 ".align 2" "\n"
289 ".globl " SYMBOL_STRING(ctiOpThrowNotCaught) "\n"
290 ".thumb" "\n"
291 ".thumb_func " THUMB_FUNC_PARAM(ctiOpThrowNotCaught) "\n"
292 SYMBOL_STRING(ctiOpThrowNotCaught) ":" "\n"
293 "ldr r6, [sp, #0x2c]" "\n"
294 "ldr r5, [sp, #0x28]" "\n"
295 "ldr r4, [sp, #0x24]" "\n"
296 "ldr lr, [sp, #0x20]" "\n"
297 "add sp, sp, #0x3c" "\n"
298 "bx lr" "\n"
299 );
300
301 #elif COMPILER(GCC) && CPU(ARM_TRADITIONAL)
302
303 asm volatile (
304 ".globl " SYMBOL_STRING(ctiTrampoline) "\n"
305 SYMBOL_STRING(ctiTrampoline) ":" "\n"
306 "stmdb sp!, {r1-r3}" "\n"
307 "stmdb sp!, {r4-r8, lr}" "\n"
308 "sub sp, sp, #68" "\n"
309 "mov r4, r2" "\n"
310 "mov r5, #512" "\n"
311 // r0 contains the code
312 "mov lr, pc" "\n"
313 "mov pc, r0" "\n"
314 "add sp, sp, #68" "\n"
315 "ldmia sp!, {r4-r8, lr}" "\n"
316 "add sp, sp, #12" "\n"
317 "mov pc, lr" "\n"
318 );
319
320 asm volatile (
321 ".globl " SYMBOL_STRING(ctiVMThrowTrampoline) "\n"
322 SYMBOL_STRING(ctiVMThrowTrampoline) ":" "\n"
323 "mov r0, sp" "\n"
324 "bl " SYMBOL_STRING(cti_vm_throw) "\n"
325
326 // Both has the same return sequence
327 ".globl " SYMBOL_STRING(ctiOpThrowNotCaught) "\n"
328 SYMBOL_STRING(ctiOpThrowNotCaught) ":" "\n"
329 "add sp, sp, #68" "\n"
330 "ldmia sp!, {r4-r8, lr}" "\n"
331 "add sp, sp, #12" "\n"
332 "mov pc, lr" "\n"
333 );
334
335 #elif COMPILER(MSVC) && CPU(X86)
336
337 #if USE(JIT_STUB_ARGUMENT_VA_LIST)
338 #error "JIT_STUB_ARGUMENT_VA_LIST configuration not supported on MSVC."
339 #endif
340
341 // These ASSERTs remind you that, if you change the layout of JITStackFrame, you
342 // need to change the assembly trampolines below to match.
343 COMPILE_ASSERT(offsetof(struct JITStackFrame, code) % 16 == 0x0, JITStackFrame_maintains_16byte_stack_alignment);
344 COMPILE_ASSERT(offsetof(struct JITStackFrame, savedEBX) == 0x3c, JITStackFrame_stub_argument_space_matches_ctiTrampoline);
345 COMPILE_ASSERT(offsetof(struct JITStackFrame, callFrame) == 0x58, JITStackFrame_callFrame_offset_matches_ctiTrampoline);
346 COMPILE_ASSERT(offsetof(struct JITStackFrame, code) == 0x50, JITStackFrame_code_offset_matches_ctiTrampoline);
347
348 extern "C" {
349
350 __declspec(naked) EncodedJSValue ctiTrampoline(void* code, RegisterFile*, CallFrame*, JSValue* exception, Profiler**, JSGlobalData*)
351 {
352 __asm {
353 push ebp;
354 mov ebp, esp;
355 push esi;
356 push edi;
357 push ebx;
358 sub esp, 0x3c;
359 mov esi, 512;
360 mov ecx, esp;
361 mov edi, [esp + 0x58];
362 call [esp + 0x50];
363 add esp, 0x3c;
364 pop ebx;
365 pop edi;
366 pop esi;
367 pop ebp;
368 ret;
369 }
370 }
371
372 __declspec(naked) void ctiVMThrowTrampoline()
373 {
374 __asm {
375 mov ecx, esp;
376 call cti_vm_throw;
377 add esp, 0x3c;
378 pop ebx;
379 pop edi;
380 pop esi;
381 pop ebp;
382 ret;
383 }
384 }
385
386 __declspec(naked) void ctiOpThrowNotCaught()
387 {
388 __asm {
389 add esp, 0x3c;
390 pop ebx;
391 pop edi;
392 pop esi;
393 pop ebp;
394 ret;
395 }
396 }
397 }
398
399 #else
400 #error "JIT not supported on this platform."
401 #endif
402
403 #else // USE(JSVALUE32_64)
404
405 #if COMPILER(GCC) && CPU(X86)
406
407 // These ASSERTs remind you that, if you change the layout of JITStackFrame, you
408 // need to change the assembly trampolines below to match.
409 COMPILE_ASSERT(offsetof(struct JITStackFrame, callFrame) == 0x38, JITStackFrame_callFrame_offset_matches_ctiTrampoline);
410 COMPILE_ASSERT(offsetof(struct JITStackFrame, code) == 0x30, JITStackFrame_code_offset_matches_ctiTrampoline);
411 COMPILE_ASSERT(offsetof(struct JITStackFrame, savedEBX) == 0x1c, JITStackFrame_stub_argument_space_matches_ctiTrampoline);
412
413 asm volatile (
414 ".text\n"
415 ".globl " SYMBOL_STRING(ctiTrampoline) "\n"
416 HIDE_SYMBOL(ctiTrampoline) "\n"
417 SYMBOL_STRING(ctiTrampoline) ":" "\n"
418 "pushl %ebp" "\n"
419 "movl %esp, %ebp" "\n"
420 "pushl %esi" "\n"
421 "pushl %edi" "\n"
422 "pushl %ebx" "\n"
423 "subl $0x1c, %esp" "\n"
424 "movl $512, %esi" "\n"
425 "movl 0x38(%esp), %edi" "\n"
426 "call *0x30(%esp)" "\n"
427 "addl $0x1c, %esp" "\n"
428 "popl %ebx" "\n"
429 "popl %edi" "\n"
430 "popl %esi" "\n"
431 "popl %ebp" "\n"
432 "ret" "\n"
433 );
434
435 asm volatile (
436 ".globl " SYMBOL_STRING(ctiVMThrowTrampoline) "\n"
437 HIDE_SYMBOL(ctiVMThrowTrampoline) "\n"
438 SYMBOL_STRING(ctiVMThrowTrampoline) ":" "\n"
439 #if !USE(JIT_STUB_ARGUMENT_VA_LIST)
440 "movl %esp, %ecx" "\n"
441 #endif
442 "call " SYMBOL_STRING_RELOCATION(cti_vm_throw) "\n"
443 "addl $0x1c, %esp" "\n"
444 "popl %ebx" "\n"
445 "popl %edi" "\n"
446 "popl %esi" "\n"
447 "popl %ebp" "\n"
448 "ret" "\n"
449 );
450
451 asm volatile (
452 ".globl " SYMBOL_STRING(ctiOpThrowNotCaught) "\n"
453 HIDE_SYMBOL(ctiOpThrowNotCaught) "\n"
454 SYMBOL_STRING(ctiOpThrowNotCaught) ":" "\n"
455 "addl $0x1c, %esp" "\n"
456 "popl %ebx" "\n"
457 "popl %edi" "\n"
458 "popl %esi" "\n"
459 "popl %ebp" "\n"
460 "ret" "\n"
461 );
462
463 #elif COMPILER(GCC) && CPU(X86_64)
464
465 #if USE(JIT_STUB_ARGUMENT_VA_LIST)
466 #error "JIT_STUB_ARGUMENT_VA_LIST not supported on x86-64."
467 #endif
468
469 // These ASSERTs remind you that, if you change the layout of JITStackFrame, you
470 // need to change the assembly trampolines below to match.
471 COMPILE_ASSERT(offsetof(struct JITStackFrame, callFrame) == 0x58, JITStackFrame_callFrame_offset_matches_ctiTrampoline);
472 COMPILE_ASSERT(offsetof(struct JITStackFrame, code) == 0x48, JITStackFrame_code_offset_matches_ctiTrampoline);
473 COMPILE_ASSERT(offsetof(struct JITStackFrame, savedRBX) == 0x78, JITStackFrame_stub_argument_space_matches_ctiTrampoline);
474
475 asm volatile (
476 ".text\n"
477 ".globl " SYMBOL_STRING(ctiTrampoline) "\n"
478 HIDE_SYMBOL(ctiTrampoline) "\n"
479 SYMBOL_STRING(ctiTrampoline) ":" "\n"
480 "pushq %rbp" "\n"
481 "movq %rsp, %rbp" "\n"
482 "pushq %r12" "\n"
483 "pushq %r13" "\n"
484 "pushq %r14" "\n"
485 "pushq %r15" "\n"
486 "pushq %rbx" "\n"
487 // Form the JIT stubs area
488 "pushq %r9" "\n"
489 "pushq %r8" "\n"
490 "pushq %rcx" "\n"
491 "pushq %rdx" "\n"
492 "pushq %rsi" "\n"
493 "pushq %rdi" "\n"
494 "subq $0x48, %rsp" "\n"
495 "movq $512, %r12" "\n"
496 "movq $0xFFFF000000000000, %r14" "\n"
497 "movq $0xFFFF000000000002, %r15" "\n"
498 "movq %rdx, %r13" "\n"
499 "call *%rdi" "\n"
500 "addq $0x78, %rsp" "\n"
501 "popq %rbx" "\n"
502 "popq %r15" "\n"
503 "popq %r14" "\n"
504 "popq %r13" "\n"
505 "popq %r12" "\n"
506 "popq %rbp" "\n"
507 "ret" "\n"
508 );
509
510 asm volatile (
511 ".globl " SYMBOL_STRING(ctiVMThrowTrampoline) "\n"
512 HIDE_SYMBOL(ctiVMThrowTrampoline) "\n"
513 SYMBOL_STRING(ctiVMThrowTrampoline) ":" "\n"
514 "movq %rsp, %rdi" "\n"
515 "call " SYMBOL_STRING_RELOCATION(cti_vm_throw) "\n"
516 "addq $0x78, %rsp" "\n"
517 "popq %rbx" "\n"
518 "popq %r15" "\n"
519 "popq %r14" "\n"
520 "popq %r13" "\n"
521 "popq %r12" "\n"
522 "popq %rbp" "\n"
523 "ret" "\n"
524 );
525
526 asm volatile (
527 ".globl " SYMBOL_STRING(ctiOpThrowNotCaught) "\n"
528 HIDE_SYMBOL(ctiOpThrowNotCaught) "\n"
529 SYMBOL_STRING(ctiOpThrowNotCaught) ":" "\n"
530 "addq $0x78, %rsp" "\n"
531 "popq %rbx" "\n"
532 "popq %r15" "\n"
533 "popq %r14" "\n"
534 "popq %r13" "\n"
535 "popq %r12" "\n"
536 "popq %rbp" "\n"
537 "ret" "\n"
538 );
539
540 #elif COMPILER(GCC) && CPU(ARM_THUMB2)
541
542 #if USE(JIT_STUB_ARGUMENT_VA_LIST)
543 #error "JIT_STUB_ARGUMENT_VA_LIST not supported on ARMv7."
544 #endif
545
546 asm volatile (
547 ".text" "\n"
548 ".align 2" "\n"
549 ".globl " SYMBOL_STRING(ctiTrampoline) "\n"
550 HIDE_SYMBOL(ctiTrampoline) "\n"
551 ".thumb" "\n"
552 ".thumb_func " THUMB_FUNC_PARAM(ctiTrampoline) "\n"
553 SYMBOL_STRING(ctiTrampoline) ":" "\n"
554 "sub sp, sp, #0x40" "\n"
555 "str lr, [sp, #0x20]" "\n"
556 "str r4, [sp, #0x24]" "\n"
557 "str r5, [sp, #0x28]" "\n"
558 "str r6, [sp, #0x2c]" "\n"
559 "str r1, [sp, #0x30]" "\n"
560 "str r2, [sp, #0x34]" "\n"
561 "str r3, [sp, #0x38]" "\n"
562 "cpy r5, r2" "\n"
563 "mov r6, #512" "\n"
564 "blx r0" "\n"
565 "ldr r6, [sp, #0x2c]" "\n"
566 "ldr r5, [sp, #0x28]" "\n"
567 "ldr r4, [sp, #0x24]" "\n"
568 "ldr lr, [sp, #0x20]" "\n"
569 "add sp, sp, #0x40" "\n"
570 "bx lr" "\n"
571 );
572
573 asm volatile (
574 ".text" "\n"
575 ".align 2" "\n"
576 ".globl " SYMBOL_STRING(ctiVMThrowTrampoline) "\n"
577 HIDE_SYMBOL(ctiVMThrowTrampoline) "\n"
578 ".thumb" "\n"
579 ".thumb_func " THUMB_FUNC_PARAM(ctiVMThrowTrampoline) "\n"
580 SYMBOL_STRING(ctiVMThrowTrampoline) ":" "\n"
581 "cpy r0, sp" "\n"
582 "bl " SYMBOL_STRING_RELOCATION(cti_vm_throw) "\n"
583 "ldr r6, [sp, #0x2c]" "\n"
584 "ldr r5, [sp, #0x28]" "\n"
585 "ldr r4, [sp, #0x24]" "\n"
586 "ldr lr, [sp, #0x20]" "\n"
587 "add sp, sp, #0x40" "\n"
588 "bx lr" "\n"
589 );
590
591 asm volatile (
592 ".text" "\n"
593 ".align 2" "\n"
594 ".globl " SYMBOL_STRING(ctiOpThrowNotCaught) "\n"
595 HIDE_SYMBOL(ctiOpThrowNotCaught) "\n"
596 ".thumb" "\n"
597 ".thumb_func " THUMB_FUNC_PARAM(ctiOpThrowNotCaught) "\n"
598 SYMBOL_STRING(ctiOpThrowNotCaught) ":" "\n"
599 "ldr r6, [sp, #0x2c]" "\n"
600 "ldr r5, [sp, #0x28]" "\n"
601 "ldr r4, [sp, #0x24]" "\n"
602 "ldr lr, [sp, #0x20]" "\n"
603 "add sp, sp, #0x3c" "\n"
604 "bx lr" "\n"
605 );
606
607 #elif COMPILER(GCC) && CPU(ARM_TRADITIONAL)
608
609 asm volatile (
610 ".text\n"
611 ".globl " SYMBOL_STRING(ctiTrampoline) "\n"
612 HIDE_SYMBOL(ctiTrampoline) "\n"
613 SYMBOL_STRING(ctiTrampoline) ":" "\n"
614 "stmdb sp!, {r1-r3}" "\n"
615 "stmdb sp!, {r4-r8, lr}" "\n"
616 "sub sp, sp, #36" "\n"
617 "mov r4, r2" "\n"
618 "mov r5, #512" "\n"
619 "mov lr, pc" "\n"
620 "mov pc, r0" "\n"
621 "add sp, sp, #36" "\n"
622 "ldmia sp!, {r4-r8, lr}" "\n"
623 "add sp, sp, #12" "\n"
624 "mov pc, lr" "\n"
625 );
626
627 asm volatile (
628 ".globl " SYMBOL_STRING(ctiVMThrowTrampoline) "\n"
629 HIDE_SYMBOL(ctiVMThrowTrampoline) "\n"
630 SYMBOL_STRING(ctiVMThrowTrampoline) ":" "\n"
631 "mov r0, sp" "\n"
632 "bl " SYMBOL_STRING_RELOCATION(cti_vm_throw) "\n"
633
634 // Both has the same return sequence
635 ".globl " SYMBOL_STRING(ctiOpThrowNotCaught) "\n"
636 HIDE_SYMBOL(ctiOpThrowNotCaught) "\n"
637 SYMBOL_STRING(ctiOpThrowNotCaught) ":" "\n"
638 "add sp, sp, #36" "\n"
639 "ldmia sp!, {r4-r8, lr}" "\n"
640 "add sp, sp, #12" "\n"
641 "mov pc, lr" "\n"
642 );
643
644 #elif COMPILER(RVCT) && CPU(ARM_TRADITIONAL)
645
646 __asm EncodedJSValue ctiTrampoline(void*, RegisterFile*, CallFrame*, JSValue*, Profiler**, JSGlobalData*)
647 {
648 ARM
649 stmdb sp!, {r1-r3}
650 stmdb sp!, {r4-r8, lr}
651 sub sp, sp, #36
652 mov r4, r2
653 mov r5, #512
654 mov lr, pc
655 bx r0
656 add sp, sp, #36
657 ldmia sp!, {r4-r8, lr}
658 add sp, sp, #12
659 bx lr
660 }
661
662 __asm void ctiVMThrowTrampoline()
663 {
664 ARM
665 PRESERVE8
666 mov r0, sp
667 bl cti_vm_throw
668 add sp, sp, #36
669 ldmia sp!, {r4-r8, lr}
670 add sp, sp, #12
671 bx lr
672 }
673
674 __asm void ctiOpThrowNotCaught()
675 {
676 ARM
677 add sp, sp, #36
678 ldmia sp!, {r4-r8, lr}
679 add sp, sp, #12
680 bx lr
681 }
682
683 #elif COMPILER(MSVC) && CPU(X86)
684
685 #if USE(JIT_STUB_ARGUMENT_VA_LIST)
686 #error "JIT_STUB_ARGUMENT_VA_LIST configuration not supported on MSVC."
687 #endif
688
689 // These ASSERTs remind you that, if you change the layout of JITStackFrame, you
690 // need to change the assembly trampolines below to match.
691 COMPILE_ASSERT(offsetof(struct JITStackFrame, callFrame) == 0x38, JITStackFrame_callFrame_offset_matches_ctiTrampoline);
692 COMPILE_ASSERT(offsetof(struct JITStackFrame, code) == 0x30, JITStackFrame_code_offset_matches_ctiTrampoline);
693 COMPILE_ASSERT(offsetof(struct JITStackFrame, savedEBX) == 0x1c, JITStackFrame_stub_argument_space_matches_ctiTrampoline);
694
695 extern "C" {
696
697 __declspec(naked) EncodedJSValue ctiTrampoline(void* code, RegisterFile*, CallFrame*, JSValue* exception, Profiler**, JSGlobalData*)
698 {
699 __asm {
700 push ebp;
701 mov ebp, esp;
702 push esi;
703 push edi;
704 push ebx;
705 sub esp, 0x1c;
706 mov esi, 512;
707 mov ecx, esp;
708 mov edi, [esp + 0x38];
709 call [esp + 0x30];
710 add esp, 0x1c;
711 pop ebx;
712 pop edi;
713 pop esi;
714 pop ebp;
715 ret;
716 }
717 }
718
719 __declspec(naked) void ctiVMThrowTrampoline()
720 {
721 __asm {
722 mov ecx, esp;
723 call cti_vm_throw;
724 add esp, 0x1c;
725 pop ebx;
726 pop edi;
727 pop esi;
728 pop ebp;
729 ret;
730 }
731 }
732
733 __declspec(naked) void ctiOpThrowNotCaught()
734 {
735 __asm {
736 add esp, 0x1c;
737 pop ebx;
738 pop edi;
739 pop esi;
740 pop ebp;
741 ret;
742 }
743 }
744 }
745
746 #else
747 #error "JIT not supported on this platform."
748 #endif
749
750 #endif // USE(JSVALUE32_64)
751
752 #if ENABLE(OPCODE_SAMPLING)
753 #define CTI_SAMPLER stackFrame.globalData->interpreter->sampler()
754 #else
755 #define CTI_SAMPLER 0
756 #endif
757
758 JITThunks::JITThunks(JSGlobalData* globalData)
759 {
760 JIT::compileCTIMachineTrampolines(globalData, &m_executablePool, &m_ctiStringLengthTrampoline, &m_ctiVirtualCallLink, &m_ctiVirtualCall, &m_ctiNativeCallThunk);
761
762 #if CPU(ARM_THUMB2)
763 // Unfortunate the arm compiler does not like the use of offsetof on JITStackFrame (since it contains non POD types),
764 // and the OBJECT_OFFSETOF macro does not appear constantish enough for it to be happy with its use in COMPILE_ASSERT
765 // macros.
766 ASSERT(OBJECT_OFFSETOF(struct JITStackFrame, preservedReturnAddress) == 0x20);
767 ASSERT(OBJECT_OFFSETOF(struct JITStackFrame, preservedR4) == 0x24);
768 ASSERT(OBJECT_OFFSETOF(struct JITStackFrame, preservedR5) == 0x28);
769 ASSERT(OBJECT_OFFSETOF(struct JITStackFrame, preservedR6) == 0x2c);
770
771 ASSERT(OBJECT_OFFSETOF(struct JITStackFrame, registerFile) == 0x30);
772 ASSERT(OBJECT_OFFSETOF(struct JITStackFrame, callFrame) == 0x34);
773 ASSERT(OBJECT_OFFSETOF(struct JITStackFrame, exception) == 0x38);
774 // The fifth argument is the first item already on the stack.
775 ASSERT(OBJECT_OFFSETOF(struct JITStackFrame, enabledProfilerReference) == 0x40);
776
777 ASSERT(OBJECT_OFFSETOF(struct JITStackFrame, thunkReturnAddress) == 0x1C);
778 #endif
779 }
780
781 #if ENABLE(JIT_OPTIMIZE_PROPERTY_ACCESS)
782
783 NEVER_INLINE void JITThunks::tryCachePutByID(CallFrame* callFrame, CodeBlock* codeBlock, ReturnAddressPtr returnAddress, JSValue baseValue, const PutPropertySlot& slot, StructureStubInfo* stubInfo)
784 {
785 // The interpreter checks for recursion here; I do not believe this can occur in CTI.
786
787 if (!baseValue.isCell())
788 return;
789
790 // Uncacheable: give up.
791 if (!slot.isCacheable()) {
792 ctiPatchCallByReturnAddress(codeBlock, returnAddress, FunctionPtr(cti_op_put_by_id_generic));
793 return;
794 }
795
796 JSCell* baseCell = asCell(baseValue);
797 Structure* structure = baseCell->structure();
798
799 if (structure->isUncacheableDictionary()) {
800 ctiPatchCallByReturnAddress(codeBlock, returnAddress, FunctionPtr(cti_op_put_by_id_generic));
801 return;
802 }
803
804 // If baseCell != base, then baseCell must be a proxy for another object.
805 if (baseCell != slot.base()) {
806 ctiPatchCallByReturnAddress(codeBlock, returnAddress, FunctionPtr(cti_op_put_by_id_generic));
807 return;
808 }
809
810 // Cache hit: Specialize instruction and ref Structures.
811
812 // Structure transition, cache transition info
813 if (slot.type() == PutPropertySlot::NewProperty) {
814 if (structure->isDictionary()) {
815 ctiPatchCallByReturnAddress(codeBlock, returnAddress, FunctionPtr(cti_op_put_by_id_generic));
816 return;
817 }
818
819 // put_by_id_transition checks the prototype chain for setters.
820 normalizePrototypeChain(callFrame, baseCell);
821
822 StructureChain* prototypeChain = structure->prototypeChain(callFrame);
823 stubInfo->initPutByIdTransition(structure->previousID(), structure, prototypeChain);
824 JIT::compilePutByIdTransition(callFrame->scopeChain()->globalData, codeBlock, stubInfo, structure->previousID(), structure, slot.cachedOffset(), prototypeChain, returnAddress);
825 return;
826 }
827
828 stubInfo->initPutByIdReplace(structure);
829
830 JIT::patchPutByIdReplace(codeBlock, stubInfo, structure, slot.cachedOffset(), returnAddress);
831 }
832
833 NEVER_INLINE void JITThunks::tryCacheGetByID(CallFrame* callFrame, CodeBlock* codeBlock, ReturnAddressPtr returnAddress, JSValue baseValue, const Identifier& propertyName, const PropertySlot& slot, StructureStubInfo* stubInfo)
834 {
835 // FIXME: Write a test that proves we need to check for recursion here just
836 // like the interpreter does, then add a check for recursion.
837
838 // FIXME: Cache property access for immediates.
839 if (!baseValue.isCell()) {
840 ctiPatchCallByReturnAddress(codeBlock, returnAddress, FunctionPtr(cti_op_get_by_id_generic));
841 return;
842 }
843
844 JSGlobalData* globalData = &callFrame->globalData();
845
846 if (isJSArray(globalData, baseValue) && propertyName == callFrame->propertyNames().length) {
847 JIT::compilePatchGetArrayLength(callFrame->scopeChain()->globalData, codeBlock, returnAddress);
848 return;
849 }
850
851 if (isJSString(globalData, baseValue) && propertyName == callFrame->propertyNames().length) {
852 // The tradeoff of compiling an patched inline string length access routine does not seem
853 // to pay off, so we currently only do this for arrays.
854 ctiPatchCallByReturnAddress(codeBlock, returnAddress, globalData->jitStubs.ctiStringLengthTrampoline());
855 return;
856 }
857
858 // Uncacheable: give up.
859 if (!slot.isCacheable()) {
860 ctiPatchCallByReturnAddress(codeBlock, returnAddress, FunctionPtr(cti_op_get_by_id_generic));
861 return;
862 }
863
864 JSCell* baseCell = asCell(baseValue);
865 Structure* structure = baseCell->structure();
866
867 if (structure->isUncacheableDictionary()) {
868 ctiPatchCallByReturnAddress(codeBlock, returnAddress, FunctionPtr(cti_op_get_by_id_generic));
869 return;
870 }
871
872 // Cache hit: Specialize instruction and ref Structures.
873
874 if (slot.slotBase() == baseValue) {
875 // set this up, so derefStructures can do it's job.
876 stubInfo->initGetByIdSelf(structure);
877
878 JIT::patchGetByIdSelf(codeBlock, stubInfo, structure, slot.cachedOffset(), returnAddress);
879 return;
880 }
881
882 if (structure->isDictionary()) {
883 ctiPatchCallByReturnAddress(codeBlock, returnAddress, FunctionPtr(cti_op_get_by_id_generic));
884 return;
885 }
886
887 if (slot.slotBase() == structure->prototypeForLookup(callFrame)) {
888 ASSERT(slot.slotBase().isObject());
889
890 JSObject* slotBaseObject = asObject(slot.slotBase());
891 size_t offset = slot.cachedOffset();
892
893 // Since we're accessing a prototype in a loop, it's a good bet that it
894 // should not be treated as a dictionary.
895 if (slotBaseObject->structure()->isDictionary()) {
896 slotBaseObject->flattenDictionaryObject();
897 offset = slotBaseObject->structure()->get(propertyName);
898 }
899
900 stubInfo->initGetByIdProto(structure, slotBaseObject->structure());
901
902 ASSERT(!structure->isDictionary());
903 ASSERT(!slotBaseObject->structure()->isDictionary());
904 JIT::compileGetByIdProto(callFrame->scopeChain()->globalData, callFrame, codeBlock, stubInfo, structure, slotBaseObject->structure(), offset, returnAddress);
905 return;
906 }
907
908 size_t offset = slot.cachedOffset();
909 size_t count = normalizePrototypeChain(callFrame, baseValue, slot.slotBase(), propertyName, offset);
910 if (!count) {
911 stubInfo->accessType = access_get_by_id_generic;
912 return;
913 }
914
915 StructureChain* prototypeChain = structure->prototypeChain(callFrame);
916 stubInfo->initGetByIdChain(structure, prototypeChain);
917 JIT::compileGetByIdChain(callFrame->scopeChain()->globalData, callFrame, codeBlock, stubInfo, structure, prototypeChain, count, offset, returnAddress);
918 }
919
920 #endif // ENABLE(JIT_OPTIMIZE_PROPERTY_ACCESS)
921
922 #if USE(JIT_STUB_ARGUMENT_VA_LIST)
923 #define SETUP_VA_LISTL_ARGS va_list vl_args; va_start(vl_args, args)
924 #else
925 #define SETUP_VA_LISTL_ARGS
926 #endif
927
928 #ifndef NDEBUG
929
930 extern "C" {
931
932 static void jscGeneratedNativeCode()
933 {
934 // When executing a JIT stub function (which might do an allocation), we hack the return address
935 // to pretend to be executing this function, to keep stack logging tools from blowing out
936 // memory.
937 }
938
939 }
940
941 struct StackHack {
942 ALWAYS_INLINE StackHack(JITStackFrame& stackFrame)
943 : stackFrame(stackFrame)
944 , savedReturnAddress(*stackFrame.returnAddressSlot())
945 {
946 *stackFrame.returnAddressSlot() = ReturnAddressPtr(FunctionPtr(jscGeneratedNativeCode));
947 }
948
949 ALWAYS_INLINE ~StackHack()
950 {
951 *stackFrame.returnAddressSlot() = savedReturnAddress;
952 }
953
954 JITStackFrame& stackFrame;
955 ReturnAddressPtr savedReturnAddress;
956 };
957
958 #define STUB_INIT_STACK_FRAME(stackFrame) SETUP_VA_LISTL_ARGS; JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS); StackHack stackHack(stackFrame)
959 #define STUB_SET_RETURN_ADDRESS(returnAddress) stackHack.savedReturnAddress = ReturnAddressPtr(returnAddress)
960 #define STUB_RETURN_ADDRESS stackHack.savedReturnAddress
961
962 #else
963
964 #define STUB_INIT_STACK_FRAME(stackFrame) SETUP_VA_LISTL_ARGS; JITStackFrame& stackFrame = *reinterpret_cast<JITStackFrame*>(STUB_ARGS)
965 #define STUB_SET_RETURN_ADDRESS(returnAddress) *stackFrame.returnAddressSlot() = ReturnAddressPtr(returnAddress)
966 #define STUB_RETURN_ADDRESS *stackFrame.returnAddressSlot()
967
968 #endif
969
970 // The reason this is not inlined is to avoid having to do a PIC branch
971 // to get the address of the ctiVMThrowTrampoline function. It's also
972 // good to keep the code size down by leaving as much of the exception
973 // handling code out of line as possible.
974 static NEVER_INLINE void returnToThrowTrampoline(JSGlobalData* globalData, ReturnAddressPtr exceptionLocation, ReturnAddressPtr& returnAddressSlot)
975 {
976 ASSERT(globalData->exception);
977 globalData->exceptionLocation = exceptionLocation;
978 returnAddressSlot = ReturnAddressPtr(FunctionPtr(ctiVMThrowTrampoline));
979 }
980
981 static NEVER_INLINE void throwStackOverflowError(CallFrame* callFrame, JSGlobalData* globalData, ReturnAddressPtr exceptionLocation, ReturnAddressPtr& returnAddressSlot)
982 {
983 globalData->exception = createStackOverflowError(callFrame);
984 returnToThrowTrampoline(globalData, exceptionLocation, returnAddressSlot);
985 }
986
987 #define VM_THROW_EXCEPTION() \
988 do { \
989 VM_THROW_EXCEPTION_AT_END(); \
990 return 0; \
991 } while (0)
992 #define VM_THROW_EXCEPTION_AT_END() \
993 returnToThrowTrampoline(stackFrame.globalData, STUB_RETURN_ADDRESS, STUB_RETURN_ADDRESS)
994
995 #define CHECK_FOR_EXCEPTION() \
996 do { \
997 if (UNLIKELY(stackFrame.globalData->exception)) \
998 VM_THROW_EXCEPTION(); \
999 } while (0)
1000 #define CHECK_FOR_EXCEPTION_AT_END() \
1001 do { \
1002 if (UNLIKELY(stackFrame.globalData->exception)) \
1003 VM_THROW_EXCEPTION_AT_END(); \
1004 } while (0)
1005 #define CHECK_FOR_EXCEPTION_VOID() \
1006 do { \
1007 if (UNLIKELY(stackFrame.globalData->exception)) { \
1008 VM_THROW_EXCEPTION_AT_END(); \
1009 return; \
1010 } \
1011 } while (0)
1012
1013 #if CPU(ARM_THUMB2)
1014
1015 #define DEFINE_STUB_FUNCTION(rtype, op) \
1016 extern "C" { \
1017 rtype JITStubThunked_##op(STUB_ARGS_DECLARATION); \
1018 }; \
1019 asm volatile ( \
1020 ".text" "\n" \
1021 ".align 2" "\n" \
1022 ".globl " SYMBOL_STRING(cti_##op) "\n" \
1023 HIDE_SYMBOL(cti_##op) "\n" \
1024 ".thumb" "\n" \
1025 ".thumb_func " THUMB_FUNC_PARAM(cti_##op) "\n" \
1026 SYMBOL_STRING(cti_##op) ":" "\n" \
1027 "str lr, [sp, #0x1c]" "\n" \
1028 "bl " SYMBOL_STRING(JITStubThunked_##op) "\n" \
1029 "ldr lr, [sp, #0x1c]" "\n" \
1030 "bx lr" "\n" \
1031 ); \
1032 rtype JITStubThunked_##op(STUB_ARGS_DECLARATION) \
1033
1034 #elif CPU(ARM_TRADITIONAL) && COMPILER(GCC)
1035
1036 #if USE(JSVALUE32_64)
1037 #define THUNK_RETURN_ADDRESS_OFFSET 64
1038 #else
1039 #define THUNK_RETURN_ADDRESS_OFFSET 32
1040 #endif
1041
1042 COMPILE_ASSERT(offsetof(struct JITStackFrame, thunkReturnAddress) == THUNK_RETURN_ADDRESS_OFFSET, JITStackFrame_thunkReturnAddress_offset_mismatch);
1043
1044 #define DEFINE_STUB_FUNCTION(rtype, op) \
1045 extern "C" { \
1046 rtype JITStubThunked_##op(STUB_ARGS_DECLARATION); \
1047 }; \
1048 asm volatile ( \
1049 ".globl " SYMBOL_STRING(cti_##op) "\n" \
1050 SYMBOL_STRING(cti_##op) ":" "\n" \
1051 "str lr, [sp, #" STRINGIZE_VALUE_OF(THUNK_RETURN_ADDRESS_OFFSET) "]" "\n" \
1052 "bl " SYMBOL_STRING(JITStubThunked_##op) "\n" \
1053 "ldr lr, [sp, #" STRINGIZE_VALUE_OF(THUNK_RETURN_ADDRESS_OFFSET) "]" "\n" \
1054 "mov pc, lr" "\n" \
1055 ); \
1056 rtype JITStubThunked_##op(STUB_ARGS_DECLARATION)
1057
1058 #elif CPU(ARM_TRADITIONAL) && COMPILER(RVCT)
1059
1060 #define DEFINE_STUB_FUNCTION(rtype, op) rtype JITStubThunked_##op(STUB_ARGS_DECLARATION)
1061
1062 /* The following is a workaround for RVCT toolchain; precompiler macros are not expanded before the code is passed to the assembler */
1063
1064 /* The following section is a template to generate code for GeneratedJITStubs_RVCT.h */
1065 /* The pattern "#xxx#" will be replaced with "xxx" */
1066
1067 /*
1068 RVCT(extern "C" #rtype# JITStubThunked_#op#(STUB_ARGS_DECLARATION);)
1069 RVCT(__asm #rtype# cti_#op#(STUB_ARGS_DECLARATION))
1070 RVCT({)
1071 RVCT( ARM)
1072 RVCT( IMPORT JITStubThunked_#op#)
1073 RVCT( str lr, [sp, #32])
1074 RVCT( bl JITStubThunked_#op#)
1075 RVCT( ldr lr, [sp, #32])
1076 RVCT( bx lr)
1077 RVCT(})
1078 RVCT()
1079 */
1080
1081 /* Include the generated file */
1082 #include "GeneratedJITStubs_RVCT.h"
1083
1084 #else
1085 #define DEFINE_STUB_FUNCTION(rtype, op) rtype JIT_STUB cti_##op(STUB_ARGS_DECLARATION)
1086 #endif
1087
1088 DEFINE_STUB_FUNCTION(EncodedJSValue, op_convert_this)
1089 {
1090 STUB_INIT_STACK_FRAME(stackFrame);
1091
1092 JSValue v1 = stackFrame.args[0].jsValue();
1093 CallFrame* callFrame = stackFrame.callFrame;
1094
1095 JSObject* result = v1.toThisObject(callFrame);
1096 CHECK_FOR_EXCEPTION_AT_END();
1097 return JSValue::encode(result);
1098 }
1099
1100 DEFINE_STUB_FUNCTION(void, op_end)
1101 {
1102 STUB_INIT_STACK_FRAME(stackFrame);
1103
1104 ScopeChainNode* scopeChain = stackFrame.callFrame->scopeChain();
1105 ASSERT(scopeChain->refCount > 1);
1106 scopeChain->deref();
1107 }
1108
1109 DEFINE_STUB_FUNCTION(EncodedJSValue, op_add)
1110 {
1111 STUB_INIT_STACK_FRAME(stackFrame);
1112
1113 JSValue v1 = stackFrame.args[0].jsValue();
1114 JSValue v2 = stackFrame.args[1].jsValue();
1115 CallFrame* callFrame = stackFrame.callFrame;
1116
1117 if (v1.isString()) {
1118 JSValue result = v2.isString()
1119 ? jsString(callFrame, asString(v1), asString(v2))
1120 : jsString(callFrame, asString(v1), v2.toPrimitiveString(callFrame));
1121 CHECK_FOR_EXCEPTION_AT_END();
1122 return JSValue::encode(result);
1123 }
1124
1125 double left = 0.0, right;
1126 if (v1.getNumber(left) && v2.getNumber(right))
1127 return JSValue::encode(jsNumber(stackFrame.globalData, left + right));
1128
1129 // All other cases are pretty uncommon
1130 JSValue result = jsAddSlowCase(callFrame, v1, v2);
1131 CHECK_FOR_EXCEPTION_AT_END();
1132 return JSValue::encode(result);
1133 }
1134
1135 DEFINE_STUB_FUNCTION(EncodedJSValue, op_pre_inc)
1136 {
1137 STUB_INIT_STACK_FRAME(stackFrame);
1138
1139 JSValue v = stackFrame.args[0].jsValue();
1140
1141 CallFrame* callFrame = stackFrame.callFrame;
1142 JSValue result = jsNumber(stackFrame.globalData, v.toNumber(callFrame) + 1);
1143 CHECK_FOR_EXCEPTION_AT_END();
1144 return JSValue::encode(result);
1145 }
1146
1147 DEFINE_STUB_FUNCTION(int, timeout_check)
1148 {
1149 STUB_INIT_STACK_FRAME(stackFrame);
1150
1151 JSGlobalData* globalData = stackFrame.globalData;
1152 TimeoutChecker& timeoutChecker = globalData->timeoutChecker;
1153
1154 if (timeoutChecker.didTimeOut(stackFrame.callFrame)) {
1155 globalData->exception = createInterruptedExecutionException(globalData);
1156 VM_THROW_EXCEPTION_AT_END();
1157 }
1158
1159 return timeoutChecker.ticksUntilNextCheck();
1160 }
1161
1162 DEFINE_STUB_FUNCTION(void, register_file_check)
1163 {
1164 STUB_INIT_STACK_FRAME(stackFrame);
1165
1166 if (LIKELY(stackFrame.registerFile->grow(&stackFrame.callFrame->registers()[stackFrame.callFrame->codeBlock()->m_numCalleeRegisters])))
1167 return;
1168
1169 // Rewind to the previous call frame because op_call already optimistically
1170 // moved the call frame forward.
1171 CallFrame* oldCallFrame = stackFrame.callFrame->callerFrame();
1172 stackFrame.callFrame = oldCallFrame;
1173 throwStackOverflowError(oldCallFrame, stackFrame.globalData, ReturnAddressPtr(oldCallFrame->returnPC()), STUB_RETURN_ADDRESS);
1174 }
1175
1176 DEFINE_STUB_FUNCTION(int, op_loop_if_lesseq)
1177 {
1178 STUB_INIT_STACK_FRAME(stackFrame);
1179
1180 JSValue src1 = stackFrame.args[0].jsValue();
1181 JSValue src2 = stackFrame.args[1].jsValue();
1182 CallFrame* callFrame = stackFrame.callFrame;
1183
1184 bool result = jsLessEq(callFrame, src1, src2);
1185 CHECK_FOR_EXCEPTION_AT_END();
1186 return result;
1187 }
1188
1189 DEFINE_STUB_FUNCTION(JSObject*, op_new_object)
1190 {
1191 STUB_INIT_STACK_FRAME(stackFrame);
1192
1193 return constructEmptyObject(stackFrame.callFrame);
1194 }
1195
1196 DEFINE_STUB_FUNCTION(void, op_put_by_id_generic)
1197 {
1198 STUB_INIT_STACK_FRAME(stackFrame);
1199
1200 PutPropertySlot slot;
1201 stackFrame.args[0].jsValue().put(stackFrame.callFrame, stackFrame.args[1].identifier(), stackFrame.args[2].jsValue(), slot);
1202 CHECK_FOR_EXCEPTION_AT_END();
1203 }
1204
1205 DEFINE_STUB_FUNCTION(EncodedJSValue, op_get_by_id_generic)
1206 {
1207 STUB_INIT_STACK_FRAME(stackFrame);
1208
1209 CallFrame* callFrame = stackFrame.callFrame;
1210 Identifier& ident = stackFrame.args[1].identifier();
1211
1212 JSValue baseValue = stackFrame.args[0].jsValue();
1213 PropertySlot slot(baseValue);
1214 JSValue result = baseValue.get(callFrame, ident, slot);
1215
1216 CHECK_FOR_EXCEPTION_AT_END();
1217 return JSValue::encode(result);
1218 }
1219
1220 #if ENABLE(JIT_OPTIMIZE_PROPERTY_ACCESS)
1221
1222 DEFINE_STUB_FUNCTION(void, op_put_by_id)
1223 {
1224 STUB_INIT_STACK_FRAME(stackFrame);
1225 CallFrame* callFrame = stackFrame.callFrame;
1226 Identifier& ident = stackFrame.args[1].identifier();
1227
1228 PutPropertySlot slot;
1229 stackFrame.args[0].jsValue().put(callFrame, ident, stackFrame.args[2].jsValue(), slot);
1230
1231 CodeBlock* codeBlock = stackFrame.callFrame->codeBlock();
1232 StructureStubInfo* stubInfo = &codeBlock->getStubInfo(STUB_RETURN_ADDRESS);
1233 if (!stubInfo->seenOnce())
1234 stubInfo->setSeen();
1235 else
1236 JITThunks::tryCachePutByID(callFrame, codeBlock, STUB_RETURN_ADDRESS, stackFrame.args[0].jsValue(), slot, stubInfo);
1237
1238 CHECK_FOR_EXCEPTION_AT_END();
1239 }
1240
1241 DEFINE_STUB_FUNCTION(void, op_put_by_id_fail)
1242 {
1243 STUB_INIT_STACK_FRAME(stackFrame);
1244
1245 CallFrame* callFrame = stackFrame.callFrame;
1246 Identifier& ident = stackFrame.args[1].identifier();
1247
1248 PutPropertySlot slot;
1249 stackFrame.args[0].jsValue().put(callFrame, ident, stackFrame.args[2].jsValue(), slot);
1250
1251 CHECK_FOR_EXCEPTION_AT_END();
1252 }
1253
1254 DEFINE_STUB_FUNCTION(JSObject*, op_put_by_id_transition_realloc)
1255 {
1256 STUB_INIT_STACK_FRAME(stackFrame);
1257
1258 JSValue baseValue = stackFrame.args[0].jsValue();
1259 int32_t oldSize = stackFrame.args[3].int32();
1260 int32_t newSize = stackFrame.args[4].int32();
1261
1262 ASSERT(baseValue.isObject());
1263 JSObject* base = asObject(baseValue);
1264 base->allocatePropertyStorage(oldSize, newSize);
1265
1266 return base;
1267 }
1268
1269 DEFINE_STUB_FUNCTION(EncodedJSValue, op_get_by_id_method_check)
1270 {
1271 STUB_INIT_STACK_FRAME(stackFrame);
1272
1273 CallFrame* callFrame = stackFrame.callFrame;
1274 Identifier& ident = stackFrame.args[1].identifier();
1275
1276 JSValue baseValue = stackFrame.args[0].jsValue();
1277 PropertySlot slot(baseValue);
1278 JSValue result = baseValue.get(callFrame, ident, slot);
1279 CHECK_FOR_EXCEPTION();
1280
1281 CodeBlock* codeBlock = stackFrame.callFrame->codeBlock();
1282 MethodCallLinkInfo& methodCallLinkInfo = codeBlock->getMethodCallLinkInfo(STUB_RETURN_ADDRESS);
1283
1284 if (!methodCallLinkInfo.seenOnce()) {
1285 methodCallLinkInfo.setSeen();
1286 return JSValue::encode(result);
1287 }
1288
1289 // If we successfully got something, then the base from which it is being accessed must
1290 // be an object. (Assertion to ensure asObject() call below is safe, which comes after
1291 // an isCacheable() chceck.
1292 ASSERT(!slot.isCacheable() || slot.slotBase().isObject());
1293
1294 // Check that:
1295 // * We're dealing with a JSCell,
1296 // * the property is cachable,
1297 // * it's not a dictionary
1298 // * there is a function cached.
1299 Structure* structure;
1300 JSCell* specific;
1301 JSObject* slotBaseObject;
1302 if (baseValue.isCell()
1303 && slot.isCacheable()
1304 && !(structure = asCell(baseValue)->structure())->isUncacheableDictionary()
1305 && (slotBaseObject = asObject(slot.slotBase()))->getPropertySpecificValue(callFrame, ident, specific)
1306 && specific
1307 ) {
1308
1309 JSFunction* callee = (JSFunction*)specific;
1310
1311 // Since we're accessing a prototype in a loop, it's a good bet that it
1312 // should not be treated as a dictionary.
1313 if (slotBaseObject->structure()->isDictionary())
1314 slotBaseObject->flattenDictionaryObject();
1315
1316 // The result fetched should always be the callee!
1317 ASSERT(result == JSValue(callee));
1318
1319 // Check to see if the function is on the object's prototype. Patch up the code to optimize.
1320 if (slot.slotBase() == structure->prototypeForLookup(callFrame)) {
1321 JIT::patchMethodCallProto(codeBlock, methodCallLinkInfo, callee, structure, slotBaseObject, STUB_RETURN_ADDRESS);
1322 return JSValue::encode(result);
1323 }
1324
1325 // Check to see if the function is on the object itself.
1326 // Since we generate the method-check to check both the structure and a prototype-structure (since this
1327 // is the common case) we have a problem - we need to patch the prototype structure check to do something
1328 // useful. We could try to nop it out altogether, but that's a little messy, so lets do something simpler
1329 // for now. For now it performs a check on a special object on the global object only used for this
1330 // purpose. The object is in no way exposed, and as such the check will always pass.
1331 if (slot.slotBase() == baseValue) {
1332 JIT::patchMethodCallProto(codeBlock, methodCallLinkInfo, callee, structure, callFrame->scopeChain()->globalObject->methodCallDummy(), STUB_RETURN_ADDRESS);
1333 return JSValue::encode(result);
1334 }
1335 }
1336
1337 // Revert the get_by_id op back to being a regular get_by_id - allow it to cache like normal, if it needs to.
1338 ctiPatchCallByReturnAddress(codeBlock, STUB_RETURN_ADDRESS, FunctionPtr(cti_op_get_by_id));
1339 return JSValue::encode(result);
1340 }
1341
1342 DEFINE_STUB_FUNCTION(EncodedJSValue, op_get_by_id)
1343 {
1344 STUB_INIT_STACK_FRAME(stackFrame);
1345 CallFrame* callFrame = stackFrame.callFrame;
1346 Identifier& ident = stackFrame.args[1].identifier();
1347
1348 JSValue baseValue = stackFrame.args[0].jsValue();
1349 PropertySlot slot(baseValue);
1350 JSValue result = baseValue.get(callFrame, ident, slot);
1351
1352 CodeBlock* codeBlock = stackFrame.callFrame->codeBlock();
1353 StructureStubInfo* stubInfo = &codeBlock->getStubInfo(STUB_RETURN_ADDRESS);
1354 if (!stubInfo->seenOnce())
1355 stubInfo->setSeen();
1356 else
1357 JITThunks::tryCacheGetByID(callFrame, codeBlock, STUB_RETURN_ADDRESS, baseValue, ident, slot, stubInfo);
1358
1359 CHECK_FOR_EXCEPTION_AT_END();
1360 return JSValue::encode(result);
1361 }
1362
1363 DEFINE_STUB_FUNCTION(EncodedJSValue, op_get_by_id_self_fail)
1364 {
1365 STUB_INIT_STACK_FRAME(stackFrame);
1366
1367 CallFrame* callFrame = stackFrame.callFrame;
1368 Identifier& ident = stackFrame.args[1].identifier();
1369
1370 JSValue baseValue = stackFrame.args[0].jsValue();
1371 PropertySlot slot(baseValue);
1372 JSValue result = baseValue.get(callFrame, ident, slot);
1373
1374 CHECK_FOR_EXCEPTION();
1375
1376 if (baseValue.isCell()
1377 && slot.isCacheable()
1378 && !asCell(baseValue)->structure()->isUncacheableDictionary()
1379 && slot.slotBase() == baseValue) {
1380
1381 CodeBlock* codeBlock = callFrame->codeBlock();
1382 StructureStubInfo* stubInfo = &codeBlock->getStubInfo(STUB_RETURN_ADDRESS);
1383
1384 ASSERT(slot.slotBase().isObject());
1385
1386 PolymorphicAccessStructureList* polymorphicStructureList;
1387 int listIndex = 1;
1388
1389 if (stubInfo->accessType == access_get_by_id_self) {
1390 ASSERT(!stubInfo->stubRoutine);
1391 polymorphicStructureList = new PolymorphicAccessStructureList(CodeLocationLabel(), stubInfo->u.getByIdSelf.baseObjectStructure);
1392 stubInfo->initGetByIdSelfList(polymorphicStructureList, 2);
1393 } else {
1394 polymorphicStructureList = stubInfo->u.getByIdSelfList.structureList;
1395 listIndex = stubInfo->u.getByIdSelfList.listSize;
1396 stubInfo->u.getByIdSelfList.listSize++;
1397 }
1398
1399 JIT::compileGetByIdSelfList(callFrame->scopeChain()->globalData, codeBlock, stubInfo, polymorphicStructureList, listIndex, asCell(baseValue)->structure(), slot.cachedOffset());
1400
1401 if (listIndex == (POLYMORPHIC_LIST_CACHE_SIZE - 1))
1402 ctiPatchCallByReturnAddress(codeBlock, STUB_RETURN_ADDRESS, FunctionPtr(cti_op_get_by_id_generic));
1403 } else
1404 ctiPatchCallByReturnAddress(callFrame->codeBlock(), STUB_RETURN_ADDRESS, FunctionPtr(cti_op_get_by_id_generic));
1405 return JSValue::encode(result);
1406 }
1407
1408 static PolymorphicAccessStructureList* getPolymorphicAccessStructureListSlot(StructureStubInfo* stubInfo, int& listIndex)
1409 {
1410 PolymorphicAccessStructureList* prototypeStructureList = 0;
1411 listIndex = 1;
1412
1413 switch (stubInfo->accessType) {
1414 case access_get_by_id_proto:
1415 prototypeStructureList = new PolymorphicAccessStructureList(stubInfo->stubRoutine, stubInfo->u.getByIdProto.baseObjectStructure, stubInfo->u.getByIdProto.prototypeStructure);
1416 stubInfo->stubRoutine = CodeLocationLabel();
1417 stubInfo->initGetByIdProtoList(prototypeStructureList, 2);
1418 break;
1419 case access_get_by_id_chain:
1420 prototypeStructureList = new PolymorphicAccessStructureList(stubInfo->stubRoutine, stubInfo->u.getByIdChain.baseObjectStructure, stubInfo->u.getByIdChain.chain);
1421 stubInfo->stubRoutine = CodeLocationLabel();
1422 stubInfo->initGetByIdProtoList(prototypeStructureList, 2);
1423 break;
1424 case access_get_by_id_proto_list:
1425 prototypeStructureList = stubInfo->u.getByIdProtoList.structureList;
1426 listIndex = stubInfo->u.getByIdProtoList.listSize;
1427 stubInfo->u.getByIdProtoList.listSize++;
1428 break;
1429 default:
1430 ASSERT_NOT_REACHED();
1431 }
1432
1433 ASSERT(listIndex < POLYMORPHIC_LIST_CACHE_SIZE);
1434 return prototypeStructureList;
1435 }
1436
1437 DEFINE_STUB_FUNCTION(EncodedJSValue, op_get_by_id_proto_list)
1438 {
1439 STUB_INIT_STACK_FRAME(stackFrame);
1440
1441 CallFrame* callFrame = stackFrame.callFrame;
1442 const Identifier& propertyName = stackFrame.args[1].identifier();
1443
1444 JSValue baseValue = stackFrame.args[0].jsValue();
1445 PropertySlot slot(baseValue);
1446 JSValue result = baseValue.get(callFrame, propertyName, slot);
1447
1448 CHECK_FOR_EXCEPTION();
1449
1450 if (!baseValue.isCell() || !slot.isCacheable() || asCell(baseValue)->structure()->isDictionary()) {
1451 ctiPatchCallByReturnAddress(callFrame->codeBlock(), STUB_RETURN_ADDRESS, FunctionPtr(cti_op_get_by_id_proto_fail));
1452 return JSValue::encode(result);
1453 }
1454
1455 Structure* structure = asCell(baseValue)->structure();
1456 CodeBlock* codeBlock = callFrame->codeBlock();
1457 StructureStubInfo* stubInfo = &codeBlock->getStubInfo(STUB_RETURN_ADDRESS);
1458
1459 ASSERT(slot.slotBase().isObject());
1460 JSObject* slotBaseObject = asObject(slot.slotBase());
1461
1462 size_t offset = slot.cachedOffset();
1463
1464 if (slot.slotBase() == baseValue)
1465 ctiPatchCallByReturnAddress(codeBlock, STUB_RETURN_ADDRESS, FunctionPtr(cti_op_get_by_id_proto_fail));
1466 else if (slot.slotBase() == asCell(baseValue)->structure()->prototypeForLookup(callFrame)) {
1467 ASSERT(!asCell(baseValue)->structure()->isDictionary());
1468 // Since we're accessing a prototype in a loop, it's a good bet that it
1469 // should not be treated as a dictionary.
1470 if (slotBaseObject->structure()->isDictionary()) {
1471 slotBaseObject->flattenDictionaryObject();
1472 offset = slotBaseObject->structure()->get(propertyName);
1473 }
1474
1475 int listIndex;
1476 PolymorphicAccessStructureList* prototypeStructureList = getPolymorphicAccessStructureListSlot(stubInfo, listIndex);
1477
1478 JIT::compileGetByIdProtoList(callFrame->scopeChain()->globalData, callFrame, codeBlock, stubInfo, prototypeStructureList, listIndex, structure, slotBaseObject->structure(), offset);
1479
1480 if (listIndex == (POLYMORPHIC_LIST_CACHE_SIZE - 1))
1481 ctiPatchCallByReturnAddress(codeBlock, STUB_RETURN_ADDRESS, FunctionPtr(cti_op_get_by_id_proto_list_full));
1482 } else if (size_t count = normalizePrototypeChain(callFrame, baseValue, slot.slotBase(), propertyName, offset)) {
1483 ASSERT(!asCell(baseValue)->structure()->isDictionary());
1484 int listIndex;
1485 PolymorphicAccessStructureList* prototypeStructureList = getPolymorphicAccessStructureListSlot(stubInfo, listIndex);
1486
1487 StructureChain* protoChain = structure->prototypeChain(callFrame);
1488 JIT::compileGetByIdChainList(callFrame->scopeChain()->globalData, callFrame, codeBlock, stubInfo, prototypeStructureList, listIndex, structure, protoChain, count, offset);
1489
1490 if (listIndex == (POLYMORPHIC_LIST_CACHE_SIZE - 1))
1491 ctiPatchCallByReturnAddress(codeBlock, STUB_RETURN_ADDRESS, FunctionPtr(cti_op_get_by_id_proto_list_full));
1492 } else
1493 ctiPatchCallByReturnAddress(codeBlock, STUB_RETURN_ADDRESS, FunctionPtr(cti_op_get_by_id_proto_fail));
1494
1495 return JSValue::encode(result);
1496 }
1497
1498 DEFINE_STUB_FUNCTION(EncodedJSValue, op_get_by_id_proto_list_full)
1499 {
1500 STUB_INIT_STACK_FRAME(stackFrame);
1501
1502 JSValue baseValue = stackFrame.args[0].jsValue();
1503 PropertySlot slot(baseValue);
1504 JSValue result = baseValue.get(stackFrame.callFrame, stackFrame.args[1].identifier(), slot);
1505
1506 CHECK_FOR_EXCEPTION_AT_END();
1507 return JSValue::encode(result);
1508 }
1509
1510 DEFINE_STUB_FUNCTION(EncodedJSValue, op_get_by_id_proto_fail)
1511 {
1512 STUB_INIT_STACK_FRAME(stackFrame);
1513
1514 JSValue baseValue = stackFrame.args[0].jsValue();
1515 PropertySlot slot(baseValue);
1516 JSValue result = baseValue.get(stackFrame.callFrame, stackFrame.args[1].identifier(), slot);
1517
1518 CHECK_FOR_EXCEPTION_AT_END();
1519 return JSValue::encode(result);
1520 }
1521
1522 DEFINE_STUB_FUNCTION(EncodedJSValue, op_get_by_id_array_fail)
1523 {
1524 STUB_INIT_STACK_FRAME(stackFrame);
1525
1526 JSValue baseValue = stackFrame.args[0].jsValue();
1527 PropertySlot slot(baseValue);
1528 JSValue result = baseValue.get(stackFrame.callFrame, stackFrame.args[1].identifier(), slot);
1529
1530 CHECK_FOR_EXCEPTION_AT_END();
1531 return JSValue::encode(result);
1532 }
1533
1534 DEFINE_STUB_FUNCTION(EncodedJSValue, op_get_by_id_string_fail)
1535 {
1536 STUB_INIT_STACK_FRAME(stackFrame);
1537
1538 JSValue baseValue = stackFrame.args[0].jsValue();
1539 PropertySlot slot(baseValue);
1540 JSValue result = baseValue.get(stackFrame.callFrame, stackFrame.args[1].identifier(), slot);
1541
1542 CHECK_FOR_EXCEPTION_AT_END();
1543 return JSValue::encode(result);
1544 }
1545
1546 #endif // ENABLE(JIT_OPTIMIZE_PROPERTY_ACCESS)
1547
1548 DEFINE_STUB_FUNCTION(EncodedJSValue, op_instanceof)
1549 {
1550 STUB_INIT_STACK_FRAME(stackFrame);
1551
1552 CallFrame* callFrame = stackFrame.callFrame;
1553 JSValue value = stackFrame.args[0].jsValue();
1554 JSValue baseVal = stackFrame.args[1].jsValue();
1555 JSValue proto = stackFrame.args[2].jsValue();
1556
1557 // At least one of these checks must have failed to get to the slow case.
1558 ASSERT(!value.isCell() || !baseVal.isCell() || !proto.isCell()
1559 || !value.isObject() || !baseVal.isObject() || !proto.isObject()
1560 || (asObject(baseVal)->structure()->typeInfo().flags() & (ImplementsHasInstance | OverridesHasInstance)) != ImplementsHasInstance);
1561
1562
1563 // ECMA-262 15.3.5.3:
1564 // Throw an exception either if baseVal is not an object, or if it does not implement 'HasInstance' (i.e. is a function).
1565 TypeInfo typeInfo(UnspecifiedType);
1566 if (!baseVal.isObject() || !(typeInfo = asObject(baseVal)->structure()->typeInfo()).implementsHasInstance()) {
1567 CallFrame* callFrame = stackFrame.callFrame;
1568 CodeBlock* codeBlock = callFrame->codeBlock();
1569 unsigned vPCIndex = codeBlock->getBytecodeIndex(callFrame, STUB_RETURN_ADDRESS);
1570 stackFrame.globalData->exception = createInvalidParamError(callFrame, "instanceof", baseVal, vPCIndex, codeBlock);
1571 VM_THROW_EXCEPTION();
1572 }
1573 ASSERT(typeInfo.type() != UnspecifiedType);
1574
1575 if (!typeInfo.overridesHasInstance()) {
1576 if (!value.isObject())
1577 return JSValue::encode(jsBoolean(false));
1578
1579 if (!proto.isObject()) {
1580 throwError(callFrame, TypeError, "instanceof called on an object with an invalid prototype property.");
1581 VM_THROW_EXCEPTION();
1582 }
1583 }
1584
1585 JSValue result = jsBoolean(asObject(baseVal)->hasInstance(callFrame, value, proto));
1586 CHECK_FOR_EXCEPTION_AT_END();
1587
1588 return JSValue::encode(result);
1589 }
1590
1591 DEFINE_STUB_FUNCTION(EncodedJSValue, op_del_by_id)
1592 {
1593 STUB_INIT_STACK_FRAME(stackFrame);
1594
1595 CallFrame* callFrame = stackFrame.callFrame;
1596
1597 JSObject* baseObj = stackFrame.args[0].jsValue().toObject(callFrame);
1598
1599 JSValue result = jsBoolean(baseObj->deleteProperty(callFrame, stackFrame.args[1].identifier()));
1600 CHECK_FOR_EXCEPTION_AT_END();
1601 return JSValue::encode(result);
1602 }
1603
1604 DEFINE_STUB_FUNCTION(EncodedJSValue, op_mul)
1605 {
1606 STUB_INIT_STACK_FRAME(stackFrame);
1607
1608 JSValue src1 = stackFrame.args[0].jsValue();
1609 JSValue src2 = stackFrame.args[1].jsValue();
1610
1611 double left;
1612 double right;
1613 if (src1.getNumber(left) && src2.getNumber(right))
1614 return JSValue::encode(jsNumber(stackFrame.globalData, left * right));
1615
1616 CallFrame* callFrame = stackFrame.callFrame;
1617 JSValue result = jsNumber(stackFrame.globalData, src1.toNumber(callFrame) * src2.toNumber(callFrame));
1618 CHECK_FOR_EXCEPTION_AT_END();
1619 return JSValue::encode(result);
1620 }
1621
1622 DEFINE_STUB_FUNCTION(JSObject*, op_new_func)
1623 {
1624 STUB_INIT_STACK_FRAME(stackFrame);
1625
1626 return stackFrame.args[0].function()->make(stackFrame.callFrame, stackFrame.callFrame->scopeChain());
1627 }
1628
1629 DEFINE_STUB_FUNCTION(void*, op_call_JSFunction)
1630 {
1631 STUB_INIT_STACK_FRAME(stackFrame);
1632
1633 #if !ASSERT_DISABLED
1634 CallData callData;
1635 ASSERT(stackFrame.args[0].jsValue().getCallData(callData) == CallTypeJS);
1636 #endif
1637
1638 JSFunction* function = asFunction(stackFrame.args[0].jsValue());
1639 ASSERT(!function->isHostFunction());
1640 FunctionExecutable* executable = function->jsExecutable();
1641 ScopeChainNode* callDataScopeChain = function->scope().node();
1642 executable->jitCode(stackFrame.callFrame, callDataScopeChain);
1643
1644 return function;
1645 }
1646
1647 DEFINE_STUB_FUNCTION(VoidPtrPair, op_call_arityCheck)
1648 {
1649 STUB_INIT_STACK_FRAME(stackFrame);
1650
1651 CallFrame* callFrame = stackFrame.callFrame;
1652 JSFunction* callee = asFunction(stackFrame.args[0].jsValue());
1653 ASSERT(!callee->isHostFunction());
1654 CodeBlock* newCodeBlock = &callee->jsExecutable()->generatedBytecode();
1655 int argCount = stackFrame.args[2].int32();
1656
1657 ASSERT(argCount != newCodeBlock->m_numParameters);
1658
1659 CallFrame* oldCallFrame = callFrame->callerFrame();
1660
1661 if (argCount > newCodeBlock->m_numParameters) {
1662 size_t numParameters = newCodeBlock->m_numParameters;
1663 Register* r = callFrame->registers() + numParameters;
1664
1665 Register* argv = r - RegisterFile::CallFrameHeaderSize - numParameters - argCount;
1666 for (size_t i = 0; i < numParameters; ++i)
1667 argv[i + argCount] = argv[i];
1668
1669 callFrame = CallFrame::create(r);
1670 callFrame->setCallerFrame(oldCallFrame);
1671 } else {
1672 size_t omittedArgCount = newCodeBlock->m_numParameters - argCount;
1673 Register* r = callFrame->registers() + omittedArgCount;
1674 Register* newEnd = r + newCodeBlock->m_numCalleeRegisters;
1675 if (!stackFrame.registerFile->grow(newEnd)) {
1676 // Rewind to the previous call frame because op_call already optimistically
1677 // moved the call frame forward.
1678 stackFrame.callFrame = oldCallFrame;
1679 throwStackOverflowError(oldCallFrame, stackFrame.globalData, stackFrame.args[1].returnAddress(), STUB_RETURN_ADDRESS);
1680 RETURN_POINTER_PAIR(0, 0);
1681 }
1682
1683 Register* argv = r - RegisterFile::CallFrameHeaderSize - omittedArgCount;
1684 for (size_t i = 0; i < omittedArgCount; ++i)
1685 argv[i] = jsUndefined();
1686
1687 callFrame = CallFrame::create(r);
1688 callFrame->setCallerFrame(oldCallFrame);
1689 }
1690
1691 RETURN_POINTER_PAIR(callee, callFrame);
1692 }
1693
1694 #if ENABLE(JIT_OPTIMIZE_CALL)
1695 DEFINE_STUB_FUNCTION(void*, vm_lazyLinkCall)
1696 {
1697 STUB_INIT_STACK_FRAME(stackFrame);
1698 JSFunction* callee = asFunction(stackFrame.args[0].jsValue());
1699 ExecutableBase* executable = callee->executable();
1700 JITCode& jitCode = executable->generatedJITCode();
1701
1702 CodeBlock* codeBlock = 0;
1703 if (!executable->isHostFunction())
1704 codeBlock = &static_cast<FunctionExecutable*>(executable)->bytecode(stackFrame.callFrame, callee->scope().node());
1705 CallLinkInfo* callLinkInfo = &stackFrame.callFrame->callerFrame()->codeBlock()->getCallLinkInfo(stackFrame.args[1].returnAddress());
1706
1707 if (!callLinkInfo->seenOnce())
1708 callLinkInfo->setSeen();
1709 else
1710 JIT::linkCall(callee, stackFrame.callFrame->callerFrame()->codeBlock(), codeBlock, jitCode, callLinkInfo, stackFrame.args[2].int32(), stackFrame.globalData);
1711
1712 return jitCode.addressForCall().executableAddress();
1713 }
1714 #endif // !ENABLE(JIT_OPTIMIZE_CALL)
1715
1716 DEFINE_STUB_FUNCTION(JSObject*, op_push_activation)
1717 {
1718 STUB_INIT_STACK_FRAME(stackFrame);
1719
1720 JSActivation* activation = new (stackFrame.globalData) JSActivation(stackFrame.callFrame, static_cast<FunctionExecutable*>(stackFrame.callFrame->codeBlock()->ownerExecutable()));
1721 stackFrame.callFrame->setScopeChain(stackFrame.callFrame->scopeChain()->copy()->push(activation));
1722 return activation;
1723 }
1724
1725 DEFINE_STUB_FUNCTION(EncodedJSValue, op_call_NotJSFunction)
1726 {
1727 STUB_INIT_STACK_FRAME(stackFrame);
1728
1729 JSValue funcVal = stackFrame.args[0].jsValue();
1730
1731 CallData callData;
1732 CallType callType = funcVal.getCallData(callData);
1733
1734 ASSERT(callType != CallTypeJS);
1735
1736 if (callType == CallTypeHost) {
1737 int registerOffset = stackFrame.args[1].int32();
1738 int argCount = stackFrame.args[2].int32();
1739 CallFrame* previousCallFrame = stackFrame.callFrame;
1740 CallFrame* callFrame = CallFrame::create(previousCallFrame->registers() + registerOffset);
1741
1742 callFrame->init(0, static_cast<Instruction*>((STUB_RETURN_ADDRESS).value()), previousCallFrame->scopeChain(), previousCallFrame, 0, argCount, 0);
1743 stackFrame.callFrame = callFrame;
1744
1745 Register* argv = stackFrame.callFrame->registers() - RegisterFile::CallFrameHeaderSize - argCount;
1746 ArgList argList(argv + 1, argCount - 1);
1747
1748 JSValue returnValue;
1749 {
1750 SamplingTool::HostCallRecord callRecord(CTI_SAMPLER);
1751
1752 // FIXME: All host methods should be calling toThisObject, but this is not presently the case.
1753 JSValue thisValue = argv[0].jsValue();
1754 if (thisValue == jsNull())
1755 thisValue = callFrame->globalThisValue();
1756
1757 returnValue = callData.native.function(callFrame, asObject(funcVal), thisValue, argList);
1758 }
1759 stackFrame.callFrame = previousCallFrame;
1760 CHECK_FOR_EXCEPTION();
1761
1762 return JSValue::encode(returnValue);
1763 }
1764
1765 ASSERT(callType == CallTypeNone);
1766
1767 CallFrame* callFrame = stackFrame.callFrame;
1768 CodeBlock* codeBlock = callFrame->codeBlock();
1769 unsigned vPCIndex = codeBlock->getBytecodeIndex(callFrame, STUB_RETURN_ADDRESS);
1770 stackFrame.globalData->exception = createNotAFunctionError(stackFrame.callFrame, funcVal, vPCIndex, codeBlock);
1771 VM_THROW_EXCEPTION();
1772 }
1773
1774 DEFINE_STUB_FUNCTION(void, op_create_arguments)
1775 {
1776 STUB_INIT_STACK_FRAME(stackFrame);
1777
1778 Arguments* arguments = new (stackFrame.globalData) Arguments(stackFrame.callFrame);
1779 stackFrame.callFrame->setCalleeArguments(arguments);
1780 stackFrame.callFrame[RegisterFile::ArgumentsRegister] = JSValue(arguments);
1781 }
1782
1783 DEFINE_STUB_FUNCTION(void, op_create_arguments_no_params)
1784 {
1785 STUB_INIT_STACK_FRAME(stackFrame);
1786
1787 Arguments* arguments = new (stackFrame.globalData) Arguments(stackFrame.callFrame, Arguments::NoParameters);
1788 stackFrame.callFrame->setCalleeArguments(arguments);
1789 stackFrame.callFrame[RegisterFile::ArgumentsRegister] = JSValue(arguments);
1790 }
1791
1792 DEFINE_STUB_FUNCTION(void, op_tear_off_activation)
1793 {
1794 STUB_INIT_STACK_FRAME(stackFrame);
1795
1796 ASSERT(stackFrame.callFrame->codeBlock()->needsFullScopeChain());
1797 asActivation(stackFrame.args[0].jsValue())->copyRegisters(stackFrame.callFrame->optionalCalleeArguments());
1798 }
1799
1800 DEFINE_STUB_FUNCTION(void, op_tear_off_arguments)
1801 {
1802 STUB_INIT_STACK_FRAME(stackFrame);
1803
1804 ASSERT(stackFrame.callFrame->codeBlock()->usesArguments() && !stackFrame.callFrame->codeBlock()->needsFullScopeChain());
1805 if (stackFrame.callFrame->optionalCalleeArguments())
1806 stackFrame.callFrame->optionalCalleeArguments()->copyRegisters();
1807 }
1808
1809 DEFINE_STUB_FUNCTION(void, op_profile_will_call)
1810 {
1811 STUB_INIT_STACK_FRAME(stackFrame);
1812
1813 ASSERT(*stackFrame.enabledProfilerReference);
1814 (*stackFrame.enabledProfilerReference)->willExecute(stackFrame.callFrame, stackFrame.args[0].jsValue());
1815 }
1816
1817 DEFINE_STUB_FUNCTION(void, op_profile_did_call)
1818 {
1819 STUB_INIT_STACK_FRAME(stackFrame);
1820
1821 ASSERT(*stackFrame.enabledProfilerReference);
1822 (*stackFrame.enabledProfilerReference)->didExecute(stackFrame.callFrame, stackFrame.args[0].jsValue());
1823 }
1824
1825 DEFINE_STUB_FUNCTION(void, op_ret_scopeChain)
1826 {
1827 STUB_INIT_STACK_FRAME(stackFrame);
1828
1829 ASSERT(stackFrame.callFrame->codeBlock()->needsFullScopeChain());
1830 stackFrame.callFrame->scopeChain()->deref();
1831 }
1832
1833 DEFINE_STUB_FUNCTION(JSObject*, op_new_array)
1834 {
1835 STUB_INIT_STACK_FRAME(stackFrame);
1836
1837 ArgList argList(&stackFrame.callFrame->registers()[stackFrame.args[0].int32()], stackFrame.args[1].int32());
1838 return constructArray(stackFrame.callFrame, argList);
1839 }
1840
1841 DEFINE_STUB_FUNCTION(EncodedJSValue, op_resolve)
1842 {
1843 STUB_INIT_STACK_FRAME(stackFrame);
1844
1845 CallFrame* callFrame = stackFrame.callFrame;
1846 ScopeChainNode* scopeChain = callFrame->scopeChain();
1847
1848 ScopeChainIterator iter = scopeChain->begin();
1849 ScopeChainIterator end = scopeChain->end();
1850 ASSERT(iter != end);
1851
1852 Identifier& ident = stackFrame.args[0].identifier();
1853 do {
1854 JSObject* o = *iter;
1855 PropertySlot slot(o);
1856 if (o->getPropertySlot(callFrame, ident, slot)) {
1857 JSValue result = slot.getValue(callFrame, ident);
1858 CHECK_FOR_EXCEPTION_AT_END();
1859 return JSValue::encode(result);
1860 }
1861 } while (++iter != end);
1862
1863 CodeBlock* codeBlock = callFrame->codeBlock();
1864 unsigned vPCIndex = codeBlock->getBytecodeIndex(callFrame, STUB_RETURN_ADDRESS);
1865 stackFrame.globalData->exception = createUndefinedVariableError(callFrame, ident, vPCIndex, codeBlock);
1866 VM_THROW_EXCEPTION();
1867 }
1868
1869 DEFINE_STUB_FUNCTION(JSObject*, op_construct_JSConstruct)
1870 {
1871 STUB_INIT_STACK_FRAME(stackFrame);
1872
1873 JSFunction* constructor = asFunction(stackFrame.args[0].jsValue());
1874 if (constructor->isHostFunction()) {
1875 CallFrame* callFrame = stackFrame.callFrame;
1876 CodeBlock* codeBlock = callFrame->codeBlock();
1877 unsigned vPCIndex = codeBlock->getBytecodeIndex(callFrame, STUB_RETURN_ADDRESS);
1878 stackFrame.globalData->exception = createNotAConstructorError(callFrame, constructor, vPCIndex, codeBlock);
1879 VM_THROW_EXCEPTION();
1880 }
1881
1882 #if !ASSERT_DISABLED
1883 ConstructData constructData;
1884 ASSERT(constructor->getConstructData(constructData) == ConstructTypeJS);
1885 #endif
1886
1887 Structure* structure;
1888 if (stackFrame.args[3].jsValue().isObject())
1889 structure = asObject(stackFrame.args[3].jsValue())->inheritorID();
1890 else
1891 structure = constructor->scope().node()->globalObject->emptyObjectStructure();
1892 return new (stackFrame.globalData) JSObject(structure);
1893 }
1894
1895 DEFINE_STUB_FUNCTION(EncodedJSValue, op_construct_NotJSConstruct)
1896 {
1897 STUB_INIT_STACK_FRAME(stackFrame);
1898
1899 CallFrame* callFrame = stackFrame.callFrame;
1900
1901 JSValue constrVal = stackFrame.args[0].jsValue();
1902 int argCount = stackFrame.args[2].int32();
1903 int thisRegister = stackFrame.args[4].int32();
1904
1905 ConstructData constructData;
1906 ConstructType constructType = constrVal.getConstructData(constructData);
1907
1908 if (constructType == ConstructTypeHost) {
1909 ArgList argList(callFrame->registers() + thisRegister + 1, argCount - 1);
1910
1911 JSValue returnValue;
1912 {
1913 SamplingTool::HostCallRecord callRecord(CTI_SAMPLER);
1914 returnValue = constructData.native.function(callFrame, asObject(constrVal), argList);
1915 }
1916 CHECK_FOR_EXCEPTION();
1917
1918 return JSValue::encode(returnValue);
1919 }
1920
1921 ASSERT(constructType == ConstructTypeNone);
1922
1923 CodeBlock* codeBlock = callFrame->codeBlock();
1924 unsigned vPCIndex = codeBlock->getBytecodeIndex(callFrame, STUB_RETURN_ADDRESS);
1925 stackFrame.globalData->exception = createNotAConstructorError(callFrame, constrVal, vPCIndex, codeBlock);
1926 VM_THROW_EXCEPTION();
1927 }
1928
1929 DEFINE_STUB_FUNCTION(EncodedJSValue, op_get_by_val)
1930 {
1931 STUB_INIT_STACK_FRAME(stackFrame);
1932
1933 CallFrame* callFrame = stackFrame.callFrame;
1934 JSGlobalData* globalData = stackFrame.globalData;
1935
1936 JSValue baseValue = stackFrame.args[0].jsValue();
1937 JSValue subscript = stackFrame.args[1].jsValue();
1938
1939 JSValue result;
1940
1941 if (LIKELY(subscript.isUInt32())) {
1942 uint32_t i = subscript.asUInt32();
1943 if (isJSArray(globalData, baseValue)) {
1944 JSArray* jsArray = asArray(baseValue);
1945 if (jsArray->canGetIndex(i))
1946 result = jsArray->getIndex(i);
1947 else
1948 result = jsArray->JSArray::get(callFrame, i);
1949 } else if (isJSString(globalData, baseValue) && asString(baseValue)->canGetIndex(i)) {
1950 // All fast byte array accesses are safe from exceptions so return immediately to avoid exception checks.
1951 ctiPatchCallByReturnAddress(callFrame->codeBlock(), STUB_RETURN_ADDRESS, FunctionPtr(cti_op_get_by_val_string));
1952 result = asString(baseValue)->getIndex(callFrame, i);
1953 } else if (isJSByteArray(globalData, baseValue) && asByteArray(baseValue)->canAccessIndex(i)) {
1954 // All fast byte array accesses are safe from exceptions so return immediately to avoid exception checks.
1955 ctiPatchCallByReturnAddress(callFrame->codeBlock(), STUB_RETURN_ADDRESS, FunctionPtr(cti_op_get_by_val_byte_array));
1956 return JSValue::encode(asByteArray(baseValue)->getIndex(callFrame, i));
1957 } else
1958 result = baseValue.get(callFrame, i);
1959 } else {
1960 Identifier property(callFrame, subscript.toString(callFrame));
1961 result = baseValue.get(callFrame, property);
1962 }
1963
1964 CHECK_FOR_EXCEPTION_AT_END();
1965 return JSValue::encode(result);
1966 }
1967
1968 DEFINE_STUB_FUNCTION(EncodedJSValue, op_get_by_val_string)
1969 {
1970 STUB_INIT_STACK_FRAME(stackFrame);
1971
1972 CallFrame* callFrame = stackFrame.callFrame;
1973 JSGlobalData* globalData = stackFrame.globalData;
1974
1975 JSValue baseValue = stackFrame.args[0].jsValue();
1976 JSValue subscript = stackFrame.args[1].jsValue();
1977
1978 JSValue result;
1979
1980 if (LIKELY(subscript.isUInt32())) {
1981 uint32_t i = subscript.asUInt32();
1982 if (isJSString(globalData, baseValue) && asString(baseValue)->canGetIndex(i))
1983 result = asString(baseValue)->getIndex(callFrame, i);
1984 else {
1985 result = baseValue.get(callFrame, i);
1986 if (!isJSString(globalData, baseValue))
1987 ctiPatchCallByReturnAddress(callFrame->codeBlock(), STUB_RETURN_ADDRESS, FunctionPtr(cti_op_get_by_val));
1988 }
1989 } else {
1990 Identifier property(callFrame, subscript.toString(callFrame));
1991 result = baseValue.get(callFrame, property);
1992 }
1993
1994 CHECK_FOR_EXCEPTION_AT_END();
1995 return JSValue::encode(result);
1996 }
1997
1998 DEFINE_STUB_FUNCTION(EncodedJSValue, op_get_by_val_byte_array)
1999 {
2000 STUB_INIT_STACK_FRAME(stackFrame);
2001
2002 CallFrame* callFrame = stackFrame.callFrame;
2003 JSGlobalData* globalData = stackFrame.globalData;
2004
2005 JSValue baseValue = stackFrame.args[0].jsValue();
2006 JSValue subscript = stackFrame.args[1].jsValue();
2007
2008 JSValue result;
2009
2010 if (LIKELY(subscript.isUInt32())) {
2011 uint32_t i = subscript.asUInt32();
2012 if (isJSByteArray(globalData, baseValue) && asByteArray(baseValue)->canAccessIndex(i)) {
2013 // All fast byte array accesses are safe from exceptions so return immediately to avoid exception checks.
2014 return JSValue::encode(asByteArray(baseValue)->getIndex(callFrame, i));
2015 }
2016
2017 result = baseValue.get(callFrame, i);
2018 if (!isJSByteArray(globalData, baseValue))
2019 ctiPatchCallByReturnAddress(callFrame->codeBlock(), STUB_RETURN_ADDRESS, FunctionPtr(cti_op_get_by_val));
2020 } else {
2021 Identifier property(callFrame, subscript.toString(callFrame));
2022 result = baseValue.get(callFrame, property);
2023 }
2024
2025 CHECK_FOR_EXCEPTION_AT_END();
2026 return JSValue::encode(result);
2027 }
2028
2029 DEFINE_STUB_FUNCTION(EncodedJSValue, op_sub)
2030 {
2031 STUB_INIT_STACK_FRAME(stackFrame);
2032
2033 JSValue src1 = stackFrame.args[0].jsValue();
2034 JSValue src2 = stackFrame.args[1].jsValue();
2035
2036 double left;
2037 double right;
2038 if (src1.getNumber(left) && src2.getNumber(right))
2039 return JSValue::encode(jsNumber(stackFrame.globalData, left - right));
2040
2041 CallFrame* callFrame = stackFrame.callFrame;
2042 JSValue result = jsNumber(stackFrame.globalData, src1.toNumber(callFrame) - src2.toNumber(callFrame));
2043 CHECK_FOR_EXCEPTION_AT_END();
2044 return JSValue::encode(result);
2045 }
2046
2047 DEFINE_STUB_FUNCTION(void, op_put_by_val)
2048 {
2049 STUB_INIT_STACK_FRAME(stackFrame);
2050
2051 CallFrame* callFrame = stackFrame.callFrame;
2052 JSGlobalData* globalData = stackFrame.globalData;
2053
2054 JSValue baseValue = stackFrame.args[0].jsValue();
2055 JSValue subscript = stackFrame.args[1].jsValue();
2056 JSValue value = stackFrame.args[2].jsValue();
2057
2058 if (LIKELY(subscript.isUInt32())) {
2059 uint32_t i = subscript.asUInt32();
2060 if (isJSArray(globalData, baseValue)) {
2061 JSArray* jsArray = asArray(baseValue);
2062 if (jsArray->canSetIndex(i))
2063 jsArray->setIndex(i, value);
2064 else
2065 jsArray->JSArray::put(callFrame, i, value);
2066 } else if (isJSByteArray(globalData, baseValue) && asByteArray(baseValue)->canAccessIndex(i)) {
2067 JSByteArray* jsByteArray = asByteArray(baseValue);
2068 ctiPatchCallByReturnAddress(callFrame->codeBlock(), STUB_RETURN_ADDRESS, FunctionPtr(cti_op_put_by_val_byte_array));
2069 // All fast byte array accesses are safe from exceptions so return immediately to avoid exception checks.
2070 if (value.isInt32()) {
2071 jsByteArray->setIndex(i, value.asInt32());
2072 return;
2073 } else {
2074 double dValue = 0;
2075 if (value.getNumber(dValue)) {
2076 jsByteArray->setIndex(i, dValue);
2077 return;
2078 }
2079 }
2080
2081 baseValue.put(callFrame, i, value);
2082 } else
2083 baseValue.put(callFrame, i, value);
2084 } else {
2085 Identifier property(callFrame, subscript.toString(callFrame));
2086 if (!stackFrame.globalData->exception) { // Don't put to an object if toString threw an exception.
2087 PutPropertySlot slot;
2088 baseValue.put(callFrame, property, value, slot);
2089 }
2090 }
2091
2092 CHECK_FOR_EXCEPTION_AT_END();
2093 }
2094
2095 DEFINE_STUB_FUNCTION(void, op_put_by_val_byte_array)
2096 {
2097 STUB_INIT_STACK_FRAME(stackFrame);
2098
2099 CallFrame* callFrame = stackFrame.callFrame;
2100 JSGlobalData* globalData = stackFrame.globalData;
2101
2102 JSValue baseValue = stackFrame.args[0].jsValue();
2103 JSValue subscript = stackFrame.args[1].jsValue();
2104 JSValue value = stackFrame.args[2].jsValue();
2105
2106 if (LIKELY(subscript.isUInt32())) {
2107 uint32_t i = subscript.asUInt32();
2108 if (isJSByteArray(globalData, baseValue) && asByteArray(baseValue)->canAccessIndex(i)) {
2109 JSByteArray* jsByteArray = asByteArray(baseValue);
2110
2111 // All fast byte array accesses are safe from exceptions so return immediately to avoid exception checks.
2112 if (value.isInt32()) {
2113 jsByteArray->setIndex(i, value.asInt32());
2114 return;
2115 } else {
2116 double dValue = 0;
2117 if (value.getNumber(dValue)) {
2118 jsByteArray->setIndex(i, dValue);
2119 return;
2120 }
2121 }
2122 }
2123
2124 if (!isJSByteArray(globalData, baseValue))
2125 ctiPatchCallByReturnAddress(callFrame->codeBlock(), STUB_RETURN_ADDRESS, FunctionPtr(cti_op_put_by_val));
2126 baseValue.put(callFrame, i, value);
2127 } else {
2128 Identifier property(callFrame, subscript.toString(callFrame));
2129 if (!stackFrame.globalData->exception) { // Don't put to an object if toString threw an exception.
2130 PutPropertySlot slot;
2131 baseValue.put(callFrame, property, value, slot);
2132 }
2133 }
2134
2135 CHECK_FOR_EXCEPTION_AT_END();
2136 }
2137
2138 DEFINE_STUB_FUNCTION(EncodedJSValue, op_lesseq)
2139 {
2140 STUB_INIT_STACK_FRAME(stackFrame);
2141
2142 CallFrame* callFrame = stackFrame.callFrame;
2143 JSValue result = jsBoolean(jsLessEq(callFrame, stackFrame.args[0].jsValue(), stackFrame.args[1].jsValue()));
2144 CHECK_FOR_EXCEPTION_AT_END();
2145 return JSValue::encode(result);
2146 }
2147
2148 DEFINE_STUB_FUNCTION(int, op_load_varargs)
2149 {
2150 STUB_INIT_STACK_FRAME(stackFrame);
2151
2152 CallFrame* callFrame = stackFrame.callFrame;
2153 RegisterFile* registerFile = stackFrame.registerFile;
2154 int argsOffset = stackFrame.args[0].int32();
2155 JSValue arguments = callFrame->registers()[argsOffset].jsValue();
2156 uint32_t argCount = 0;
2157 if (!arguments) {
2158 int providedParams = callFrame->registers()[RegisterFile::ArgumentCount].i() - 1;
2159 argCount = providedParams;
2160 int32_t sizeDelta = argsOffset + argCount + RegisterFile::CallFrameHeaderSize;
2161 Register* newEnd = callFrame->registers() + sizeDelta;
2162 if (!registerFile->grow(newEnd) || ((newEnd - callFrame->registers()) != sizeDelta)) {
2163 stackFrame.globalData->exception = createStackOverflowError(callFrame);
2164 VM_THROW_EXCEPTION();
2165 }
2166 int32_t expectedParams = callFrame->callee()->jsExecutable()->parameterCount();
2167 int32_t inplaceArgs = min(providedParams, expectedParams);
2168
2169 Register* inplaceArgsDst = callFrame->registers() + argsOffset;
2170
2171 Register* inplaceArgsEnd = inplaceArgsDst + inplaceArgs;
2172 Register* inplaceArgsEnd2 = inplaceArgsDst + providedParams;
2173
2174 Register* inplaceArgsSrc = callFrame->registers() - RegisterFile::CallFrameHeaderSize - expectedParams;
2175 Register* inplaceArgsSrc2 = inplaceArgsSrc - providedParams - 1 + inplaceArgs;
2176
2177 // First step is to copy the "expected" parameters from their normal location relative to the callframe
2178 while (inplaceArgsDst < inplaceArgsEnd)
2179 *inplaceArgsDst++ = *inplaceArgsSrc++;
2180
2181 // Then we copy any additional arguments that may be further up the stack ('-1' to account for 'this')
2182 while (inplaceArgsDst < inplaceArgsEnd2)
2183 *inplaceArgsDst++ = *inplaceArgsSrc2++;
2184
2185 } else if (!arguments.isUndefinedOrNull()) {
2186 if (!arguments.isObject()) {
2187 CodeBlock* codeBlock = callFrame->codeBlock();
2188 unsigned vPCIndex = codeBlock->getBytecodeIndex(callFrame, STUB_RETURN_ADDRESS);
2189 stackFrame.globalData->exception = createInvalidParamError(callFrame, "Function.prototype.apply", arguments, vPCIndex, codeBlock);
2190 VM_THROW_EXCEPTION();
2191 }
2192 if (asObject(arguments)->classInfo() == &Arguments::info) {
2193 Arguments* argsObject = asArguments(arguments);
2194 argCount = argsObject->numProvidedArguments(callFrame);
2195 int32_t sizeDelta = argsOffset + argCount + RegisterFile::CallFrameHeaderSize;
2196 Register* newEnd = callFrame->registers() + sizeDelta;
2197 if (!registerFile->grow(newEnd) || ((newEnd - callFrame->registers()) != sizeDelta)) {
2198 stackFrame.globalData->exception = createStackOverflowError(callFrame);
2199 VM_THROW_EXCEPTION();
2200 }
2201 argsObject->copyToRegisters(callFrame, callFrame->registers() + argsOffset, argCount);
2202 } else if (isJSArray(&callFrame->globalData(), arguments)) {
2203 JSArray* array = asArray(arguments);
2204 argCount = array->length();
2205 int32_t sizeDelta = argsOffset + argCount + RegisterFile::CallFrameHeaderSize;
2206 Register* newEnd = callFrame->registers() + sizeDelta;
2207 if (!registerFile->grow(newEnd) || ((newEnd - callFrame->registers()) != sizeDelta)) {
2208 stackFrame.globalData->exception = createStackOverflowError(callFrame);
2209 VM_THROW_EXCEPTION();
2210 }
2211 array->copyToRegisters(callFrame, callFrame->registers() + argsOffset, argCount);
2212 } else if (asObject(arguments)->inherits(&JSArray::info)) {
2213 JSObject* argObject = asObject(arguments);
2214 argCount = argObject->get(callFrame, callFrame->propertyNames().length).toUInt32(callFrame);
2215 int32_t sizeDelta = argsOffset + argCount + RegisterFile::CallFrameHeaderSize;
2216 Register* newEnd = callFrame->registers() + sizeDelta;
2217 if (!registerFile->grow(newEnd) || ((newEnd - callFrame->registers()) != sizeDelta)) {
2218 stackFrame.globalData->exception = createStackOverflowError(callFrame);
2219 VM_THROW_EXCEPTION();
2220 }
2221 Register* argsBuffer = callFrame->registers() + argsOffset;
2222 for (unsigned i = 0; i < argCount; ++i) {
2223 argsBuffer[i] = asObject(arguments)->get(callFrame, i);
2224 CHECK_FOR_EXCEPTION();
2225 }
2226 } else {
2227 CodeBlock* codeBlock = callFrame->codeBlock();
2228 unsigned vPCIndex = codeBlock->getBytecodeIndex(callFrame, STUB_RETURN_ADDRESS);
2229 stackFrame.globalData->exception = createInvalidParamError(callFrame, "Function.prototype.apply", arguments, vPCIndex, codeBlock);
2230 VM_THROW_EXCEPTION();
2231 }
2232 }
2233
2234 return argCount + 1;
2235 }
2236
2237 DEFINE_STUB_FUNCTION(EncodedJSValue, op_negate)
2238 {
2239 STUB_INIT_STACK_FRAME(stackFrame);
2240
2241 JSValue src = stackFrame.args[0].jsValue();
2242
2243 double v;
2244 if (src.getNumber(v))
2245 return JSValue::encode(jsNumber(stackFrame.globalData, -v));
2246
2247 CallFrame* callFrame = stackFrame.callFrame;
2248 JSValue result = jsNumber(stackFrame.globalData, -src.toNumber(callFrame));
2249 CHECK_FOR_EXCEPTION_AT_END();
2250 return JSValue::encode(result);
2251 }
2252
2253 DEFINE_STUB_FUNCTION(EncodedJSValue, op_resolve_base)
2254 {
2255 STUB_INIT_STACK_FRAME(stackFrame);
2256
2257 return JSValue::encode(JSC::resolveBase(stackFrame.callFrame, stackFrame.args[0].identifier(), stackFrame.callFrame->scopeChain()));
2258 }
2259
2260 DEFINE_STUB_FUNCTION(EncodedJSValue, op_resolve_skip)
2261 {
2262 STUB_INIT_STACK_FRAME(stackFrame);
2263
2264 CallFrame* callFrame = stackFrame.callFrame;
2265 ScopeChainNode* scopeChain = callFrame->scopeChain();
2266
2267 int skip = stackFrame.args[1].int32();
2268
2269 ScopeChainIterator iter = scopeChain->begin();
2270 ScopeChainIterator end = scopeChain->end();
2271 ASSERT(iter != end);
2272 while (skip--) {
2273 ++iter;
2274 ASSERT(iter != end);
2275 }
2276 Identifier& ident = stackFrame.args[0].identifier();
2277 do {
2278 JSObject* o = *iter;
2279 PropertySlot slot(o);
2280 if (o->getPropertySlot(callFrame, ident, slot)) {
2281 JSValue result = slot.getValue(callFrame, ident);
2282 CHECK_FOR_EXCEPTION_AT_END();
2283 return JSValue::encode(result);
2284 }
2285 } while (++iter != end);
2286
2287 CodeBlock* codeBlock = callFrame->codeBlock();
2288 unsigned vPCIndex = codeBlock->getBytecodeIndex(callFrame, STUB_RETURN_ADDRESS);
2289 stackFrame.globalData->exception = createUndefinedVariableError(callFrame, ident, vPCIndex, codeBlock);
2290 VM_THROW_EXCEPTION();
2291 }
2292
2293 DEFINE_STUB_FUNCTION(EncodedJSValue, op_resolve_global)
2294 {
2295 STUB_INIT_STACK_FRAME(stackFrame);
2296
2297 CallFrame* callFrame = stackFrame.callFrame;
2298 JSGlobalObject* globalObject = stackFrame.args[0].globalObject();
2299 Identifier& ident = stackFrame.args[1].identifier();
2300 unsigned globalResolveInfoIndex = stackFrame.args[2].int32();
2301 ASSERT(globalObject->isGlobalObject());
2302
2303 PropertySlot slot(globalObject);
2304 if (globalObject->getPropertySlot(callFrame, ident, slot)) {
2305 JSValue result = slot.getValue(callFrame, ident);
2306 if (slot.isCacheable() && !globalObject->structure()->isUncacheableDictionary() && slot.slotBase() == globalObject) {
2307 GlobalResolveInfo& globalResolveInfo = callFrame->codeBlock()->globalResolveInfo(globalResolveInfoIndex);
2308 if (globalResolveInfo.structure)
2309 globalResolveInfo.structure->deref();
2310 globalObject->structure()->ref();
2311 globalResolveInfo.structure = globalObject->structure();
2312 globalResolveInfo.offset = slot.cachedOffset();
2313 return JSValue::encode(result);
2314 }
2315
2316 CHECK_FOR_EXCEPTION_AT_END();
2317 return JSValue::encode(result);
2318 }
2319
2320 unsigned vPCIndex = callFrame->codeBlock()->getBytecodeIndex(callFrame, STUB_RETURN_ADDRESS);
2321 stackFrame.globalData->exception = createUndefinedVariableError(callFrame, ident, vPCIndex, callFrame->codeBlock());
2322 VM_THROW_EXCEPTION();
2323 }
2324
2325 DEFINE_STUB_FUNCTION(EncodedJSValue, op_div)
2326 {
2327 STUB_INIT_STACK_FRAME(stackFrame);
2328
2329 JSValue src1 = stackFrame.args[0].jsValue();
2330 JSValue src2 = stackFrame.args[1].jsValue();
2331
2332 double left;
2333 double right;
2334 if (src1.getNumber(left) && src2.getNumber(right))
2335 return JSValue::encode(jsNumber(stackFrame.globalData, left / right));
2336
2337 CallFrame* callFrame = stackFrame.callFrame;
2338 JSValue result = jsNumber(stackFrame.globalData, src1.toNumber(callFrame) / src2.toNumber(callFrame));
2339 CHECK_FOR_EXCEPTION_AT_END();
2340 return JSValue::encode(result);
2341 }
2342
2343 DEFINE_STUB_FUNCTION(EncodedJSValue, op_pre_dec)
2344 {
2345 STUB_INIT_STACK_FRAME(stackFrame);
2346
2347 JSValue v = stackFrame.args[0].jsValue();
2348
2349 CallFrame* callFrame = stackFrame.callFrame;
2350 JSValue result = jsNumber(stackFrame.globalData, v.toNumber(callFrame) - 1);
2351 CHECK_FOR_EXCEPTION_AT_END();
2352 return JSValue::encode(result);
2353 }
2354
2355 DEFINE_STUB_FUNCTION(int, op_jless)
2356 {
2357 STUB_INIT_STACK_FRAME(stackFrame);
2358
2359 JSValue src1 = stackFrame.args[0].jsValue();
2360 JSValue src2 = stackFrame.args[1].jsValue();
2361 CallFrame* callFrame = stackFrame.callFrame;
2362
2363 bool result = jsLess(callFrame, src1, src2);
2364 CHECK_FOR_EXCEPTION_AT_END();
2365 return result;
2366 }
2367
2368 DEFINE_STUB_FUNCTION(int, op_jlesseq)
2369 {
2370 STUB_INIT_STACK_FRAME(stackFrame);
2371
2372 JSValue src1 = stackFrame.args[0].jsValue();
2373 JSValue src2 = stackFrame.args[1].jsValue();
2374 CallFrame* callFrame = stackFrame.callFrame;
2375
2376 bool result = jsLessEq(callFrame, src1, src2);
2377 CHECK_FOR_EXCEPTION_AT_END();
2378 return result;
2379 }
2380
2381 DEFINE_STUB_FUNCTION(EncodedJSValue, op_not)
2382 {
2383 STUB_INIT_STACK_FRAME(stackFrame);
2384
2385 JSValue src = stackFrame.args[0].jsValue();
2386
2387 CallFrame* callFrame = stackFrame.callFrame;
2388
2389 JSValue result = jsBoolean(!src.toBoolean(callFrame));
2390 CHECK_FOR_EXCEPTION_AT_END();
2391 return JSValue::encode(result);
2392 }
2393
2394 DEFINE_STUB_FUNCTION(int, op_jtrue)
2395 {
2396 STUB_INIT_STACK_FRAME(stackFrame);
2397
2398 JSValue src1 = stackFrame.args[0].jsValue();
2399
2400 CallFrame* callFrame = stackFrame.callFrame;
2401
2402 bool result = src1.toBoolean(callFrame);
2403 CHECK_FOR_EXCEPTION_AT_END();
2404 return result;
2405 }
2406
2407 DEFINE_STUB_FUNCTION(EncodedJSValue, op_post_inc)
2408 {
2409 STUB_INIT_STACK_FRAME(stackFrame);
2410
2411 JSValue v = stackFrame.args[0].jsValue();
2412
2413 CallFrame* callFrame = stackFrame.callFrame;
2414
2415 JSValue number = v.toJSNumber(callFrame);
2416 CHECK_FOR_EXCEPTION_AT_END();
2417
2418 callFrame->registers()[stackFrame.args[1].int32()] = jsNumber(stackFrame.globalData, number.uncheckedGetNumber() + 1);
2419 return JSValue::encode(number);
2420 }
2421
2422 DEFINE_STUB_FUNCTION(int, op_eq)
2423 {
2424 STUB_INIT_STACK_FRAME(stackFrame);
2425
2426 JSValue src1 = stackFrame.args[0].jsValue();
2427 JSValue src2 = stackFrame.args[1].jsValue();
2428
2429 #if USE(JSVALUE32_64)
2430 start:
2431 if (src2.isUndefined()) {
2432 return src1.isNull() ||
2433 (src1.isCell() && asCell(src1)->structure()->typeInfo().masqueradesAsUndefined()) ||
2434 src1.isUndefined();
2435 }
2436
2437 if (src2.isNull()) {
2438 return src1.isUndefined() ||
2439 (src1.isCell() && asCell(src1)->structure()->typeInfo().masqueradesAsUndefined()) ||
2440 src1.isNull();
2441 }
2442
2443 if (src1.isInt32()) {
2444 if (src2.isDouble())
2445 return src1.asInt32() == src2.asDouble();
2446 double d = src2.toNumber(stackFrame.callFrame);
2447 CHECK_FOR_EXCEPTION();
2448 return src1.asInt32() == d;
2449 }
2450
2451 if (src1.isDouble()) {
2452 if (src2.isInt32())
2453 return src1.asDouble() == src2.asInt32();
2454 double d = src2.toNumber(stackFrame.callFrame);
2455 CHECK_FOR_EXCEPTION();
2456 return src1.asDouble() == d;
2457 }
2458
2459 if (src1.isTrue()) {
2460 if (src2.isFalse())
2461 return false;
2462 double d = src2.toNumber(stackFrame.callFrame);
2463 CHECK_FOR_EXCEPTION();
2464 return d == 1.0;
2465 }
2466
2467 if (src1.isFalse()) {
2468 if (src2.isTrue())
2469 return false;
2470 double d = src2.toNumber(stackFrame.callFrame);
2471 CHECK_FOR_EXCEPTION();
2472 return d == 0.0;
2473 }
2474
2475 if (src1.isUndefined())
2476 return src2.isCell() && asCell(src2)->structure()->typeInfo().masqueradesAsUndefined();
2477
2478 if (src1.isNull())
2479 return src2.isCell() && asCell(src2)->structure()->typeInfo().masqueradesAsUndefined();
2480
2481 JSCell* cell1 = asCell(src1);
2482
2483 if (cell1->isString()) {
2484 if (src2.isInt32())
2485 return static_cast<JSString*>(cell1)->value(stackFrame.callFrame).toDouble() == src2.asInt32();
2486
2487 if (src2.isDouble())
2488 return static_cast<JSString*>(cell1)->value(stackFrame.callFrame).toDouble() == src2.asDouble();
2489
2490 if (src2.isTrue())
2491 return static_cast<JSString*>(cell1)->value(stackFrame.callFrame).toDouble() == 1.0;
2492
2493 if (src2.isFalse())
2494 return static_cast<JSString*>(cell1)->value(stackFrame.callFrame).toDouble() == 0.0;
2495
2496 JSCell* cell2 = asCell(src2);
2497 if (cell2->isString())
2498 return static_cast<JSString*>(cell1)->value(stackFrame.callFrame) == static_cast<JSString*>(cell2)->value(stackFrame.callFrame);
2499
2500 src2 = asObject(cell2)->toPrimitive(stackFrame.callFrame);
2501 CHECK_FOR_EXCEPTION();
2502 goto start;
2503 }
2504
2505 if (src2.isObject())
2506 return asObject(cell1) == asObject(src2);
2507 src1 = asObject(cell1)->toPrimitive(stackFrame.callFrame);
2508 CHECK_FOR_EXCEPTION();
2509 goto start;
2510
2511 #else // USE(JSVALUE32_64)
2512 CallFrame* callFrame = stackFrame.callFrame;
2513
2514 bool result = JSValue::equalSlowCaseInline(callFrame, src1, src2);
2515 CHECK_FOR_EXCEPTION_AT_END();
2516 return result;
2517 #endif // USE(JSVALUE32_64)
2518 }
2519
2520 #if USE(JSVALUE32_64)
2521
2522 DEFINE_STUB_FUNCTION(int, op_eq_strings)
2523 {
2524 STUB_INIT_STACK_FRAME(stackFrame);
2525
2526 JSString* string1 = stackFrame.args[0].jsString();
2527 JSString* string2 = stackFrame.args[1].jsString();
2528
2529 ASSERT(string1->isString());
2530 ASSERT(string2->isString());
2531 return string1->value(stackFrame.callFrame) == string2->value(stackFrame.callFrame);
2532 }
2533
2534 #endif
2535
2536 DEFINE_STUB_FUNCTION(EncodedJSValue, op_lshift)
2537 {
2538 STUB_INIT_STACK_FRAME(stackFrame);
2539
2540 JSValue val = stackFrame.args[0].jsValue();
2541 JSValue shift = stackFrame.args[1].jsValue();
2542
2543 CallFrame* callFrame = stackFrame.callFrame;
2544 JSValue result = jsNumber(stackFrame.globalData, (val.toInt32(callFrame)) << (shift.toUInt32(callFrame) & 0x1f));
2545 CHECK_FOR_EXCEPTION_AT_END();
2546 return JSValue::encode(result);
2547 }
2548
2549 DEFINE_STUB_FUNCTION(EncodedJSValue, op_bitand)
2550 {
2551 STUB_INIT_STACK_FRAME(stackFrame);
2552
2553 JSValue src1 = stackFrame.args[0].jsValue();
2554 JSValue src2 = stackFrame.args[1].jsValue();
2555
2556 ASSERT(!src1.isInt32() || !src2.isInt32());
2557 CallFrame* callFrame = stackFrame.callFrame;
2558 JSValue result = jsNumber(stackFrame.globalData, src1.toInt32(callFrame) & src2.toInt32(callFrame));
2559 CHECK_FOR_EXCEPTION_AT_END();
2560 return JSValue::encode(result);
2561 }
2562
2563 DEFINE_STUB_FUNCTION(EncodedJSValue, op_rshift)
2564 {
2565 STUB_INIT_STACK_FRAME(stackFrame);
2566
2567 JSValue val = stackFrame.args[0].jsValue();
2568 JSValue shift = stackFrame.args[1].jsValue();
2569
2570 CallFrame* callFrame = stackFrame.callFrame;
2571 JSValue result = jsNumber(stackFrame.globalData, (val.toInt32(callFrame)) >> (shift.toUInt32(callFrame) & 0x1f));
2572
2573 CHECK_FOR_EXCEPTION_AT_END();
2574 return JSValue::encode(result);
2575 }
2576
2577 DEFINE_STUB_FUNCTION(EncodedJSValue, op_bitnot)
2578 {
2579 STUB_INIT_STACK_FRAME(stackFrame);
2580
2581 JSValue src = stackFrame.args[0].jsValue();
2582
2583 ASSERT(!src.isInt32());
2584 CallFrame* callFrame = stackFrame.callFrame;
2585 JSValue result = jsNumber(stackFrame.globalData, ~src.toInt32(callFrame));
2586 CHECK_FOR_EXCEPTION_AT_END();
2587 return JSValue::encode(result);
2588 }
2589
2590 DEFINE_STUB_FUNCTION(EncodedJSValue, op_resolve_with_base)
2591 {
2592 STUB_INIT_STACK_FRAME(stackFrame);
2593
2594 CallFrame* callFrame = stackFrame.callFrame;
2595 ScopeChainNode* scopeChain = callFrame->scopeChain();
2596
2597 ScopeChainIterator iter = scopeChain->begin();
2598 ScopeChainIterator end = scopeChain->end();
2599
2600 // FIXME: add scopeDepthIsZero optimization
2601
2602 ASSERT(iter != end);
2603
2604 Identifier& ident = stackFrame.args[0].identifier();
2605 JSObject* base;
2606 do {
2607 base = *iter;
2608 PropertySlot slot(base);
2609 if (base->getPropertySlot(callFrame, ident, slot)) {
2610 JSValue result = slot.getValue(callFrame, ident);
2611 CHECK_FOR_EXCEPTION_AT_END();
2612
2613 callFrame->registers()[stackFrame.args[1].int32()] = JSValue(base);
2614 return JSValue::encode(result);
2615 }
2616 ++iter;
2617 } while (iter != end);
2618
2619 CodeBlock* codeBlock = callFrame->codeBlock();
2620 unsigned vPCIndex = codeBlock->getBytecodeIndex(callFrame, STUB_RETURN_ADDRESS);
2621 stackFrame.globalData->exception = createUndefinedVariableError(callFrame, ident, vPCIndex, codeBlock);
2622 VM_THROW_EXCEPTION_AT_END();
2623 return JSValue::encode(JSValue());
2624 }
2625
2626 DEFINE_STUB_FUNCTION(JSObject*, op_new_func_exp)
2627 {
2628 STUB_INIT_STACK_FRAME(stackFrame);
2629 CallFrame* callFrame = stackFrame.callFrame;
2630
2631 FunctionExecutable* function = stackFrame.args[0].function();
2632 JSFunction* func = function->make(callFrame, callFrame->scopeChain());
2633
2634 /*
2635 The Identifier in a FunctionExpression can be referenced from inside
2636 the FunctionExpression's FunctionBody to allow the function to call
2637 itself recursively. However, unlike in a FunctionDeclaration, the
2638 Identifier in a FunctionExpression cannot be referenced from and
2639 does not affect the scope enclosing the FunctionExpression.
2640 */
2641 if (!function->name().isNull()) {
2642 JSStaticScopeObject* functionScopeObject = new (callFrame) JSStaticScopeObject(callFrame, function->name(), func, ReadOnly | DontDelete);
2643 func->scope().push(functionScopeObject);
2644 }
2645
2646 return func;
2647 }
2648
2649 DEFINE_STUB_FUNCTION(EncodedJSValue, op_mod)
2650 {
2651 STUB_INIT_STACK_FRAME(stackFrame);
2652
2653 JSValue dividendValue = stackFrame.args[0].jsValue();
2654 JSValue divisorValue = stackFrame.args[1].jsValue();
2655
2656 CallFrame* callFrame = stackFrame.callFrame;
2657 double d = dividendValue.toNumber(callFrame);
2658 JSValue result = jsNumber(stackFrame.globalData, fmod(d, divisorValue.toNumber(callFrame)));
2659 CHECK_FOR_EXCEPTION_AT_END();
2660 return JSValue::encode(result);
2661 }
2662
2663 DEFINE_STUB_FUNCTION(EncodedJSValue, op_less)
2664 {
2665 STUB_INIT_STACK_FRAME(stackFrame);
2666
2667 CallFrame* callFrame = stackFrame.callFrame;
2668 JSValue result = jsBoolean(jsLess(callFrame, stackFrame.args[0].jsValue(), stackFrame.args[1].jsValue()));
2669 CHECK_FOR_EXCEPTION_AT_END();
2670 return JSValue::encode(result);
2671 }
2672
2673 DEFINE_STUB_FUNCTION(EncodedJSValue, op_post_dec)
2674 {
2675 STUB_INIT_STACK_FRAME(stackFrame);
2676
2677 JSValue v = stackFrame.args[0].jsValue();
2678
2679 CallFrame* callFrame = stackFrame.callFrame;
2680
2681 JSValue number = v.toJSNumber(callFrame);
2682 CHECK_FOR_EXCEPTION_AT_END();
2683
2684 callFrame->registers()[stackFrame.args[1].int32()] = jsNumber(stackFrame.globalData, number.uncheckedGetNumber() - 1);
2685 return JSValue::encode(number);
2686 }
2687
2688 DEFINE_STUB_FUNCTION(EncodedJSValue, op_urshift)
2689 {
2690 STUB_INIT_STACK_FRAME(stackFrame);
2691
2692 JSValue val = stackFrame.args[0].jsValue();
2693 JSValue shift = stackFrame.args[1].jsValue();
2694
2695 CallFrame* callFrame = stackFrame.callFrame;
2696 JSValue result = jsNumber(stackFrame.globalData, (val.toUInt32(callFrame)) >> (shift.toUInt32(callFrame) & 0x1f));
2697 CHECK_FOR_EXCEPTION_AT_END();
2698 return JSValue::encode(result);
2699 }
2700
2701 DEFINE_STUB_FUNCTION(EncodedJSValue, op_bitxor)
2702 {
2703 STUB_INIT_STACK_FRAME(stackFrame);
2704
2705 JSValue src1 = stackFrame.args[0].jsValue();
2706 JSValue src2 = stackFrame.args[1].jsValue();
2707
2708 CallFrame* callFrame = stackFrame.callFrame;
2709
2710 JSValue result = jsNumber(stackFrame.globalData, src1.toInt32(callFrame) ^ src2.toInt32(callFrame));
2711 CHECK_FOR_EXCEPTION_AT_END();
2712 return JSValue::encode(result);
2713 }
2714
2715 DEFINE_STUB_FUNCTION(JSObject*, op_new_regexp)
2716 {
2717 STUB_INIT_STACK_FRAME(stackFrame);
2718
2719 return new (stackFrame.globalData) RegExpObject(stackFrame.callFrame->lexicalGlobalObject()->regExpStructure(), stackFrame.args[0].regExp());
2720 }
2721
2722 DEFINE_STUB_FUNCTION(EncodedJSValue, op_bitor)
2723 {
2724 STUB_INIT_STACK_FRAME(stackFrame);
2725
2726 JSValue src1 = stackFrame.args[0].jsValue();
2727 JSValue src2 = stackFrame.args[1].jsValue();
2728
2729 CallFrame* callFrame = stackFrame.callFrame;
2730
2731 JSValue result = jsNumber(stackFrame.globalData, src1.toInt32(callFrame) | src2.toInt32(callFrame));
2732 CHECK_FOR_EXCEPTION_AT_END();
2733 return JSValue::encode(result);
2734 }
2735
2736 DEFINE_STUB_FUNCTION(EncodedJSValue, op_call_eval)
2737 {
2738 STUB_INIT_STACK_FRAME(stackFrame);
2739
2740 CallFrame* callFrame = stackFrame.callFrame;
2741 RegisterFile* registerFile = stackFrame.registerFile;
2742
2743 Interpreter* interpreter = stackFrame.globalData->interpreter;
2744
2745 JSValue funcVal = stackFrame.args[0].jsValue();
2746 int registerOffset = stackFrame.args[1].int32();
2747 int argCount = stackFrame.args[2].int32();
2748
2749 Register* newCallFrame = callFrame->registers() + registerOffset;
2750 Register* argv = newCallFrame - RegisterFile::CallFrameHeaderSize - argCount;
2751 JSValue thisValue = argv[0].jsValue();
2752 JSGlobalObject* globalObject = callFrame->scopeChain()->globalObject;
2753
2754 if (thisValue == globalObject && funcVal == globalObject->evalFunction()) {
2755 JSValue exceptionValue;
2756 JSValue result = interpreter->callEval(callFrame, registerFile, argv, argCount, registerOffset, exceptionValue);
2757 if (UNLIKELY(exceptionValue)) {
2758 stackFrame.globalData->exception = exceptionValue;
2759 VM_THROW_EXCEPTION_AT_END();
2760 }
2761 return JSValue::encode(result);
2762 }
2763
2764 return JSValue::encode(JSValue());
2765 }
2766
2767 DEFINE_STUB_FUNCTION(EncodedJSValue, op_throw)
2768 {
2769 STUB_INIT_STACK_FRAME(stackFrame);
2770
2771 CallFrame* callFrame = stackFrame.callFrame;
2772 CodeBlock* codeBlock = callFrame->codeBlock();
2773
2774 unsigned vPCIndex = codeBlock->getBytecodeIndex(callFrame, STUB_RETURN_ADDRESS);
2775
2776 JSValue exceptionValue = stackFrame.args[0].jsValue();
2777 ASSERT(exceptionValue);
2778
2779 HandlerInfo* handler = stackFrame.globalData->interpreter->throwException(callFrame, exceptionValue, vPCIndex, true);
2780
2781 if (!handler) {
2782 *stackFrame.exception = exceptionValue;
2783 STUB_SET_RETURN_ADDRESS(FunctionPtr(ctiOpThrowNotCaught).value());
2784 return JSValue::encode(jsNull());
2785 }
2786
2787 stackFrame.callFrame = callFrame;
2788 void* catchRoutine = handler->nativeCode.executableAddress();
2789 ASSERT(catchRoutine);
2790 STUB_SET_RETURN_ADDRESS(catchRoutine);
2791 return JSValue::encode(exceptionValue);
2792 }
2793
2794 DEFINE_STUB_FUNCTION(JSPropertyNameIterator*, op_get_pnames)
2795 {
2796 STUB_INIT_STACK_FRAME(stackFrame);
2797
2798 CallFrame* callFrame = stackFrame.callFrame;
2799 JSObject* o = stackFrame.args[0].jsObject();
2800 Structure* structure = o->structure();
2801 JSPropertyNameIterator* jsPropertyNameIterator = structure->enumerationCache();
2802 if (!jsPropertyNameIterator || jsPropertyNameIterator->cachedPrototypeChain() != structure->prototypeChain(callFrame))
2803 jsPropertyNameIterator = JSPropertyNameIterator::create(callFrame, o);
2804 return jsPropertyNameIterator;
2805 }
2806
2807 DEFINE_STUB_FUNCTION(int, has_property)
2808 {
2809 STUB_INIT_STACK_FRAME(stackFrame);
2810
2811 JSObject* base = stackFrame.args[0].jsObject();
2812 JSString* property = stackFrame.args[1].jsString();
2813 return base->hasProperty(stackFrame.callFrame, Identifier(stackFrame.callFrame, property->value(stackFrame.callFrame)));
2814 }
2815
2816 DEFINE_STUB_FUNCTION(JSObject*, op_push_scope)
2817 {
2818 STUB_INIT_STACK_FRAME(stackFrame);
2819
2820 JSObject* o = stackFrame.args[0].jsValue().toObject(stackFrame.callFrame);
2821 CHECK_FOR_EXCEPTION();
2822 stackFrame.callFrame->setScopeChain(stackFrame.callFrame->scopeChain()->push(o));
2823 return o;
2824 }
2825
2826 DEFINE_STUB_FUNCTION(void, op_pop_scope)
2827 {
2828 STUB_INIT_STACK_FRAME(stackFrame);
2829
2830 stackFrame.callFrame->setScopeChain(stackFrame.callFrame->scopeChain()->pop());
2831 }
2832
2833 DEFINE_STUB_FUNCTION(EncodedJSValue, op_typeof)
2834 {
2835 STUB_INIT_STACK_FRAME(stackFrame);
2836
2837 return JSValue::encode(jsTypeStringForValue(stackFrame.callFrame, stackFrame.args[0].jsValue()));
2838 }
2839
2840 DEFINE_STUB_FUNCTION(EncodedJSValue, op_is_undefined)
2841 {
2842 STUB_INIT_STACK_FRAME(stackFrame);
2843
2844 JSValue v = stackFrame.args[0].jsValue();
2845 return JSValue::encode(jsBoolean(v.isCell() ? v.asCell()->structure()->typeInfo().masqueradesAsUndefined() : v.isUndefined()));
2846 }
2847
2848 DEFINE_STUB_FUNCTION(EncodedJSValue, op_is_boolean)
2849 {
2850 STUB_INIT_STACK_FRAME(stackFrame);
2851
2852 return JSValue::encode(jsBoolean(stackFrame.args[0].jsValue().isBoolean()));
2853 }
2854
2855 DEFINE_STUB_FUNCTION(EncodedJSValue, op_is_number)
2856 {
2857 STUB_INIT_STACK_FRAME(stackFrame);
2858
2859 return JSValue::encode(jsBoolean(stackFrame.args[0].jsValue().isNumber()));
2860 }
2861
2862 DEFINE_STUB_FUNCTION(EncodedJSValue, op_is_string)
2863 {
2864 STUB_INIT_STACK_FRAME(stackFrame);
2865
2866 return JSValue::encode(jsBoolean(isJSString(stackFrame.globalData, stackFrame.args[0].jsValue())));
2867 }
2868
2869 DEFINE_STUB_FUNCTION(EncodedJSValue, op_is_object)
2870 {
2871 STUB_INIT_STACK_FRAME(stackFrame);
2872
2873 return JSValue::encode(jsBoolean(jsIsObjectType(stackFrame.args[0].jsValue())));
2874 }
2875
2876 DEFINE_STUB_FUNCTION(EncodedJSValue, op_is_function)
2877 {
2878 STUB_INIT_STACK_FRAME(stackFrame);
2879
2880 return JSValue::encode(jsBoolean(jsIsFunctionType(stackFrame.args[0].jsValue())));
2881 }
2882
2883 DEFINE_STUB_FUNCTION(EncodedJSValue, op_stricteq)
2884 {
2885 STUB_INIT_STACK_FRAME(stackFrame);
2886
2887 JSValue src1 = stackFrame.args[0].jsValue();
2888 JSValue src2 = stackFrame.args[1].jsValue();
2889
2890 return JSValue::encode(jsBoolean(JSValue::strictEqual(stackFrame.callFrame, src1, src2)));
2891 }
2892
2893 DEFINE_STUB_FUNCTION(EncodedJSValue, op_to_primitive)
2894 {
2895 STUB_INIT_STACK_FRAME(stackFrame);
2896
2897 return JSValue::encode(stackFrame.args[0].jsValue().toPrimitive(stackFrame.callFrame));
2898 }
2899
2900 DEFINE_STUB_FUNCTION(EncodedJSValue, op_strcat)
2901 {
2902 STUB_INIT_STACK_FRAME(stackFrame);
2903
2904 JSValue result = jsString(stackFrame.callFrame, &stackFrame.callFrame->registers()[stackFrame.args[0].int32()], stackFrame.args[1].int32());
2905 CHECK_FOR_EXCEPTION_AT_END();
2906 return JSValue::encode(result);
2907 }
2908
2909 DEFINE_STUB_FUNCTION(EncodedJSValue, op_nstricteq)
2910 {
2911 STUB_INIT_STACK_FRAME(stackFrame);
2912
2913 JSValue src1 = stackFrame.args[0].jsValue();
2914 JSValue src2 = stackFrame.args[1].jsValue();
2915
2916 return JSValue::encode(jsBoolean(!JSValue::strictEqual(stackFrame.callFrame, src1, src2)));
2917 }
2918
2919 DEFINE_STUB_FUNCTION(EncodedJSValue, op_to_jsnumber)
2920 {
2921 STUB_INIT_STACK_FRAME(stackFrame);
2922
2923 JSValue src = stackFrame.args[0].jsValue();
2924 CallFrame* callFrame = stackFrame.callFrame;
2925
2926 JSValue result = src.toJSNumber(callFrame);
2927 CHECK_FOR_EXCEPTION_AT_END();
2928 return JSValue::encode(result);
2929 }
2930
2931 DEFINE_STUB_FUNCTION(EncodedJSValue, op_in)
2932 {
2933 STUB_INIT_STACK_FRAME(stackFrame);
2934
2935 CallFrame* callFrame = stackFrame.callFrame;
2936 JSValue baseVal = stackFrame.args[1].jsValue();
2937
2938 if (!baseVal.isObject()) {
2939 CallFrame* callFrame = stackFrame.callFrame;
2940 CodeBlock* codeBlock = callFrame->codeBlock();
2941 unsigned vPCIndex = codeBlock->getBytecodeIndex(callFrame, STUB_RETURN_ADDRESS);
2942 stackFrame.globalData->exception = createInvalidParamError(callFrame, "in", baseVal, vPCIndex, codeBlock);
2943 VM_THROW_EXCEPTION();
2944 }
2945
2946 JSValue propName = stackFrame.args[0].jsValue();
2947 JSObject* baseObj = asObject(baseVal);
2948
2949 uint32_t i;
2950 if (propName.getUInt32(i))
2951 return JSValue::encode(jsBoolean(baseObj->hasProperty(callFrame, i)));
2952
2953 Identifier property(callFrame, propName.toString(callFrame));
2954 CHECK_FOR_EXCEPTION();
2955 return JSValue::encode(jsBoolean(baseObj->hasProperty(callFrame, property)));
2956 }
2957
2958 DEFINE_STUB_FUNCTION(JSObject*, op_push_new_scope)
2959 {
2960 STUB_INIT_STACK_FRAME(stackFrame);
2961
2962 JSObject* scope = new (stackFrame.globalData) JSStaticScopeObject(stackFrame.callFrame, stackFrame.args[0].identifier(), stackFrame.args[1].jsValue(), DontDelete);
2963
2964 CallFrame* callFrame = stackFrame.callFrame;
2965 callFrame->setScopeChain(callFrame->scopeChain()->push(scope));
2966 return scope;
2967 }
2968
2969 DEFINE_STUB_FUNCTION(void, op_jmp_scopes)
2970 {
2971 STUB_INIT_STACK_FRAME(stackFrame);
2972
2973 unsigned count = stackFrame.args[0].int32();
2974 CallFrame* callFrame = stackFrame.callFrame;
2975
2976 ScopeChainNode* tmp = callFrame->scopeChain();
2977 while (count--)
2978 tmp = tmp->pop();
2979 callFrame->setScopeChain(tmp);
2980 }
2981
2982 DEFINE_STUB_FUNCTION(void, op_put_by_index)
2983 {
2984 STUB_INIT_STACK_FRAME(stackFrame);
2985
2986 CallFrame* callFrame = stackFrame.callFrame;
2987 unsigned property = stackFrame.args[1].int32();
2988
2989 stackFrame.args[0].jsValue().put(callFrame, property, stackFrame.args[2].jsValue());
2990 }
2991
2992 DEFINE_STUB_FUNCTION(void*, op_switch_imm)
2993 {
2994 STUB_INIT_STACK_FRAME(stackFrame);
2995
2996 JSValue scrutinee = stackFrame.args[0].jsValue();
2997 unsigned tableIndex = stackFrame.args[1].int32();
2998 CallFrame* callFrame = stackFrame.callFrame;
2999 CodeBlock* codeBlock = callFrame->codeBlock();
3000
3001 if (scrutinee.isInt32())
3002 return codeBlock->immediateSwitchJumpTable(tableIndex).ctiForValue(scrutinee.asInt32()).executableAddress();
3003 else {
3004 double value;
3005 int32_t intValue;
3006 if (scrutinee.getNumber(value) && ((intValue = static_cast<int32_t>(value)) == value))
3007 return codeBlock->immediateSwitchJumpTable(tableIndex).ctiForValue(intValue).executableAddress();
3008 else
3009 return codeBlock->immediateSwitchJumpTable(tableIndex).ctiDefault.executableAddress();
3010 }
3011 }
3012
3013 DEFINE_STUB_FUNCTION(void*, op_switch_char)
3014 {
3015 STUB_INIT_STACK_FRAME(stackFrame);
3016
3017 JSValue scrutinee = stackFrame.args[0].jsValue();
3018 unsigned tableIndex = stackFrame.args[1].int32();
3019 CallFrame* callFrame = stackFrame.callFrame;
3020 CodeBlock* codeBlock = callFrame->codeBlock();
3021
3022 void* result = codeBlock->characterSwitchJumpTable(tableIndex).ctiDefault.executableAddress();
3023
3024 if (scrutinee.isString()) {
3025 UString::Rep* value = asString(scrutinee)->value(callFrame).rep();
3026 if (value->size() == 1)
3027 result = codeBlock->characterSwitchJumpTable(tableIndex).ctiForValue(value->data()[0]).executableAddress();
3028 }
3029
3030 return result;
3031 }
3032
3033 DEFINE_STUB_FUNCTION(void*, op_switch_string)
3034 {
3035 STUB_INIT_STACK_FRAME(stackFrame);
3036
3037 JSValue scrutinee = stackFrame.args[0].jsValue();
3038 unsigned tableIndex = stackFrame.args[1].int32();
3039 CallFrame* callFrame = stackFrame.callFrame;
3040 CodeBlock* codeBlock = callFrame->codeBlock();
3041
3042 void* result = codeBlock->stringSwitchJumpTable(tableIndex).ctiDefault.executableAddress();
3043
3044 if (scrutinee.isString()) {
3045 UString::Rep* value = asString(scrutinee)->value(callFrame).rep();
3046 result = codeBlock->stringSwitchJumpTable(tableIndex).ctiForValue(value).executableAddress();
3047 }
3048
3049 return result;
3050 }
3051
3052 DEFINE_STUB_FUNCTION(EncodedJSValue, op_del_by_val)
3053 {
3054 STUB_INIT_STACK_FRAME(stackFrame);
3055
3056 CallFrame* callFrame = stackFrame.callFrame;
3057
3058 JSValue baseValue = stackFrame.args[0].jsValue();
3059 JSObject* baseObj = baseValue.toObject(callFrame); // may throw
3060
3061 JSValue subscript = stackFrame.args[1].jsValue();
3062 JSValue result;
3063 uint32_t i;
3064 if (subscript.getUInt32(i))
3065 result = jsBoolean(baseObj->deleteProperty(callFrame, i));
3066 else {
3067 CHECK_FOR_EXCEPTION();
3068 Identifier property(callFrame, subscript.toString(callFrame));
3069 CHECK_FOR_EXCEPTION();
3070 result = jsBoolean(baseObj->deleteProperty(callFrame, property));
3071 }
3072
3073 CHECK_FOR_EXCEPTION_AT_END();
3074 return JSValue::encode(result);
3075 }
3076
3077 DEFINE_STUB_FUNCTION(void, op_put_getter)
3078 {
3079 STUB_INIT_STACK_FRAME(stackFrame);
3080
3081 CallFrame* callFrame = stackFrame.callFrame;
3082
3083 ASSERT(stackFrame.args[0].jsValue().isObject());
3084 JSObject* baseObj = asObject(stackFrame.args[0].jsValue());
3085 ASSERT(stackFrame.args[2].jsValue().isObject());
3086 baseObj->defineGetter(callFrame, stackFrame.args[1].identifier(), asObject(stackFrame.args[2].jsValue()));
3087 }
3088
3089 DEFINE_STUB_FUNCTION(void, op_put_setter)
3090 {
3091 STUB_INIT_STACK_FRAME(stackFrame);
3092
3093 CallFrame* callFrame = stackFrame.callFrame;
3094
3095 ASSERT(stackFrame.args[0].jsValue().isObject());
3096 JSObject* baseObj = asObject(stackFrame.args[0].jsValue());
3097 ASSERT(stackFrame.args[2].jsValue().isObject());
3098 baseObj->defineSetter(callFrame, stackFrame.args[1].identifier(), asObject(stackFrame.args[2].jsValue()));
3099 }
3100
3101 DEFINE_STUB_FUNCTION(JSObject*, op_new_error)
3102 {
3103 STUB_INIT_STACK_FRAME(stackFrame);
3104
3105 CallFrame* callFrame = stackFrame.callFrame;
3106 CodeBlock* codeBlock = callFrame->codeBlock();
3107 unsigned type = stackFrame.args[0].int32();
3108 JSValue message = stackFrame.args[1].jsValue();
3109 unsigned bytecodeOffset = stackFrame.args[2].int32();
3110
3111 unsigned lineNumber = codeBlock->lineNumberForBytecodeOffset(callFrame, bytecodeOffset);
3112 return Error::create(callFrame, static_cast<ErrorType>(type), message.toString(callFrame), lineNumber, codeBlock->ownerExecutable()->sourceID(), codeBlock->ownerExecutable()->sourceURL());
3113 }
3114
3115 DEFINE_STUB_FUNCTION(void, op_debug)
3116 {
3117 STUB_INIT_STACK_FRAME(stackFrame);
3118
3119 CallFrame* callFrame = stackFrame.callFrame;
3120
3121 int debugHookID = stackFrame.args[0].int32();
3122 int firstLine = stackFrame.args[1].int32();
3123 int lastLine = stackFrame.args[2].int32();
3124
3125 stackFrame.globalData->interpreter->debug(callFrame, static_cast<DebugHookID>(debugHookID), firstLine, lastLine);
3126 }
3127
3128 DEFINE_STUB_FUNCTION(EncodedJSValue, vm_throw)
3129 {
3130 STUB_INIT_STACK_FRAME(stackFrame);
3131
3132 CallFrame* callFrame = stackFrame.callFrame;
3133 CodeBlock* codeBlock = callFrame->codeBlock();
3134 JSGlobalData* globalData = stackFrame.globalData;
3135
3136 unsigned vPCIndex = codeBlock->getBytecodeIndex(callFrame, globalData->exceptionLocation);
3137
3138 JSValue exceptionValue = globalData->exception;
3139 ASSERT(exceptionValue);
3140 globalData->exception = JSValue();
3141
3142 HandlerInfo* handler = globalData->interpreter->throwException(callFrame, exceptionValue, vPCIndex, false);
3143
3144 if (!handler) {
3145 *stackFrame.exception = exceptionValue;
3146 return JSValue::encode(jsNull());
3147 }
3148
3149 stackFrame.callFrame = callFrame;
3150 void* catchRoutine = handler->nativeCode.executableAddress();
3151 ASSERT(catchRoutine);
3152 STUB_SET_RETURN_ADDRESS(catchRoutine);
3153 return JSValue::encode(exceptionValue);
3154 }
3155
3156 DEFINE_STUB_FUNCTION(EncodedJSValue, to_object)
3157 {
3158 STUB_INIT_STACK_FRAME(stackFrame);
3159
3160 CallFrame* callFrame = stackFrame.callFrame;
3161 return JSValue::encode(stackFrame.args[0].jsValue().toObject(callFrame));
3162 }
3163
3164 } // namespace JSC
3165
3166 #endif // ENABLE(JIT)
mirror of JavaScriptCore