Windows build fixes
[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 KJS {
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 += 2;
176 }
177
178 void CodeBlock::printStructureID(const char* name, const Instruction* vPC, int operand) const
179 {
180     printf("  [%4d] %s: %s\n", vPC - instructions.begin(), name, pointerToSourceString(vPC[operand].u.structureID).UTF8String().c_str());
181 }
182
183 void CodeBlock::printStructureIDs(const Instruction* vPC) const
184 {
185     Machine* machine = globalData->machine;
186
187     if (vPC[0].u.opcode == machine->getOpcode(op_get_by_id)) {
188         printStructureID("get_by_id", vPC, 4);
189         return;
190     }
191     if (vPC[0].u.opcode == machine->getOpcode(op_get_by_id_self)) {
192         printStructureID("get_by_id_self", vPC, 4);
193         return;
194     }
195     if (vPC[0].u.opcode == machine->getOpcode(op_get_by_id_proto)) {
196         printf("  [%4d] %s: %s, %s\n", vPC - instructions.begin(), "get_by_id_proto", pointerToSourceString(vPC[4].u.structureID).UTF8String().c_str(), pointerToSourceString(vPC[5].u.structureID).UTF8String().c_str());
197         return;
198     }
199     if (vPC[0].u.opcode == machine->getOpcode(op_get_by_id_chain)) {
200         printf("  [%4d] %s: %s, %s\n", vPC - instructions.begin(), "get_by_id_chain", pointerToSourceString(vPC[4].u.structureID).UTF8String().c_str(), pointerToSourceString(vPC[5].u.structureIDChain).UTF8String().c_str());
201         return;
202     }
203     if (vPC[0].u.opcode == machine->getOpcode(op_put_by_id)) {
204         printStructureID("put_by_id", vPC, 4);
205         return;
206     }
207     if (vPC[0].u.opcode == machine->getOpcode(op_put_by_id_replace)) {
208         printStructureID("put_by_id_replace", vPC, 4);
209         return;
210     }
211
212     // These instructions doesn't ref StructureIDs.
213     ASSERT(vPC[0].u.opcode == machine->getOpcode(op_get_by_id_generic) || vPC[0].u.opcode == machine->getOpcode(op_put_by_id_generic));
214 }
215
216 void CodeBlock::dump(ExecState* exec) const
217 {
218     Vector<Instruction>::const_iterator begin = instructions.begin();
219     Vector<Instruction>::const_iterator end = instructions.end();
220
221     size_t instructionCount = 0;
222     for (Vector<Instruction>::const_iterator it = begin; it != end; ++it)
223         if (exec->machine()->isOpcode(it->u.opcode))
224             ++instructionCount;
225
226     printf("%lu instructions; %lu bytes at %p; %d locals (%d parameters); %d temporaries\n\n",
227         static_cast<unsigned long>(instructionCount),
228         static_cast<unsigned long>(instructions.size() * sizeof(Instruction)),
229         this, numLocals, numParameters, numTemporaries);
230     
231     for (Vector<Instruction>::const_iterator it = begin; it != end; ++it)
232         dump(exec, begin, it);
233
234     if (identifiers.size()) {
235         printf("\nIdentifiers:\n");
236         size_t i = 0;
237         do {
238             printf("  id%u = %s\n", static_cast<unsigned>(i), identifiers[i].ascii());
239             ++i;
240         } while (i != identifiers.size());
241     }
242
243     if (constantRegisters.size()) {
244         printf("\nConstants:\n");
245         size_t i = 0;
246         do {
247             printf("  tr%u = %s\n", static_cast<unsigned>(i), valueToSourceString(exec, constantRegisters[i].jsValue(exec)).ascii());
248             ++i;
249         } while (i < constantRegisters.size());
250     }
251
252     if (unexpectedConstants.size()) {
253         printf("\nUnexpected Constants:\n");
254         size_t i = 0;
255         do {
256             printf("  k%u = %s\n", static_cast<unsigned>(i), valueToSourceString(exec, unexpectedConstants[i]).ascii());
257             ++i;
258         } while (i < unexpectedConstants.size());
259     }
260     
261     if (regexps.size()) {
262         printf("\nRegExps:\n");
263         size_t i = 0;
264         do {
265             printf("  re%u = %s\n", static_cast<unsigned>(i), regexpToSourceString(regexps[i].get()).ascii());
266             ++i;
267         } while (i < regexps.size());
268     }
269
270     if (structureIDInstructions.size()) {
271         printf("\nStructureIDs:\n");
272         size_t i = 0;
273         do {
274             printStructureIDs(&instructions[structureIDInstructions[i]]);
275             ++i;
276         } while (i < structureIDInstructions.size());
277     }
278
279     if (exceptionHandlers.size()) {
280         printf("\nException Handlers:\n");
281         unsigned i = 0;
282         do {
283             printf("\t %d: { start: [%4d] end: [%4d] target: [%4d] }\n", i + 1, exceptionHandlers[i].start, exceptionHandlers[i].end, exceptionHandlers[i].target);
284             ++i;
285         } while (i < exceptionHandlers.size());
286     }
287     
288     if (immediateSwitchJumpTables.size()) {
289         printf("Immediate Switch Jump Tables:\n");
290         unsigned i = 0;
291         do {
292             printf("  %1d = {\n", i);
293             int entry = 0;
294             Vector<int32_t>::const_iterator end = immediateSwitchJumpTables[i].branchOffsets.end();
295             for (Vector<int32_t>::const_iterator iter = immediateSwitchJumpTables[i].branchOffsets.begin(); iter != end; ++iter, ++entry) {
296                 if (!*iter)
297                     continue;
298                 printf("\t\t%4d => %04d\n", entry + immediateSwitchJumpTables[i].min, *iter);
299             }
300             printf("      }\n");
301             ++i;
302         } while (i < immediateSwitchJumpTables.size());
303     }
304     
305     if (characterSwitchJumpTables.size()) {
306         printf("\nCharacter Switch Jump Tables:\n");
307         unsigned i = 0;
308         do {
309             printf("  %1d = {\n", i);
310             int entry = 0;
311             Vector<int32_t>::const_iterator end = characterSwitchJumpTables[i].branchOffsets.end();
312             for (Vector<int32_t>::const_iterator iter = characterSwitchJumpTables[i].branchOffsets.begin(); iter != end; ++iter, ++entry) {
313                 if (!*iter)
314                     continue;
315                 ASSERT(!((i + characterSwitchJumpTables[i].min) & ~0xFFFF));
316                 UChar ch = static_cast<UChar>(entry + characterSwitchJumpTables[i].min);
317                 printf("\t\t\"%s\" => %04d\n", UString(&ch, 1).ascii(), *iter);
318             }
319             printf("      }\n");
320             ++i;
321         } while (i < characterSwitchJumpTables.size());
322     }
323     
324     if (stringSwitchJumpTables.size()) {
325         printf("\nString Switch Jump Tables:\n");
326         unsigned i = 0;
327         do {
328             printf("  %1d = {\n", i);
329             StringJumpTable::const_iterator end = stringSwitchJumpTables[i].end();
330             for (StringJumpTable::const_iterator iter = stringSwitchJumpTables[i].begin(); iter != end; ++iter)
331                 printf("\t\t\"%s\" => %04d\n", UString(iter->first).ascii(), iter->second);
332             printf("      }\n");
333             ++i;
334         } while (i < stringSwitchJumpTables.size());
335     }
336
337     printf("\n");
338 }
339
340 void CodeBlock::dump(ExecState* exec, const Vector<Instruction>::const_iterator& begin, Vector<Instruction>::const_iterator& it) const
341 {
342     int location = it - begin;
343     switch (exec->machine()->getOpcodeID(it->u.opcode)) {
344         case op_unexpected_load: {
345             int r0 = (++it)->u.operand;
346             int k0 = (++it)->u.operand;
347             printf("[%4d] unexpected_load\t %s, %s\n", location, registerName(r0).c_str(), constantName(exec, k0, unexpectedConstants[k0]).c_str());
348             break;
349         }
350         case op_new_object: {
351             int r0 = (++it)->u.operand;
352             printf("[%4d] new_object\t %s\n", location, registerName(r0).c_str());
353             break;
354         }
355         case op_new_array: {
356             int dst = (++it)->u.operand;
357             int argv = (++it)->u.operand;
358             int argc = (++it)->u.operand;
359             printf("[%4d] new_array\t %s, %s, %d\n", location, registerName(dst).c_str(), registerName(argv).c_str(), argc);
360             break;
361         }
362         case op_new_regexp: {
363             int r0 = (++it)->u.operand;
364             int re0 = (++it)->u.operand;
365             printf("[%4d] new_regexp\t %s, %s\n", location, registerName(r0).c_str(), regexpName(re0, regexps[re0].get()).c_str());
366             break;
367         }
368         case op_mov: {
369             int r0 = (++it)->u.operand;
370             int r1 = (++it)->u.operand;
371             printf("[%4d] mov\t\t %s, %s\n", location, registerName(r0).c_str(), registerName(r1).c_str());
372             break;
373         }
374         case op_not: {
375             printUnaryOp(location, it, "not");
376             break;
377         }
378         case op_eq: {
379             printBinaryOp(location, it, "eq");
380             break;
381         }
382         case op_neq: {
383             printBinaryOp(location, it, "neq");
384             break;
385         }
386         case op_stricteq: {
387             printBinaryOp(location, it, "stricteq");
388             break;
389         }
390         case op_nstricteq: {
391             printBinaryOp(location, it, "nstricteq");
392             break;
393         }
394         case op_less: {
395             printBinaryOp(location, it, "less");
396             break;
397         }
398         case op_lesseq: {
399             printBinaryOp(location, it, "lesseq");
400             break;
401         }
402         case op_pre_inc: {
403             int r0 = (++it)->u.operand;
404             printf("[%4d] pre_inc\t\t %s\n", location, registerName(r0).c_str());
405             break;
406         }
407         case op_pre_dec: {
408             int r0 = (++it)->u.operand;
409             printf("[%4d] pre_dec\t\t %s\n", location, registerName(r0).c_str());
410             break;
411         }
412         case op_post_inc: {
413             printUnaryOp(location, it, "post_inc");
414             break;
415         }
416         case op_post_dec: {
417             printUnaryOp(location, it, "post_dec");
418             break;
419         }
420         case op_to_jsnumber: {
421             printUnaryOp(location, it, "to_jsnumber");
422             break;
423         }
424         case op_negate: {
425             printUnaryOp(location, it, "negate");
426             break;
427         }
428         case op_add: {
429             printBinaryOp(location, it, "add");
430             break;
431         }
432         case op_mul: {
433             printBinaryOp(location, it, "mul");
434             break;
435         }
436         case op_div: {
437             printBinaryOp(location, it, "div");
438             break;
439         }
440         case op_mod: {
441             printBinaryOp(location, it, "mod");
442             break;
443         }
444         case op_sub: {
445             printBinaryOp(location, it, "sub");
446             break;
447         }
448         case op_lshift: {
449             printBinaryOp(location, it, "lshift");
450             break;            
451         }
452         case op_rshift: {
453             printBinaryOp(location, it, "rshift");
454             break;
455         }
456         case op_urshift: {
457             printBinaryOp(location, it, "urshift");
458             break;
459         }
460         case op_bitand: {
461             printBinaryOp(location, it, "bitand");
462             break;
463         }
464         case op_bitxor: {
465             printBinaryOp(location, it, "bitxor");
466             break;
467         }
468         case op_bitor: {
469             printBinaryOp(location, it, "bitor");
470             break;
471         }
472         case op_bitnot: {
473             printUnaryOp(location, it, "bitnot");
474             break;
475         }
476         case op_instanceof: {
477             printBinaryOp(location, it, "instanceof");
478             break;
479         }
480         case op_typeof: {
481             printUnaryOp(location, it, "typeof");
482             break;
483         }
484         case op_in: {
485             printBinaryOp(location, it, "in");
486             break;
487         }
488         case op_resolve: {
489             int r0 = (++it)->u.operand;
490             int id0 = (++it)->u.operand;
491             printf("[%4d] resolve\t\t %s, %s\n", location, registerName(r0).c_str(), idName(id0, identifiers[id0]).c_str());
492             break;
493         }
494         case op_resolve_skip: {
495             int r0 = (++it)->u.operand;
496             int id0 = (++it)->u.operand;
497             int skipLevels = (++it)->u.operand;
498             printf("[%4d] resolve_skip\t %s, %s, %d\n", location, registerName(r0).c_str(), idName(id0, identifiers[id0]).c_str(), skipLevels);
499             break;
500         }
501         case op_get_scoped_var: {
502             int r0 = (++it)->u.operand;
503             int index = (++it)->u.operand;
504             int skipLevels = (++it)->u.operand;
505             printf("[%4d] get_scoped_var\t %s, %d, %d\n", location, registerName(r0).c_str(), index, skipLevels);
506             break;
507         }
508         case op_put_scoped_var: {
509             int index = (++it)->u.operand;
510             int skipLevels = (++it)->u.operand;
511             int r0 = (++it)->u.operand;
512             printf("[%4d] put_scoped_var\t %d, %d, %s\n", location, index, skipLevels, registerName(r0).c_str());
513             break;
514         }
515         case op_resolve_base: {
516             int r0 = (++it)->u.operand;
517             int id0 = (++it)->u.operand;
518             printf("[%4d] resolve_base\t %s, %s\n", location, registerName(r0).c_str(), idName(id0, identifiers[id0]).c_str());
519             break;
520         }
521         case op_resolve_with_base: {
522             int r0 = (++it)->u.operand;
523             int r1 = (++it)->u.operand;
524             int id0 = (++it)->u.operand;
525             printf("[%4d] resolve_with_base %s, %s, %s\n", location, registerName(r0).c_str(), registerName(r1).c_str(), idName(id0, identifiers[id0]).c_str());
526             break;
527         }
528         case op_resolve_func: {
529             int r0 = (++it)->u.operand;
530             int r1 = (++it)->u.operand;
531             int id0 = (++it)->u.operand;
532             printf("[%4d] resolve_func\t %s, %s, %s\n", location, registerName(r0).c_str(), registerName(r1).c_str(), idName(id0, identifiers[id0]).c_str());
533             break;
534         }
535         case op_get_by_id: {
536             printGetByIdOp(location, it, identifiers, "get_by_id");
537             break;
538         }
539         case op_get_by_id_self: {
540             printGetByIdOp(location, it, identifiers, "get_by_id_self");
541             break;
542         }
543         case op_get_by_id_proto: {
544             printGetByIdOp(location, it, identifiers, "get_by_id_proto");
545             break;
546         }
547         case op_get_by_id_chain: {
548             printGetByIdOp(location, it, identifiers, "get_by_id_chain");
549             break;
550         }
551         case op_get_by_id_generic: {
552             printGetByIdOp(location, it, identifiers, "get_by_id_generic");
553             break;
554         }
555         case op_put_by_id: {
556             printPutByIdOp(location, it, identifiers, "put_by_id");
557             break;
558         }
559         case op_put_by_id_replace: {
560             printPutByIdOp(location, it, identifiers, "put_by_id_replace");
561             break;
562         }
563         case op_put_by_id_generic: {
564             printPutByIdOp(location, it, identifiers, "put_by_id_generic");
565             break;
566         }
567         case op_put_getter: {
568             int r0 = (++it)->u.operand;
569             int id0 = (++it)->u.operand;
570             int r1 = (++it)->u.operand;
571             printf("[%4d] put_getter\t %s, %s, %s\n", location, registerName(r0).c_str(), idName(id0, identifiers[id0]).c_str(), registerName(r1).c_str());
572             break;
573         }
574         case op_put_setter: {
575             int r0 = (++it)->u.operand;
576             int id0 = (++it)->u.operand;
577             int r1 = (++it)->u.operand;
578             printf("[%4d] put_setter\t %s, %s, %s\n", location, registerName(r0).c_str(), idName(id0, identifiers[id0]).c_str(), registerName(r1).c_str());
579             break;
580         }
581         case op_del_by_id: {
582             int r0 = (++it)->u.operand;
583             int r1 = (++it)->u.operand;
584             int id0 = (++it)->u.operand;
585             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());
586             break;
587         }
588         case op_get_by_val: {
589             int r0 = (++it)->u.operand;
590             int r1 = (++it)->u.operand;
591             int r2 = (++it)->u.operand;
592             printf("[%4d] get_by_val\t %s, %s, %s\n", location, registerName(r0).c_str(), registerName(r1).c_str(), registerName(r2).c_str());
593             break;
594         }
595         case op_put_by_val: {
596             int r0 = (++it)->u.operand;
597             int r1 = (++it)->u.operand;
598             int r2 = (++it)->u.operand;
599             printf("[%4d] put_by_val\t %s, %s, %s\n", location, registerName(r0).c_str(), registerName(r1).c_str(), registerName(r2).c_str());
600             break;
601         }
602         case op_del_by_val: {
603             int r0 = (++it)->u.operand;
604             int r1 = (++it)->u.operand;
605             int r2 = (++it)->u.operand;
606             printf("[%4d] del_by_val\t %s, %s, %s\n", location, registerName(r0).c_str(), registerName(r1).c_str(), registerName(r2).c_str());
607             break;
608         }
609         case op_put_by_index: {
610             int r0 = (++it)->u.operand;
611             unsigned n0 = (++it)->u.operand;
612             int r1 = (++it)->u.operand;
613             printf("[%4d] put_by_index\t %s, %u, %s\n", location, registerName(r0).c_str(), n0, registerName(r1).c_str());
614             break;
615         }
616         case op_jmp: {
617             int offset = (++it)->u.operand;
618             printf("[%4d] jmp\t\t %d(->%d)\n", location, offset, jumpTarget(begin, it, offset));
619             break;
620         }
621         case op_loop: {
622             int offset = (++it)->u.operand;
623             printf("[%4d] loop\t\t %d(->%d)\n", location, offset, jumpTarget(begin, it, offset));
624             break;
625         }
626         case op_jtrue: {
627             printConditionalJump(begin, it, location, "jtrue");
628             break;
629         }
630         case op_loop_if_true: {
631             printConditionalJump(begin, it, location, "loop_if_true");
632             break;
633         }
634         case op_jfalse: {
635             printConditionalJump(begin, it, location, "jfalse");
636             break;
637         }
638         case op_jnless: {
639             int r0 = (++it)->u.operand;
640             int r1 = (++it)->u.operand;
641             int offset = (++it)->u.operand;
642             printf("[%4d] jnless\t\t %s, %s, %d(->%d)\n", location, registerName(r0).c_str(), registerName(r1).c_str(), offset, jumpTarget(begin, it, offset));
643             break;
644         }
645         case op_loop_if_less: {
646             int r0 = (++it)->u.operand;
647             int r1 = (++it)->u.operand;
648             int offset = (++it)->u.operand;
649             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));
650             break;
651         }
652         case op_switch_imm: {
653             int tableIndex = (++it)->u.operand;
654             int defaultTarget = (++it)->u.operand;
655             int scrutineeRegister = (++it)->u.operand;
656             printf("[%4d] switch_imm\t %d, %d(->%d), %s\n", location, tableIndex, defaultTarget, jumpTarget(begin, it, defaultTarget), registerName(scrutineeRegister).c_str());
657             break;
658         }
659         case op_switch_char: {
660             int tableIndex = (++it)->u.operand;
661             int defaultTarget = (++it)->u.operand;
662             int scrutineeRegister = (++it)->u.operand;
663             printf("[%4d] switch_char\t %d, %d(->%d), %s\n", location, tableIndex, defaultTarget, jumpTarget(begin, it, defaultTarget), registerName(scrutineeRegister).c_str());
664             break;
665         }
666         case op_switch_string: {
667             int tableIndex = (++it)->u.operand;
668             int defaultTarget = (++it)->u.operand;
669             int scrutineeRegister = (++it)->u.operand;
670             printf("[%4d] switch_string\t %d, %d(->%d), %s\n", location, tableIndex, defaultTarget, jumpTarget(begin, it, defaultTarget), registerName(scrutineeRegister).c_str());
671             break;
672         }
673         case op_new_func: {
674             int r0 = (++it)->u.operand;
675             int f0 = (++it)->u.operand;
676             printf("[%4d] new_func\t\t %s, f%d\n", location, registerName(r0).c_str(), f0);
677             break;
678         }
679         case op_new_func_exp: {
680             int r0 = (++it)->u.operand;
681             int f0 = (++it)->u.operand;
682             printf("[%4d] new_func_exp\t %s, f%d\n", location, registerName(r0).c_str(), f0);
683             break;
684         }
685         case op_call: {
686             int r0 = (++it)->u.operand;
687             int r1 = (++it)->u.operand;
688             int r2 = (++it)->u.operand;
689             int tempCount = (++it)->u.operand;
690             int argCount = (++it)->u.operand;
691             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);
692             break;
693         }
694         case op_call_eval: {
695             int r0 = (++it)->u.operand;
696             int r1 = (++it)->u.operand;
697             int r2 = (++it)->u.operand;
698             int tempCount = (++it)->u.operand;
699             int argCount = (++it)->u.operand;
700             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);
701             break;
702         }
703         case op_ret: {
704             int r0 = (++it)->u.operand;
705             printf("[%4d] ret\t\t %s\n", location, registerName(r0).c_str());
706             break;
707         }
708         case op_construct: {
709             int r0 = (++it)->u.operand;
710             int r1 = (++it)->u.operand;
711             int tempCount = (++it)->u.operand;
712             int argCount = (++it)->u.operand;
713             printf("[%4d] construct\t %s, %s, %d, %d\n", location, registerName(r0).c_str(), registerName(r1).c_str(), tempCount, argCount);
714             break;
715         }
716         case op_get_pnames: {
717             int r0 = (++it)->u.operand;
718             int r1 = (++it)->u.operand;
719             printf("[%4d] get_pnames\t %s, %s\n", location, registerName(r0).c_str(), registerName(r1).c_str());
720             break;
721         }
722         case op_next_pname: {
723             int dest = (++it)->u.operand;
724             int iter = (++it)->u.operand;
725             int offset = (++it)->u.operand;
726             printf("[%4d] next_pname\t %s, %s, %d(->%d)\n", location, registerName(dest).c_str(), registerName(iter).c_str(), offset, jumpTarget(begin, it, offset));
727             break;
728         }
729         case op_push_scope: {
730             int r0 = (++it)->u.operand;
731             printf("[%4d] push_scope\t %s\n", location, registerName(r0).c_str());
732             break;
733         }
734         case op_pop_scope: {
735             printf("[%4d] pop_scope\n", location);
736             break;
737         }
738         case op_push_new_scope: {
739             int r0 = (++it)->u.operand;
740             int id0 = (++it)->u.operand;
741             int r1 = (++it)->u.operand;
742             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());
743             break;
744         }
745         case op_jmp_scopes: {
746             int scopeDelta = (++it)->u.operand;
747             int offset = (++it)->u.operand;
748             printf("[%4d] jmp_scopes\t^%d, %d(->%d)\n", location, scopeDelta, offset, jumpTarget(begin, it, offset));
749             break;
750         }
751         case op_catch: {
752             int r0 = (++it)->u.operand;
753             printf("[%4d] catch\t\t %s\n", location, registerName(r0).c_str());
754             break;
755         }
756         case op_throw: {
757             int r0 = (++it)->u.operand;
758             printf("[%4d] throw\t\t %s\n", location, registerName(r0).c_str());
759             break;
760         }
761         case op_new_error: {
762             int r0 = (++it)->u.operand;
763             int errorType = (++it)->u.operand;
764             int k0 = (++it)->u.operand;
765             printf("[%4d] new_error\t %s, %d, %s\n", location, registerName(r0).c_str(), errorType, constantName(exec, k0, unexpectedConstants[k0]).c_str());
766             break;
767         }
768         case op_jsr: {
769             int retAddrDst = (++it)->u.operand;
770             int offset = (++it)->u.operand;
771             printf("[%4d] jsr\t\t %s, %d(->%d)\n", location, registerName(retAddrDst).c_str(), offset, jumpTarget(begin, it, offset));
772             break;
773         }
774         case op_sret: {
775             int retAddrSrc = (++it)->u.operand;
776             printf("[%4d] sret\t\t %s\n", location, registerName(retAddrSrc).c_str());
777             break;
778         }
779         case op_debug: {
780             int debugHookID = (++it)->u.operand;
781             int firstLine = (++it)->u.operand;
782             int lastLine = (++it)->u.operand;
783             printf("[%4d] debug\t\t %s, %d, %d\n", location, debugHookName(debugHookID), firstLine, lastLine);
784             break;
785         }
786         case op_end: {
787             int r0 = (++it)->u.operand;
788             printf("[%4d] end\t\t %s\n", location, registerName(r0).c_str());
789             break;
790         }
791         default: {
792             ASSERT_NOT_REACHED();
793             break;
794         }
795     }
796 }
797
798 #endif // !defined(NDEBUG) || ENABLE(SAMPLING_TOOL)
799
800 CodeBlock::~CodeBlock()
801 {
802     Vector<size_t>::const_iterator end = structureIDInstructions.end();
803     for (Vector<size_t>::const_iterator it = structureIDInstructions.begin(); it != end; ++it)
804         derefStructureIDs(&instructions[*it]);
805 }
806
807 void CodeBlock::derefStructureIDs(Instruction* vPC) const
808 {
809     Machine* machine = globalData->machine;
810
811     if (vPC[0].u.opcode == machine->getOpcode(op_get_by_id_self)) {
812         vPC[4].u.structureID->deref();
813         return;
814     }
815     if (vPC[0].u.opcode == machine->getOpcode(op_get_by_id_proto)) {
816         vPC[4].u.structureID->deref();
817         vPC[5].u.structureID->deref();
818         return;
819     }
820     if (vPC[0].u.opcode == machine->getOpcode(op_get_by_id_chain)) {
821         vPC[4].u.structureID->deref();
822         vPC[5].u.structureIDChain->deref();
823         return;
824     }
825     if (vPC[0].u.opcode == machine->getOpcode(op_put_by_id_replace)) {
826         vPC[4].u.structureID->deref();
827         return;
828     }
829     
830     // These instructions don't ref their StructureIDs.
831     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));
832 }
833
834 void CodeBlock::refStructureIDs(Instruction* vPC) const
835 {
836     Machine* machine = globalData->machine;
837
838     if (vPC[0].u.opcode == machine->getOpcode(op_get_by_id_self)) {
839         vPC[4].u.structureID->ref();
840         return;
841     }
842     if (vPC[0].u.opcode == machine->getOpcode(op_get_by_id_proto)) {
843         vPC[4].u.structureID->ref();
844         vPC[5].u.structureID->ref();
845         return;
846     }
847     if (vPC[0].u.opcode == machine->getOpcode(op_get_by_id_chain)) {
848         vPC[4].u.structureID->ref();
849         vPC[5].u.structureIDChain->ref();
850         return;
851     }
852     if (vPC[0].u.opcode == machine->getOpcode(op_put_by_id_replace)) {
853         vPC[4].u.structureID->ref();
854         return;
855     }
856     
857     // These instructions don't ref their StructureIDs.
858     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));
859 }
860
861 void CodeBlock::mark()
862 {
863     for (size_t i = 0; i < constantRegisters.size(); ++i)
864         if (!constantRegisters[i].marked())
865             constantRegisters[i].mark();
866
867     for (size_t i = 0; i < unexpectedConstants.size(); ++i)
868         if (!unexpectedConstants[i]->marked())
869             unexpectedConstants[i]->mark();
870
871     for (size_t i = 0; i < functions.size(); ++i)
872         functions[i]->body()->mark();
873
874     for (size_t i = 0; i < functionExpressions.size(); ++i)
875         functionExpressions[i]->body()->mark();
876 }
877
878 bool CodeBlock::getHandlerForVPC(const Instruction* vPC, Instruction*& target, int& scopeDepth)
879 {
880     Vector<HandlerInfo>::iterator ptr = exceptionHandlers.begin(); 
881     Vector<HandlerInfo>::iterator end = exceptionHandlers.end();
882     unsigned addressOffset = vPC - instructions.begin();
883     ASSERT(addressOffset < instructions.size());
884     
885     for (; ptr != end; ++ptr) {
886         // Handlers are ordered innermost first, so the first handler we encounter
887         // that contains the source address is the correct handler to use.
888         if (ptr->start <= addressOffset && ptr->end >= addressOffset) {
889             scopeDepth = ptr->scopeDepth;
890             target = instructions.begin() + ptr->target;
891             return true;
892         }
893     }
894     return false;
895 }
896
897 int CodeBlock::lineNumberForVPC(const Instruction* vPC)
898 {
899     ASSERT(lineInfo.size());    
900     unsigned instructionOffset = vPC - instructions.begin();
901     ASSERT(instructionOffset < instructions.size());
902
903     if (!lineInfo.size())
904         return 1; // Empty function
905
906     int low = 0;
907     int high = lineInfo.size();
908     while (low < high) {
909         int mid = low + (high - low) / 2;
910         if (lineInfo[mid].instructionOffset <= instructionOffset)
911             low = mid + 1;
912         else
913             high = mid;
914     }
915     return lineInfo[low - 1].lineNumber;
916 }
917
918 int CodeBlock::expressionRangeForVPC(const Instruction* vPC, int& divot, int& startOffset, int& endOffset)
919 {
920     unsigned instructionOffset = vPC - instructions.begin();
921     ASSERT(instructionOffset < instructions.size());
922
923     if (!expressionInfo.size()) {
924         // We didn't think anything could throw.  Apparently we were wrong.
925         startOffset = 0;
926         endOffset = 0;
927         divot = 0;
928         return lineNumberForVPC(vPC);
929     }
930
931     int low = 0;
932     int high = expressionInfo.size();
933     while (low < high) {
934         int mid = low + (high - low) / 2;
935         if (expressionInfo[mid].instructionOffset <= instructionOffset)
936             low = mid + 1;
937         else
938             high = mid;
939     }
940     
941     ASSERT(low);
942     if (!low) {
943         startOffset = 0;
944         endOffset = 0;
945         divot = 0;
946         return lineNumberForVPC(vPC);
947     }
948
949     startOffset = expressionInfo[low - 1].startOffset;
950     endOffset = expressionInfo[low - 1].endOffset;
951     divot = expressionInfo[low - 1].divotPoint + sourceOffset;
952     return lineNumberForVPC(vPC);
953 }
954
955 int32_t SimpleJumpTable::offsetForValue(int32_t value, int32_t defaultOffset)
956 {
957     if (value >= min && static_cast<uint32_t>(value - min) < branchOffsets.size()) {
958         int32_t offset = branchOffsets[value - min];
959         if (offset)
960             return offset;
961     }
962     return defaultOffset;        
963 }
964
965 } // namespace KJS