Bug 20821: Cache property transitions to speed up object initialization
[WebKit-https.git] / JavaScriptCore / VM / CodeBlock.cpp
1 /*
2  * Copyright (C) 2008 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 "CodeBlock.h"
32
33 #include "JSValue.h"
34 #include "Machine.h"
35 #include "debugger.h"
36 #include <stdio.h>
37 #include <wtf/StringExtras.h>
38
39 namespace JSC {
40
41 #if !defined(NDEBUG) || ENABLE(SAMPLING_TOOL)
42
43 static UString escapeQuotes(const UString& str)
44 {
45     UString result = str;
46     int pos = 0;
47     while ((pos = result.find('\"', pos)) >= 0) {
48         result = result.substr(0, pos) + "\"\\\"\"" + result.substr(pos + 1);
49         pos += 4;
50     }
51     return result;
52 }
53
54 static UString valueToSourceString(ExecState* exec, JSValue* val)
55 {
56     if (val->isString()) {
57         UString result("\"");
58         result += escapeQuotes(val->toString(exec)) + "\"";
59         return result;
60     } 
61
62     return val->toString(exec);
63 }
64
65 static CString registerName(int r)
66 {
67     if (r < 0)
68         return (UString("lr") + UString::from(-r)).UTF8String(); 
69         
70     if (r == missingThisObjectMarker())
71         return "<null>";
72
73     return (UString("tr") + UString::from(r)).UTF8String();
74 }
75
76 static CString constantName(ExecState* exec, int k, JSValue* value)
77 {
78     return (valueToSourceString(exec, value) + "(@k" + UString::from(k) + ")").UTF8String();
79 }
80
81 static CString idName(int id0, const Identifier& ident)
82 {
83     return (ident.ustring() + "(@id" + UString::from(id0) +")").UTF8String();
84 }
85
86 static UString regexpToSourceString(RegExp* regExp)
87 {
88     UString pattern = UString("/") + regExp->pattern() + "/";
89     if (regExp->global())
90         pattern += "g";
91     if (regExp->ignoreCase())
92         pattern += "i";
93     if (regExp->multiline())
94         pattern += "m";
95
96     return pattern;
97 }
98
99 static CString regexpName(int re, RegExp* regexp)
100 {
101     return (regexpToSourceString(regexp) + "(@re" + UString::from(re) + ")").UTF8String();
102 }
103
104 static UString pointerToSourceString(void* p)
105 {
106     char buffer[2 + 2 * sizeof(void*) + 1]; // 0x [two characters per byte] \0
107     snprintf(buffer, sizeof(buffer), "%p", p);
108     return buffer;
109 }
110
111 NEVER_INLINE static const char* debugHookName(int debugHookID)
112 {
113     switch (static_cast<DebugHookID>(debugHookID)) {
114         case DidEnterCallFrame:
115             return "didEnterCallFrame";
116         case WillLeaveCallFrame:
117             return "willLeaveCallFrame";
118         case WillExecuteStatement:
119             return "willExecuteStatement";
120         case WillExecuteProgram:
121             return "willExecuteProgram";
122         case DidExecuteProgram:
123             return "didExecuteProgram";
124         case DidReachBreakpoint:
125             return "didReachBreakpoint";
126     }
127
128     ASSERT_NOT_REACHED();
129     return "";
130 }
131
132 static int jumpTarget(const Vector<Instruction>::const_iterator& begin, Vector<Instruction>::const_iterator& it, int offset)
133 {
134     return it - begin + offset;
135 }
136
137 static void printUnaryOp(int location, Vector<Instruction>::const_iterator& it, const char* op)
138 {
139     int r0 = (++it)->u.operand;
140     int r1 = (++it)->u.operand;
141
142     printf("[%4d] %s\t\t %s, %s\n", location, op, registerName(r0).c_str(), registerName(r1).c_str());
143 }
144
145 static void printBinaryOp(int location, Vector<Instruction>::const_iterator& it, const char* op)
146 {
147     int r0 = (++it)->u.operand;
148     int r1 = (++it)->u.operand;
149     int r2 = (++it)->u.operand;
150     printf("[%4d] %s\t\t %s, %s, %s\n", location, op, registerName(r0).c_str(), registerName(r1).c_str(), registerName(r2).c_str());
151 }
152
153 static void printConditionalJump(const Vector<Instruction>::const_iterator& begin, Vector<Instruction>::const_iterator& it, int location, const char* op)
154 {
155     int r0 = (++it)->u.operand;
156     int offset = (++it)->u.operand;
157     printf("[%4d] %s\t\t %s, %d(->%d)\n", location, op, registerName(r0).c_str(), offset, jumpTarget(begin, it, offset));
158 }
159
160 static void printGetByIdOp(int location, Vector<Instruction>::const_iterator& it, const Vector<Identifier>& identifiers, const char* op)
161 {
162     int r0 = (++it)->u.operand;
163     int r1 = (++it)->u.operand;
164     int id0 = (++it)->u.operand;
165     printf("[%4d] %s\t %s, %s, %s\n", location, op, registerName(r0).c_str(), registerName(r1).c_str(), idName(id0, identifiers[id0]).c_str());
166     it += 4;
167 }
168
169 static void printPutByIdOp(int location, Vector<Instruction>::const_iterator& it, const Vector<Identifier>& identifiers, const char* op)
170 {
171     int r0 = (++it)->u.operand;
172     int id0 = (++it)->u.operand;
173     int r1 = (++it)->u.operand;
174     printf("[%4d] %s\t %s, %s, %s\n", location, op, registerName(r0).c_str(), idName(id0, identifiers[id0]).c_str(), registerName(r1).c_str());
175     it += 4;
176 }
177
178 void CodeBlock::printStructureID(const char* name, const Instruction* vPC, int operand) const
179 {
180     unsigned instructionOffset = vPC - instructions.begin();
181     printf("  [%4d] %s: %s\n", instructionOffset, name, pointerToSourceString(vPC[operand].u.structureID).UTF8String().c_str());
182 }
183
184 void CodeBlock::printStructureIDs(const Instruction* vPC) const
185 {
186     Machine* machine = globalData->machine;
187     unsigned instructionOffset = vPC - instructions.begin();
188
189     if (vPC[0].u.opcode == machine->getOpcode(op_get_by_id)) {
190         printStructureID("get_by_id", vPC, 4);
191         return;
192     }
193     if (vPC[0].u.opcode == machine->getOpcode(op_get_by_id_self)) {
194         printStructureID("get_by_id_self", vPC, 4);
195         return;
196     }
197     if (vPC[0].u.opcode == machine->getOpcode(op_get_by_id_proto)) {
198         printf("  [%4d] %s: %s, %s\n", instructionOffset, "get_by_id_proto", pointerToSourceString(vPC[4].u.structureID).UTF8String().c_str(), pointerToSourceString(vPC[5].u.structureID).UTF8String().c_str());
199         return;
200     }
201     if (vPC[0].u.opcode == machine->getOpcode(op_put_by_id_transition)) {
202         printf("  [%4d] %s: %s, %s, %s\n", instructionOffset, "put_by_id_new", pointerToSourceString(vPC[4].u.structureID).UTF8String().c_str(), pointerToSourceString(vPC[5].u.structureID).UTF8String().c_str(), pointerToSourceString(vPC[6].u.structureIDChain).UTF8String().c_str());
203         return;
204     }
205     if (vPC[0].u.opcode == machine->getOpcode(op_get_by_id_chain)) {
206         printf("  [%4d] %s: %s, %s\n", instructionOffset, "get_by_id_chain", pointerToSourceString(vPC[4].u.structureID).UTF8String().c_str(), pointerToSourceString(vPC[5].u.structureIDChain).UTF8String().c_str());
207         return;
208     }
209     if (vPC[0].u.opcode == machine->getOpcode(op_put_by_id)) {
210         printStructureID("put_by_id", vPC, 4);
211         return;
212     }
213     if (vPC[0].u.opcode == machine->getOpcode(op_put_by_id_replace)) {
214         printStructureID("put_by_id_replace", vPC, 4);
215         return;
216     }
217
218     // These instructions doesn't ref StructureIDs.
219     ASSERT(vPC[0].u.opcode == machine->getOpcode(op_get_by_id_generic) || vPC[0].u.opcode == machine->getOpcode(op_put_by_id_generic));
220 }
221
222 void CodeBlock::dump(ExecState* exec) const
223 {
224     Vector<Instruction>::const_iterator begin = instructions.begin();
225     Vector<Instruction>::const_iterator end = instructions.end();
226
227     size_t instructionCount = 0;
228     for (Vector<Instruction>::const_iterator it = begin; it != end; ++it)
229         if (exec->machine()->isOpcode(it->u.opcode))
230             ++instructionCount;
231
232     printf("%lu instructions; %lu bytes at %p; %d locals (%d parameters); %d temporaries\n\n",
233         static_cast<unsigned long>(instructionCount),
234         static_cast<unsigned long>(instructions.size() * sizeof(Instruction)),
235         this, numLocals, numParameters, numTemporaries);
236     
237     for (Vector<Instruction>::const_iterator it = begin; it != end; ++it)
238         dump(exec, begin, it);
239
240     if (identifiers.size()) {
241         printf("\nIdentifiers:\n");
242         size_t i = 0;
243         do {
244             printf("  id%u = %s\n", static_cast<unsigned>(i), identifiers[i].ascii());
245             ++i;
246         } while (i != identifiers.size());
247     }
248
249     if (constantRegisters.size()) {
250         printf("\nConstants:\n");
251         size_t i = 0;
252         do {
253             printf("  tr%u = %s\n", static_cast<unsigned>(i), valueToSourceString(exec, constantRegisters[i].jsValue(exec)).ascii());
254             ++i;
255         } while (i < constantRegisters.size());
256     }
257
258     if (unexpectedConstants.size()) {
259         printf("\nUnexpected Constants:\n");
260         size_t i = 0;
261         do {
262             printf("  k%u = %s\n", static_cast<unsigned>(i), valueToSourceString(exec, unexpectedConstants[i]).ascii());
263             ++i;
264         } while (i < unexpectedConstants.size());
265     }
266     
267     if (regexps.size()) {
268         printf("\nRegExps:\n");
269         size_t i = 0;
270         do {
271             printf("  re%u = %s\n", static_cast<unsigned>(i), regexpToSourceString(regexps[i].get()).ascii());
272             ++i;
273         } while (i < regexps.size());
274     }
275
276     if (structureIDInstructions.size()) {
277         printf("\nStructureIDs:\n");
278         size_t i = 0;
279         do {
280              printStructureIDs(&instructions[structureIDInstructions[i]]);
281              ++i;
282         } while (i < structureIDInstructions.size());
283     }
284  
285     if (exceptionHandlers.size()) {
286         printf("\nException Handlers:\n");
287         unsigned i = 0;
288         do {
289             printf("\t %d: { start: [%4d] end: [%4d] target: [%4d] }\n", i + 1, exceptionHandlers[i].start, exceptionHandlers[i].end, exceptionHandlers[i].target);
290             ++i;
291         } while (i < exceptionHandlers.size());
292     }
293     
294     if (immediateSwitchJumpTables.size()) {
295         printf("Immediate Switch Jump Tables:\n");
296         unsigned i = 0;
297         do {
298             printf("  %1d = {\n", i);
299             int entry = 0;
300             Vector<int32_t>::const_iterator end = immediateSwitchJumpTables[i].branchOffsets.end();
301             for (Vector<int32_t>::const_iterator iter = immediateSwitchJumpTables[i].branchOffsets.begin(); iter != end; ++iter, ++entry) {
302                 if (!*iter)
303                     continue;
304                 printf("\t\t%4d => %04d\n", entry + immediateSwitchJumpTables[i].min, *iter);
305             }
306             printf("      }\n");
307             ++i;
308         } while (i < immediateSwitchJumpTables.size());
309     }
310     
311     if (characterSwitchJumpTables.size()) {
312         printf("\nCharacter Switch Jump Tables:\n");
313         unsigned i = 0;
314         do {
315             printf("  %1d = {\n", i);
316             int entry = 0;
317             Vector<int32_t>::const_iterator end = characterSwitchJumpTables[i].branchOffsets.end();
318             for (Vector<int32_t>::const_iterator iter = characterSwitchJumpTables[i].branchOffsets.begin(); iter != end; ++iter, ++entry) {
319                 if (!*iter)
320                     continue;
321                 ASSERT(!((i + characterSwitchJumpTables[i].min) & ~0xFFFF));
322                 UChar ch = static_cast<UChar>(entry + characterSwitchJumpTables[i].min);
323                 printf("\t\t\"%s\" => %04d\n", UString(&ch, 1).ascii(), *iter);
324         }
325             printf("      }\n");
326             ++i;
327         } while (i < characterSwitchJumpTables.size());
328     }
329     
330     if (stringSwitchJumpTables.size()) {
331         printf("\nString Switch Jump Tables:\n");
332         unsigned i = 0;
333         do {
334             printf("  %1d = {\n", i);
335             StringJumpTable::StringOffsetTable::const_iterator end = stringSwitchJumpTables[i].offsetTable.end();
336             for (StringJumpTable::StringOffsetTable::const_iterator iter = stringSwitchJumpTables[i].offsetTable.begin(); iter != end; ++iter)
337                 printf("\t\t\"%s\" => %04d\n", UString(iter->first).ascii(), iter->second.branchOffset);
338             printf("      }\n");
339             ++i;
340         } while (i < stringSwitchJumpTables.size());
341     }
342
343     printf("\n");
344 }
345
346 void CodeBlock::dump(ExecState* exec, const Vector<Instruction>::const_iterator& begin, Vector<Instruction>::const_iterator& it) const
347 {
348     int location = it - begin;
349     switch (exec->machine()->getOpcodeID(it->u.opcode)) {
350         case op_unexpected_load: {
351             int r0 = (++it)->u.operand;
352             int k0 = (++it)->u.operand;
353             printf("[%4d] unexpected_load\t %s, %s\n", location, registerName(r0).c_str(), constantName(exec, k0, unexpectedConstants[k0]).c_str());
354             break;
355         }
356         case op_new_object: {
357             int r0 = (++it)->u.operand;
358             printf("[%4d] new_object\t %s\n", location, registerName(r0).c_str());
359             break;
360         }
361         case op_new_array: {
362             int dst = (++it)->u.operand;
363             int argv = (++it)->u.operand;
364             int argc = (++it)->u.operand;
365             printf("[%4d] new_array\t %s, %s, %d\n", location, registerName(dst).c_str(), registerName(argv).c_str(), argc);
366             break;
367         }
368         case op_new_regexp: {
369             int r0 = (++it)->u.operand;
370             int re0 = (++it)->u.operand;
371             printf("[%4d] new_regexp\t %s, %s\n", location, registerName(r0).c_str(), regexpName(re0, regexps[re0].get()).c_str());
372             break;
373         }
374         case op_mov: {
375             int r0 = (++it)->u.operand;
376             int r1 = (++it)->u.operand;
377             printf("[%4d] mov\t\t %s, %s\n", location, registerName(r0).c_str(), registerName(r1).c_str());
378             break;
379         }
380         case op_not: {
381             printUnaryOp(location, it, "not");
382             break;
383         }
384         case op_eq: {
385             printBinaryOp(location, it, "eq");
386             break;
387         }
388         case op_eq_null: {
389             printUnaryOp(location, it, "eq_null");
390             break;
391         }
392         case op_neq: {
393             printBinaryOp(location, it, "neq");
394             break;
395         }
396         case op_neq_null: {
397             printUnaryOp(location, it, "neq_null");
398             break;
399         }
400         case op_stricteq: {
401             printBinaryOp(location, it, "stricteq");
402             break;
403         }
404         case op_nstricteq: {
405             printBinaryOp(location, it, "nstricteq");
406             break;
407         }
408         case op_less: {
409             printBinaryOp(location, it, "less");
410             break;
411         }
412         case op_lesseq: {
413             printBinaryOp(location, it, "lesseq");
414             break;
415         }
416         case op_pre_inc: {
417             int r0 = (++it)->u.operand;
418             printf("[%4d] pre_inc\t\t %s\n", location, registerName(r0).c_str());
419             break;
420         }
421         case op_pre_dec: {
422             int r0 = (++it)->u.operand;
423             printf("[%4d] pre_dec\t\t %s\n", location, registerName(r0).c_str());
424             break;
425         }
426         case op_post_inc: {
427             printUnaryOp(location, it, "post_inc");
428             break;
429         }
430         case op_post_dec: {
431             printUnaryOp(location, it, "post_dec");
432             break;
433         }
434         case op_to_jsnumber: {
435             printUnaryOp(location, it, "to_jsnumber");
436             break;
437         }
438         case op_negate: {
439             printUnaryOp(location, it, "negate");
440             break;
441         }
442         case op_add: {
443             printBinaryOp(location, it, "add");
444             break;
445         }
446         case op_mul: {
447             printBinaryOp(location, it, "mul");
448             break;
449         }
450         case op_div: {
451             printBinaryOp(location, it, "div");
452             break;
453         }
454         case op_mod: {
455             printBinaryOp(location, it, "mod");
456             break;
457         }
458         case op_sub: {
459             printBinaryOp(location, it, "sub");
460             break;
461         }
462         case op_lshift: {
463             printBinaryOp(location, it, "lshift");
464             break;            
465         }
466         case op_rshift: {
467             printBinaryOp(location, it, "rshift");
468             break;
469         }
470         case op_urshift: {
471             printBinaryOp(location, it, "urshift");
472             break;
473         }
474         case op_bitand: {
475             printBinaryOp(location, it, "bitand");
476             break;
477         }
478         case op_bitxor: {
479             printBinaryOp(location, it, "bitxor");
480             break;
481         }
482         case op_bitor: {
483             printBinaryOp(location, it, "bitor");
484             break;
485         }
486         case op_bitnot: {
487             printUnaryOp(location, it, "bitnot");
488             break;
489         }
490         case op_instanceof: {
491             printBinaryOp(location, it, "instanceof");
492             break;
493         }
494         case op_typeof: {
495             printUnaryOp(location, it, "typeof");
496             break;
497         }
498         case op_in: {
499             printBinaryOp(location, it, "in");
500             break;
501         }
502         case op_resolve: {
503             int r0 = (++it)->u.operand;
504             int id0 = (++it)->u.operand;
505             printf("[%4d] resolve\t\t %s, %s\n", location, registerName(r0).c_str(), idName(id0, identifiers[id0]).c_str());
506             break;
507         }
508         case op_resolve_skip: {
509             int r0 = (++it)->u.operand;
510             int id0 = (++it)->u.operand;
511             int skipLevels = (++it)->u.operand;
512             printf("[%4d] resolve_skip\t %s, %s, %d\n", location, registerName(r0).c_str(), idName(id0, identifiers[id0]).c_str(), skipLevels);
513             break;
514         }
515         case op_get_scoped_var: {
516             int r0 = (++it)->u.operand;
517             int index = (++it)->u.operand;
518             int skipLevels = (++it)->u.operand;
519             printf("[%4d] get_scoped_var\t %s, %d, %d\n", location, registerName(r0).c_str(), index, skipLevels);
520             break;
521         }
522         case op_put_scoped_var: {
523             int index = (++it)->u.operand;
524             int skipLevels = (++it)->u.operand;
525             int r0 = (++it)->u.operand;
526             printf("[%4d] put_scoped_var\t %d, %d, %s\n", location, index, skipLevels, registerName(r0).c_str());
527             break;
528         }
529         case op_get_global_var: {
530             int r0 = (++it)->u.operand;
531             JSValue* scope = static_cast<JSValue*>((++it)->u.jsCell);
532             int index = (++it)->u.operand;
533             printf("[%4d] get_global_var\t %s, %s, %d\n", location, registerName(r0).c_str(), valueToSourceString(exec, scope).ascii(), index);
534             break;
535         }
536         case op_put_global_var: {
537             JSValue* scope = static_cast<JSValue*>((++it)->u.jsCell);
538             int index = (++it)->u.operand;
539             int r0 = (++it)->u.operand;
540             printf("[%4d] put_global_var\t %s, %d, %s\n", location, valueToSourceString(exec, scope).ascii(), index, registerName(r0).c_str());
541             break;
542         }
543         case op_resolve_base: {
544             int r0 = (++it)->u.operand;
545             int id0 = (++it)->u.operand;
546             printf("[%4d] resolve_base\t %s, %s\n", location, registerName(r0).c_str(), idName(id0, identifiers[id0]).c_str());
547             break;
548         }
549         case op_resolve_with_base: {
550             int r0 = (++it)->u.operand;
551             int r1 = (++it)->u.operand;
552             int id0 = (++it)->u.operand;
553             printf("[%4d] resolve_with_base %s, %s, %s\n", location, registerName(r0).c_str(), registerName(r1).c_str(), idName(id0, identifiers[id0]).c_str());
554             break;
555         }
556         case op_resolve_func: {
557             int r0 = (++it)->u.operand;
558             int r1 = (++it)->u.operand;
559             int id0 = (++it)->u.operand;
560             printf("[%4d] resolve_func\t %s, %s, %s\n", location, registerName(r0).c_str(), registerName(r1).c_str(), idName(id0, identifiers[id0]).c_str());
561             break;
562         }
563         case op_get_by_id: {
564             printGetByIdOp(location, it, identifiers, "get_by_id");
565             break;
566         }
567         case op_get_by_id_self: {
568             printGetByIdOp(location, it, identifiers, "get_by_id_self");
569             break;
570         }
571         case op_get_by_id_proto: {
572             printGetByIdOp(location, it, identifiers, "get_by_id_proto");
573             break;
574         }
575         case op_get_by_id_chain: {
576             printGetByIdOp(location, it, identifiers, "get_by_id_chain");
577             break;
578         }
579         case op_get_by_id_generic: {
580             printGetByIdOp(location, it, identifiers, "get_by_id_generic");
581             break;
582         }
583         case op_get_array_length: {
584             printGetByIdOp(location, it, identifiers, "get_array_length");
585             break;
586         }
587         case op_get_string_length: {
588             printGetByIdOp(location, it, identifiers, "get_string_length");
589             break;
590         }
591         case op_put_by_id: {
592             printPutByIdOp(location, it, identifiers, "put_by_id");
593             break;
594         }
595         case op_put_by_id_replace: {
596             printPutByIdOp(location, it, identifiers, "put_by_id_replace");
597             break;
598         }
599         case op_put_by_id_transition: {
600             printPutByIdOp(location, it, identifiers, "put_by_id_transition");
601             break;
602         }
603         case op_put_by_id_generic: {
604             printPutByIdOp(location, it, identifiers, "put_by_id_generic");
605             break;
606         }
607         case op_put_getter: {
608             int r0 = (++it)->u.operand;
609             int id0 = (++it)->u.operand;
610             int r1 = (++it)->u.operand;
611             printf("[%4d] put_getter\t %s, %s, %s\n", location, registerName(r0).c_str(), idName(id0, identifiers[id0]).c_str(), registerName(r1).c_str());
612             break;
613         }
614         case op_put_setter: {
615             int r0 = (++it)->u.operand;
616             int id0 = (++it)->u.operand;
617             int r1 = (++it)->u.operand;
618             printf("[%4d] put_setter\t %s, %s, %s\n", location, registerName(r0).c_str(), idName(id0, identifiers[id0]).c_str(), registerName(r1).c_str());
619             break;
620         }
621         case op_del_by_id: {
622             int r0 = (++it)->u.operand;
623             int r1 = (++it)->u.operand;
624             int id0 = (++it)->u.operand;
625             printf("[%4d] del_by_id\t %s, %s, %s\n", location, registerName(r0).c_str(), registerName(r1).c_str(), idName(id0, identifiers[id0]).c_str());
626             break;
627         }
628         case op_get_by_val: {
629             int r0 = (++it)->u.operand;
630             int r1 = (++it)->u.operand;
631             int r2 = (++it)->u.operand;
632             printf("[%4d] get_by_val\t %s, %s, %s\n", location, registerName(r0).c_str(), registerName(r1).c_str(), registerName(r2).c_str());
633             break;
634         }
635         case op_put_by_val: {
636             int r0 = (++it)->u.operand;
637             int r1 = (++it)->u.operand;
638             int r2 = (++it)->u.operand;
639             printf("[%4d] put_by_val\t %s, %s, %s\n", location, registerName(r0).c_str(), registerName(r1).c_str(), registerName(r2).c_str());
640             break;
641         }
642         case op_del_by_val: {
643             int r0 = (++it)->u.operand;
644             int r1 = (++it)->u.operand;
645             int r2 = (++it)->u.operand;
646             printf("[%4d] del_by_val\t %s, %s, %s\n", location, registerName(r0).c_str(), registerName(r1).c_str(), registerName(r2).c_str());
647             break;
648         }
649         case op_put_by_index: {
650             int r0 = (++it)->u.operand;
651             unsigned n0 = (++it)->u.operand;
652             int r1 = (++it)->u.operand;
653             printf("[%4d] put_by_index\t %s, %u, %s\n", location, registerName(r0).c_str(), n0, registerName(r1).c_str());
654             break;
655         }
656         case op_jmp: {
657             int offset = (++it)->u.operand;
658             printf("[%4d] jmp\t\t %d(->%d)\n", location, offset, jumpTarget(begin, it, offset));
659             break;
660         }
661         case op_loop: {
662             int offset = (++it)->u.operand;
663             printf("[%4d] loop\t\t %d(->%d)\n", location, offset, jumpTarget(begin, it, offset));
664             break;
665         }
666         case op_jtrue: {
667             printConditionalJump(begin, it, location, "jtrue");
668             break;
669         }
670         case op_loop_if_true: {
671             printConditionalJump(begin, it, location, "loop_if_true");
672             break;
673         }
674         case op_jfalse: {
675             printConditionalJump(begin, it, location, "jfalse");
676             break;
677         }
678         case op_jnless: {
679             int r0 = (++it)->u.operand;
680             int r1 = (++it)->u.operand;
681             int offset = (++it)->u.operand;
682             printf("[%4d] jnless\t\t %s, %s, %d(->%d)\n", location, registerName(r0).c_str(), registerName(r1).c_str(), offset, jumpTarget(begin, it, offset));
683             break;
684         }
685         case op_loop_if_less: {
686             int r0 = (++it)->u.operand;
687             int r1 = (++it)->u.operand;
688             int offset = (++it)->u.operand;
689             printf("[%4d] loop_if_less\t %s, %s, %d(->%d)\n", location, registerName(r0).c_str(), registerName(r1).c_str(), offset, jumpTarget(begin, it, offset));
690             break;
691         }
692         case op_switch_imm: {
693             int tableIndex = (++it)->u.operand;
694             int defaultTarget = (++it)->u.operand;
695             int scrutineeRegister = (++it)->u.operand;
696             printf("[%4d] switch_imm\t %d, %d(->%d), %s\n", location, tableIndex, defaultTarget, jumpTarget(begin, it, defaultTarget), registerName(scrutineeRegister).c_str());
697             break;
698         }
699         case op_switch_char: {
700             int tableIndex = (++it)->u.operand;
701             int defaultTarget = (++it)->u.operand;
702             int scrutineeRegister = (++it)->u.operand;
703             printf("[%4d] switch_char\t %d, %d(->%d), %s\n", location, tableIndex, defaultTarget, jumpTarget(begin, it, defaultTarget), registerName(scrutineeRegister).c_str());
704             break;
705         }
706         case op_switch_string: {
707             int tableIndex = (++it)->u.operand;
708             int defaultTarget = (++it)->u.operand;
709             int scrutineeRegister = (++it)->u.operand;
710             printf("[%4d] switch_string\t %d, %d(->%d), %s\n", location, tableIndex, defaultTarget, jumpTarget(begin, it, defaultTarget), registerName(scrutineeRegister).c_str());
711             break;
712         }
713         case op_new_func: {
714             int r0 = (++it)->u.operand;
715             int f0 = (++it)->u.operand;
716             printf("[%4d] new_func\t\t %s, f%d\n", location, registerName(r0).c_str(), f0);
717             break;
718         }
719         case op_new_func_exp: {
720             int r0 = (++it)->u.operand;
721             int f0 = (++it)->u.operand;
722             printf("[%4d] new_func_exp\t %s, f%d\n", location, registerName(r0).c_str(), f0);
723             break;
724         }
725         case op_call: {
726             int r0 = (++it)->u.operand;
727             int r1 = (++it)->u.operand;
728             int r2 = (++it)->u.operand;
729             int tempCount = (++it)->u.operand;
730             int argCount = (++it)->u.operand;
731             printf("[%4d] call\t\t %s, %s, %s, %d, %d\n", location, registerName(r0).c_str(), registerName(r1).c_str(), registerName(r2).c_str(), tempCount, argCount);
732             break;
733         }
734         case op_call_eval: {
735             int r0 = (++it)->u.operand;
736             int r1 = (++it)->u.operand;
737             int r2 = (++it)->u.operand;
738             int tempCount = (++it)->u.operand;
739             int argCount = (++it)->u.operand;
740             printf("[%4d] call_eval\t\t %s, %s, %s, %d, %d\n", location, registerName(r0).c_str(), registerName(r1).c_str(), registerName(r2).c_str(), tempCount, argCount);
741             break;
742         }
743         case op_ret: {
744             int r0 = (++it)->u.operand;
745             printf("[%4d] ret\t\t %s\n", location, registerName(r0).c_str());
746             break;
747         }
748         case op_construct: {
749             int r0 = (++it)->u.operand;
750             int r1 = (++it)->u.operand;
751             int tempCount = (++it)->u.operand;
752             int argCount = (++it)->u.operand;
753             printf("[%4d] construct\t %s, %s, %d, %d\n", location, registerName(r0).c_str(), registerName(r1).c_str(), tempCount, argCount);
754             break;
755         }
756         case op_get_pnames: {
757             int r0 = (++it)->u.operand;
758             int r1 = (++it)->u.operand;
759             printf("[%4d] get_pnames\t %s, %s\n", location, registerName(r0).c_str(), registerName(r1).c_str());
760             break;
761         }
762         case op_next_pname: {
763             int dest = (++it)->u.operand;
764             int iter = (++it)->u.operand;
765             int offset = (++it)->u.operand;
766             printf("[%4d] next_pname\t %s, %s, %d(->%d)\n", location, registerName(dest).c_str(), registerName(iter).c_str(), offset, jumpTarget(begin, it, offset));
767             break;
768         }
769         case op_push_scope: {
770             int r0 = (++it)->u.operand;
771             printf("[%4d] push_scope\t %s\n", location, registerName(r0).c_str());
772             break;
773         }
774         case op_pop_scope: {
775             printf("[%4d] pop_scope\n", location);
776             break;
777         }
778         case op_push_new_scope: {
779             int r0 = (++it)->u.operand;
780             int id0 = (++it)->u.operand;
781             int r1 = (++it)->u.operand;
782             printf("[%4d] push_new_scope \t%s, %s, %s\n", location, registerName(r0).c_str(), idName(id0, identifiers[id0]).c_str(), registerName(r1).c_str());
783             break;
784         }
785         case op_jmp_scopes: {
786             int scopeDelta = (++it)->u.operand;
787             int offset = (++it)->u.operand;
788             printf("[%4d] jmp_scopes\t^%d, %d(->%d)\n", location, scopeDelta, offset, jumpTarget(begin, it, offset));
789             break;
790         }
791         case op_catch: {
792             int r0 = (++it)->u.operand;
793             printf("[%4d] catch\t\t %s\n", location, registerName(r0).c_str());
794             break;
795         }
796         case op_throw: {
797             int r0 = (++it)->u.operand;
798             printf("[%4d] throw\t\t %s\n", location, registerName(r0).c_str());
799             break;
800         }
801         case op_new_error: {
802             int r0 = (++it)->u.operand;
803             int errorType = (++it)->u.operand;
804             int k0 = (++it)->u.operand;
805             printf("[%4d] new_error\t %s, %d, %s\n", location, registerName(r0).c_str(), errorType, constantName(exec, k0, unexpectedConstants[k0]).c_str());
806             break;
807         }
808         case op_jsr: {
809             int retAddrDst = (++it)->u.operand;
810             int offset = (++it)->u.operand;
811             printf("[%4d] jsr\t\t %s, %d(->%d)\n", location, registerName(retAddrDst).c_str(), offset, jumpTarget(begin, it, offset));
812             break;
813         }
814         case op_sret: {
815             int retAddrSrc = (++it)->u.operand;
816             printf("[%4d] sret\t\t %s\n", location, registerName(retAddrSrc).c_str());
817             break;
818         }
819         case op_debug: {
820             int debugHookID = (++it)->u.operand;
821             int firstLine = (++it)->u.operand;
822             int lastLine = (++it)->u.operand;
823             printf("[%4d] debug\t\t %s, %d, %d\n", location, debugHookName(debugHookID), firstLine, lastLine);
824             break;
825         }
826         case op_end: {
827             int r0 = (++it)->u.operand;
828             printf("[%4d] end\t\t %s\n", location, registerName(r0).c_str());
829             break;
830         }
831         default: {
832             ASSERT_NOT_REACHED();
833             break;
834         }
835     }
836 }
837
838 #endif // !defined(NDEBUG) || ENABLE(SAMPLING_TOOL)
839
840 CodeBlock::~CodeBlock()
841 {
842     size_t size = structureIDInstructions.size();
843     for (size_t i = 0; i < size; ++i)
844         derefStructureIDs(&instructions[structureIDInstructions[i]]);
845
846     size = structureIDAccessStubs.size();
847     for (size_t i = 0; i < size; ++i)
848         fastFree(structureIDAccessStubs[i]);
849
850 #if ENABLE(CTI)
851     if (ctiCode)
852         fastFree(ctiCode);
853 #endif
854 }
855
856 void CodeBlock::derefStructureIDs(Instruction* vPC) const
857 {
858     Machine* machine = globalData->machine;
859
860     if (vPC[0].u.opcode == machine->getOpcode(op_get_by_id_self)) {
861         vPC[4].u.structureID->deref();
862         return;
863     }
864     if (vPC[0].u.opcode == machine->getOpcode(op_get_by_id_proto)) {
865         vPC[4].u.structureID->deref();
866         vPC[5].u.structureID->deref();
867         return;
868     }
869     if (vPC[0].u.opcode == machine->getOpcode(op_get_by_id_chain)) {
870         vPC[4].u.structureID->deref();
871         vPC[5].u.structureIDChain->deref();
872         return;
873     }
874     if (vPC[0].u.opcode == machine->getOpcode(op_put_by_id_transition)) {
875         vPC[4].u.structureID->deref();
876         vPC[5].u.structureID->deref();
877         vPC[6].u.structureIDChain->deref();
878         return;
879     }
880     if (vPC[0].u.opcode == machine->getOpcode(op_put_by_id_replace)) {
881         vPC[4].u.structureID->deref();
882         return;
883     }
884     
885     // These instructions don't ref their StructureIDs.
886     ASSERT(vPC[0].u.opcode == machine->getOpcode(op_get_by_id) || vPC[0].u.opcode == machine->getOpcode(op_put_by_id) || vPC[0].u.opcode == machine->getOpcode(op_get_by_id_generic) || vPC[0].u.opcode == machine->getOpcode(op_put_by_id_generic) || vPC[0].u.opcode == machine->getOpcode(op_get_array_length) || vPC[0].u.opcode == machine->getOpcode(op_get_string_length));
887 }
888
889 void CodeBlock::refStructureIDs(Instruction* vPC) const
890 {
891     Machine* machine = globalData->machine;
892
893     if (vPC[0].u.opcode == machine->getOpcode(op_get_by_id_self)) {
894         vPC[4].u.structureID->ref();
895         return;
896     }
897     if (vPC[0].u.opcode == machine->getOpcode(op_get_by_id_proto)) {
898         vPC[4].u.structureID->ref();
899         vPC[5].u.structureID->ref();
900         return;
901     }
902     if (vPC[0].u.opcode == machine->getOpcode(op_get_by_id_chain)) {
903         vPC[4].u.structureID->ref();
904         vPC[5].u.structureIDChain->ref();
905         return;
906     }
907     if (vPC[0].u.opcode == machine->getOpcode(op_put_by_id_transition)) {
908         vPC[4].u.structureID->ref();
909         vPC[5].u.structureID->ref();
910         vPC[6].u.structureIDChain->ref();
911         return;
912     }
913     if (vPC[0].u.opcode == machine->getOpcode(op_put_by_id_replace)) {
914         vPC[4].u.structureID->ref();
915         return;
916     }
917     
918     // These instructions don't ref their StructureIDs.
919     ASSERT(vPC[0].u.opcode == machine->getOpcode(op_get_by_id) || vPC[0].u.opcode == machine->getOpcode(op_put_by_id) || vPC[0].u.opcode == machine->getOpcode(op_get_by_id_generic) || vPC[0].u.opcode == machine->getOpcode(op_put_by_id_generic));
920 }
921
922 void CodeBlock::mark()
923 {
924     for (size_t i = 0; i < constantRegisters.size(); ++i)
925         if (!constantRegisters[i].marked())
926             constantRegisters[i].mark();
927
928     for (size_t i = 0; i < unexpectedConstants.size(); ++i)
929         if (!unexpectedConstants[i]->marked())
930             unexpectedConstants[i]->mark();
931
932     for (size_t i = 0; i < functions.size(); ++i)
933         functions[i]->body()->mark();
934
935     for (size_t i = 0; i < functionExpressions.size(); ++i)
936         functionExpressions[i]->body()->mark();
937 }
938
939 bool CodeBlock::getHandlerForVPC(const Instruction* vPC, Instruction*& target, int& scopeDepth)
940 {
941     Vector<HandlerInfo>::iterator ptr = exceptionHandlers.begin(); 
942     Vector<HandlerInfo>::iterator end = exceptionHandlers.end();
943     unsigned addressOffset = vPC - instructions.begin();
944     ASSERT(addressOffset < instructions.size());
945     
946     for (; ptr != end; ++ptr) {
947         // Handlers are ordered innermost first, so the first handler we encounter
948         // that contains the source address is the correct handler to use.
949         if (ptr->start <= addressOffset && ptr->end >= addressOffset) {
950             scopeDepth = ptr->scopeDepth;
951             target = instructions.begin() + ptr->target;
952             return true;
953         }
954     }
955     return false;
956 }
957
958 void* CodeBlock::nativeExceptionCodeForHandlerVPC(const Instruction* handlerVPC)
959 {
960     Vector<HandlerInfo>::iterator ptr = exceptionHandlers.begin(); 
961     Vector<HandlerInfo>::iterator end = exceptionHandlers.end();
962     
963     for (; ptr != end; ++ptr) {
964         Instruction*target = instructions.begin() + ptr->target;
965         if (handlerVPC == target)
966             return ptr->nativeCode;
967     }
968
969     return 0;
970 }
971
972 int CodeBlock::lineNumberForVPC(const Instruction* vPC)
973 {
974     ASSERT(lineInfo.size());    
975     unsigned instructionOffset = vPC - instructions.begin();
976     ASSERT(instructionOffset < instructions.size());
977
978     if (!lineInfo.size())
979         return 1; // Empty function
980
981     int low = 0;
982     int high = lineInfo.size();
983     while (low < high) {
984         int mid = low + (high - low) / 2;
985         if (lineInfo[mid].instructionOffset <= instructionOffset)
986             low = mid + 1;
987         else
988             high = mid;
989     }
990     return lineInfo[low - 1].lineNumber;
991 }
992
993 int CodeBlock::expressionRangeForVPC(const Instruction* vPC, int& divot, int& startOffset, int& endOffset)
994 {
995     unsigned instructionOffset = vPC - instructions.begin();
996     ASSERT(instructionOffset < instructions.size());
997
998     if (!expressionInfo.size()) {
999         // We didn't think anything could throw.  Apparently we were wrong.
1000         startOffset = 0;
1001         endOffset = 0;
1002         divot = 0;
1003         return lineNumberForVPC(vPC);
1004     }
1005
1006     int low = 0;
1007     int high = expressionInfo.size();
1008     while (low < high) {
1009         int mid = low + (high - low) / 2;
1010         if (expressionInfo[mid].instructionOffset <= instructionOffset)
1011             low = mid + 1;
1012         else
1013             high = mid;
1014     }
1015     
1016     ASSERT(low);
1017     if (!low) {
1018         startOffset = 0;
1019         endOffset = 0;
1020         divot = 0;
1021         return lineNumberForVPC(vPC);
1022     }
1023
1024     startOffset = expressionInfo[low - 1].startOffset;
1025     endOffset = expressionInfo[low - 1].endOffset;
1026     divot = expressionInfo[low - 1].divotPoint + sourceOffset;
1027     return lineNumberForVPC(vPC);
1028 }
1029
1030 int32_t SimpleJumpTable::offsetForValue(int32_t value, int32_t defaultOffset)
1031 {
1032     if (value >= min && static_cast<uint32_t>(value - min) < branchOffsets.size()) {
1033         int32_t offset = branchOffsets[value - min];
1034         if (offset)
1035             return offset;
1036     }
1037     return defaultOffset;        
1038 }
1039
1040 } // namespace JSC