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