bytecode/CodeBlock.h

   1 /*
   2  * Copyright (C) 2008, 2009 Apple Inc. All rights reserved.
   3  * Copyright (C) 2008 Cameron Zwarich <cwzwarich@uwaterloo.ca>
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * 1.  Redistributions of source code must retain the above copyright
  10  *     notice, this list of conditions and the following disclaimer.
  11  * 2.  Redistributions in binary form must reproduce the above copyright
  12  *     notice, this list of conditions and the following disclaimer in the
  13  *     documentation and/or other materials provided with the distribution.
  14  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
  15  *     its contributors may be used to endorse or promote products derived
  16  *     from this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
  19  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  20  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  21  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  22  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  23  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  24  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  25  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  */
  29
  30 #ifndef CodeBlock_h
  31 #define CodeBlock_h
  32
  33 #include "EvalCodeCache.h"
  34 #include "Instruction.h"
  35 #include "JITCode.h"
  36 #include "JSGlobalObject.h"
  37 #include "JumpTable.h"
  38 #include "Nodes.h"
  39 #include "PtrAndFlags.h"
  40 #include "RegExp.h"
  41 #include "UString.h"
  42 #include <wtf/FastAllocBase.h>
  43 #include <wtf/RefPtr.h>
  44 #include <wtf/Vector.h>
  45
  46 #if ENABLE(JIT)
  47 #include "StructureStubInfo.h"
  48 #endif
  49
  50 // Register numbers used in bytecode operations have different meaning accoring to their ranges:
  51 //      0x80000000-0xFFFFFFFF  Negative indicies from the CallFrame pointer are entries in the call frame, see RegisterFile.h.
  52 //      0x00000000-0x3FFFFFFF  Forwards indices from the CallFrame pointer are local vars and temporaries with the function's callframe.
  53 //      0x40000000-0x7FFFFFFF  Positive indices from 0x40000000 specify entries in the constant pool on the CodeBlock.
  54 static const int FirstConstantRegisterIndex = 0x40000000;
  55
  56 namespace JSC {
  57
  58     enum HasSeenShouldRepatch {
  59         hasSeenShouldRepatch
  60     };
  61
  62     class ExecState;
  63
  64     enum CodeType { GlobalCode, EvalCode, FunctionCode };
  65
  66     static ALWAYS_INLINE int missingThisObjectMarker() { return std::numeric_limits<int>::max(); }
  67
  68     struct HandlerInfo {
  69         uint32_t start;
  70         uint32_t end;
  71         uint32_t target;
  72         uint32_t scopeDepth;
  73 #if ENABLE(JIT)
  74         CodeLocationLabel nativeCode;
  75 #endif
  76     };
  77
  78     struct ExpressionRangeInfo {
  79         enum {
  80             MaxOffset = (1 << 7) - 1,
  81             MaxDivot = (1 << 25) - 1
  82         };
  83         uint32_t instructionOffset : 25;
  84         uint32_t divotPoint : 25;
  85         uint32_t startOffset : 7;
  86         uint32_t endOffset : 7;
  87     };
  88
  89     struct LineInfo {
  90         uint32_t instructionOffset;
  91         int32_t lineNumber;
  92     };
  93
  94     // Both op_construct and op_instanceof require a use of op_get_by_id to get
  95     // the prototype property from an object. The exception messages for exceptions
  96     // thrown by these instances op_get_by_id need to reflect this.
  97     struct GetByIdExceptionInfo {
  98         unsigned bytecodeOffset : 31;
  99         bool isOpConstruct : 1;
 100     };
 101
 102 #if ENABLE(JIT)
 103     struct CallLinkInfo {
 104         CallLinkInfo()
 105             : callee(0)
 106         {
 107         }
 108
 109         unsigned bytecodeIndex;
 110         CodeLocationNearCall callReturnLocation;
 111         CodeLocationDataLabelPtr hotPathBegin;
 112         CodeLocationNearCall hotPathOther;
 113         PtrAndFlags<CodeBlock, HasSeenShouldRepatch> ownerCodeBlock;
 114         CodeBlock* callee;
 115         unsigned position;
 116
 117         void setUnlinked() { callee = 0; }
 118         bool isLinked() { return callee; }
 119
 120         bool seenOnce()
 121         {
 122             return ownerCodeBlock.isFlagSet(hasSeenShouldRepatch);
 123         }
 124
 125         void setSeen()
 126         {
 127             ownerCodeBlock.setFlag(hasSeenShouldRepatch);
 128         }
 129     };
 130
 131     struct MethodCallLinkInfo {
 132         MethodCallLinkInfo()
 133             : cachedStructure(0)
 134         {
 135         }
 136
 137         bool seenOnce()
 138         {
 139             return cachedPrototypeStructure.isFlagSet(hasSeenShouldRepatch);
 140         }
 141
 142         void setSeen()
 143         {
 144             cachedPrototypeStructure.setFlag(hasSeenShouldRepatch);
 145         }
 146
 147         CodeLocationCall callReturnLocation;
 148         CodeLocationDataLabelPtr structureLabel;
 149         Structure* cachedStructure;
 150         PtrAndFlags<Structure, HasSeenShouldRepatch> cachedPrototypeStructure;
 151     };
 152
 153     struct FunctionRegisterInfo {
 154         FunctionRegisterInfo(unsigned bytecodeOffset, int functionRegisterIndex)
 155             : bytecodeOffset(bytecodeOffset)
 156             , functionRegisterIndex(functionRegisterIndex)
 157         {
 158         }
 159
 160         unsigned bytecodeOffset;
 161         int functionRegisterIndex;
 162     };
 163
 164     struct GlobalResolveInfo {
 165         GlobalResolveInfo(unsigned bytecodeOffset)
 166             : structure(0)
 167             , offset(0)
 168             , bytecodeOffset(bytecodeOffset)
 169         {
 170         }
 171
 172         Structure* structure;
 173         unsigned offset;
 174         unsigned bytecodeOffset;
 175     };
 176
 177     // This structure is used to map from a call return location
 178     // (given as an offset in bytes into the JIT code) back to
 179     // the bytecode index of the corresponding bytecode operation.
 180     // This is then used to look up the corresponding handler.
 181     struct CallReturnOffsetToBytecodeIndex {
 182         CallReturnOffsetToBytecodeIndex(unsigned callReturnOffset, unsigned bytecodeIndex)
 183             : callReturnOffset(callReturnOffset)
 184             , bytecodeIndex(bytecodeIndex)
 185         {
 186         }
 187
 188         unsigned callReturnOffset;
 189         unsigned bytecodeIndex;
 190     };
 191
 192     // valueAtPosition helpers for the binaryChop algorithm below.
 193
 194     inline void* getStructureStubInfoReturnLocation(StructureStubInfo* structureStubInfo)
 195     {
 196         return structureStubInfo->callReturnLocation.executableAddress();
 197     }
 198
 199     inline void* getCallLinkInfoReturnLocation(CallLinkInfo* callLinkInfo)
 200     {
 201         return callLinkInfo->callReturnLocation.executableAddress();
 202     }
 203
 204     inline void* getMethodCallLinkInfoReturnLocation(MethodCallLinkInfo* methodCallLinkInfo)
 205     {
 206         return methodCallLinkInfo->callReturnLocation.executableAddress();
 207     }
 208
 209     inline unsigned getCallReturnOffset(CallReturnOffsetToBytecodeIndex* pc)
 210     {
 211         return pc->callReturnOffset;
 212     }
 213
 214     // Binary chop algorithm, calls valueAtPosition on pre-sorted elements in array,
 215     // compares result with key (KeyTypes should be comparable with '--', '<', '>').
 216     // Optimized for cases where the array contains the key, checked by assertions.
 217     template<typename ArrayType, typename KeyType, KeyType(*valueAtPosition)(ArrayType*)>
 218     inline ArrayType* binaryChop(ArrayType* array, size_t size, KeyType key)
 219     {
 220         // The array must contain at least one element (pre-condition, array does conatin key).
 221         // If the array only contains one element, no need to do the comparison.
 222         while (size > 1) {
 223             // Pick an element to check, half way through the array, and read the value.
 224             int pos = (size - 1) >> 1;
 225             KeyType val = valueAtPosition(&array[pos]);
 226
 227             // If the key matches, success!
 228             if (val == key)
 229                 return &array[pos];
 230             // The item we are looking for is smaller than the item being check; reduce the value of 'size',
 231             // chopping off the right hand half of the array.
 232             else if (key < val)
 233                 size = pos;
 234             // Discard all values in the left hand half of the array, up to and including the item at pos.
 235             else {
 236                 size -= (pos + 1);
 237                 array += (pos + 1);
 238             }
 239
 240             // 'size' should never reach zero.
 241             ASSERT(size);
 242         }
 243
 244         // If we reach this point we've chopped down to one element, no need to check it matches
 245         ASSERT(size == 1);
 246         ASSERT(key == valueAtPosition(&array[0]));
 247         return &array[0];
 248     }
 249 #endif
 250
 251     struct ExceptionInfo : FastAllocBase {
 252         Vector<ExpressionRangeInfo> m_expressionInfo;
 253         Vector<LineInfo> m_lineInfo;
 254         Vector<GetByIdExceptionInfo> m_getByIdExceptionInfo;
 255
 256 #if ENABLE(JIT)
 257         Vector<CallReturnOffsetToBytecodeIndex> m_callReturnIndexVector;
 258 #endif
 259     };
 260
 261     class CodeBlock : public FastAllocBase {
 262         friend class JIT;
 263     protected:
 264         CodeBlock(ScriptExecutable* ownerExecutable, CodeType, PassRefPtr<SourceProvider>, unsigned sourceOffset, SymbolTable* symbolTable);
 265     public:
 266         virtual ~CodeBlock();
 267
 268         void markAggregate(MarkStack&);
 269         void refStructures(Instruction* vPC) const;
 270         void derefStructures(Instruction* vPC) const;
 271 #if ENABLE(JIT_OPTIMIZE_CALL)
 272         void unlinkCallers();
 273 #endif
 274
 275         static void dumpStatistics();
 276
 277 #if !defined(NDEBUG) || ENABLE_OPCODE_SAMPLING
 278         void dump(ExecState*) const;
 279         void printStructures(const Instruction*) const;
 280         void printStructure(const char* name, const Instruction*, int operand) const;
 281 #endif
 282
 283         inline bool isKnownNotImmediate(int index)
 284         {
 285             if (index == m_thisRegister)
 286                 return true;
 287
 288             if (isConstantRegisterIndex(index))
 289                 return getConstant(index).isCell();
 290
 291             return false;
 292         }
 293
 294         ALWAYS_INLINE bool isTemporaryRegisterIndex(int index)
 295         {
 296             return index >= m_numVars;
 297         }
 298
 299         HandlerInfo* handlerForBytecodeOffset(unsigned bytecodeOffset);
 300         int lineNumberForBytecodeOffset(CallFrame*, unsigned bytecodeOffset);
 301         int expressionRangeForBytecodeOffset(CallFrame*, unsigned bytecodeOffset, int& divot, int& startOffset, int& endOffset);
 302         bool getByIdExceptionInfoForBytecodeOffset(CallFrame*, unsigned bytecodeOffset, OpcodeID&);
 303
 304 #if ENABLE(JIT)
 305         void addCaller(CallLinkInfo* caller)
 306         {
 307             caller->callee = this;
 308             caller->position = m_linkedCallerList.size();
 309             m_linkedCallerList.append(caller);
 310         }
 311
 312         void removeCaller(CallLinkInfo* caller)
 313         {
 314             unsigned pos = caller->position;
 315             unsigned lastPos = m_linkedCallerList.size() - 1;
 316
 317             if (pos != lastPos) {
 318                 m_linkedCallerList[pos] = m_linkedCallerList[lastPos];
 319                 m_linkedCallerList[pos]->position = pos;
 320             }
 321             m_linkedCallerList.shrink(lastPos);
 322         }
 323
 324         StructureStubInfo& getStubInfo(ReturnAddressPtr returnAddress)
 325         {
 326             return *(binaryChop<StructureStubInfo, void*, getStructureStubInfoReturnLocation>(m_structureStubInfos.begin(), m_structureStubInfos.size(), returnAddress.value()));
 327         }
 328
 329         CallLinkInfo& getCallLinkInfo(ReturnAddressPtr returnAddress)
 330         {
 331             return *(binaryChop<CallLinkInfo, void*, getCallLinkInfoReturnLocation>(m_callLinkInfos.begin(), m_callLinkInfos.size(), returnAddress.value()));
 332         }
 333
 334         MethodCallLinkInfo& getMethodCallLinkInfo(ReturnAddressPtr returnAddress)
 335         {
 336             return *(binaryChop<MethodCallLinkInfo, void*, getMethodCallLinkInfoReturnLocation>(m_methodCallLinkInfos.begin(), m_methodCallLinkInfos.size(), returnAddress.value()));
 337         }
 338
 339         unsigned getBytecodeIndex(CallFrame* callFrame, ReturnAddressPtr returnAddress)
 340         {
 341             reparseForExceptionInfoIfNecessary(callFrame);
 342             return binaryChop<CallReturnOffsetToBytecodeIndex, unsigned, getCallReturnOffset>(callReturnIndexVector().begin(), callReturnIndexVector().size(), ownerExecutable()->generatedJITCode().offsetOf(returnAddress.value()))->bytecodeIndex;
 343         }
 344
 345         bool functionRegisterForBytecodeOffset(unsigned bytecodeOffset, int& functionRegisterIndex);
 346 #endif
 347
 348         void setIsNumericCompareFunction(bool isNumericCompareFunction) { m_isNumericCompareFunction = isNumericCompareFunction; }
 349         bool isNumericCompareFunction() { return m_isNumericCompareFunction; }
 350
 351         Vector<Instruction>& instructions() { return m_instructions; }
 352         void discardBytecode() { m_instructions.clear(); }
 353
 354 #ifndef NDEBUG
 355         unsigned instructionCount() { return m_instructionCount; }
 356         void setInstructionCount(unsigned instructionCount) { m_instructionCount = instructionCount; }
 357 #endif
 358
 359 #if ENABLE(JIT)
 360         JITCode& getJITCode() { return ownerExecutable()->generatedJITCode(); }
 361         ExecutablePool* executablePool() { return ownerExecutable()->getExecutablePool(); }
 362 #endif
 363
 364         ScriptExecutable* ownerExecutable() const { return m_ownerExecutable; }
 365
 366         void setGlobalData(JSGlobalData* globalData) { m_globalData = globalData; }
 367
 368         void setThisRegister(int thisRegister) { m_thisRegister = thisRegister; }
 369         int thisRegister() const { return m_thisRegister; }
 370
 371         void setNeedsFullScopeChain(bool needsFullScopeChain) { m_needsFullScopeChain = needsFullScopeChain; }
 372         bool needsFullScopeChain() const { return m_needsFullScopeChain; }
 373         void setUsesEval(bool usesEval) { m_usesEval = usesEval; }
 374         bool usesEval() const { return m_usesEval; }
 375         void setUsesArguments(bool usesArguments) { m_usesArguments = usesArguments; }
 376         bool usesArguments() const { return m_usesArguments; }
 377
 378         CodeType codeType() const { return m_codeType; }
 379
 380         SourceProvider* source() const { return m_source.get(); }
 381         unsigned sourceOffset() const { return m_sourceOffset; }
 382
 383         size_t numberOfJumpTargets() const { return m_jumpTargets.size(); }
 384         void addJumpTarget(unsigned jumpTarget) { m_jumpTargets.append(jumpTarget); }
 385         unsigned jumpTarget(int index) const { return m_jumpTargets[index]; }
 386         unsigned lastJumpTarget() const { return m_jumpTargets.last(); }
 387
 388 #if !ENABLE(JIT)
 389         void addPropertyAccessInstruction(unsigned propertyAccessInstruction) { m_propertyAccessInstructions.append(propertyAccessInstruction); }
 390         void addGlobalResolveInstruction(unsigned globalResolveInstruction) { m_globalResolveInstructions.append(globalResolveInstruction); }
 391         bool hasGlobalResolveInstructionAtBytecodeOffset(unsigned bytecodeOffset);
 392 #else
 393         size_t numberOfStructureStubInfos() const { return m_structureStubInfos.size(); }
 394         void addStructureStubInfo(const StructureStubInfo& stubInfo) { m_structureStubInfos.append(stubInfo); }
 395         StructureStubInfo& structureStubInfo(int index) { return m_structureStubInfos[index]; }
 396
 397         void addGlobalResolveInfo(unsigned globalResolveInstruction) { m_globalResolveInfos.append(GlobalResolveInfo(globalResolveInstruction)); }
 398         GlobalResolveInfo& globalResolveInfo(int index) { return m_globalResolveInfos[index]; }
 399         bool hasGlobalResolveInfoAtBytecodeOffset(unsigned bytecodeOffset);
 400
 401         size_t numberOfCallLinkInfos() const { return m_callLinkInfos.size(); }
 402         void addCallLinkInfo() { m_callLinkInfos.append(CallLinkInfo()); }
 403         CallLinkInfo& callLinkInfo(int index) { return m_callLinkInfos[index]; }
 404
 405         void addMethodCallLinkInfos(unsigned n) { m_methodCallLinkInfos.grow(n); }
 406         MethodCallLinkInfo& methodCallLinkInfo(int index) { return m_methodCallLinkInfos[index]; }
 407
 408         void addFunctionRegisterInfo(unsigned bytecodeOffset, int functionIndex) { createRareDataIfNecessary(); m_rareData->m_functionRegisterInfos.append(FunctionRegisterInfo(bytecodeOffset, functionIndex)); }
 409 #endif
 410
 411         // Exception handling support
 412
 413         size_t numberOfExceptionHandlers() const { return m_rareData ? m_rareData->m_exceptionHandlers.size() : 0; }
 414         void addExceptionHandler(const HandlerInfo& hanler) { createRareDataIfNecessary(); return m_rareData->m_exceptionHandlers.append(hanler); }
 415         HandlerInfo& exceptionHandler(int index) { ASSERT(m_rareData); return m_rareData->m_exceptionHandlers[index]; }
 416
 417         bool hasExceptionInfo() const { return m_exceptionInfo; }
 418         void clearExceptionInfo() { m_exceptionInfo.clear(); }
 419         ExceptionInfo* extractExceptionInfo() { ASSERT(m_exceptionInfo); return m_exceptionInfo.release(); }
 420
 421         void addExpressionInfo(const ExpressionRangeInfo& expressionInfo) { ASSERT(m_exceptionInfo); m_exceptionInfo->m_expressionInfo.append(expressionInfo); }
 422         void addGetByIdExceptionInfo(const GetByIdExceptionInfo& info) { ASSERT(m_exceptionInfo); m_exceptionInfo->m_getByIdExceptionInfo.append(info); }
 423
 424         size_t numberOfLineInfos() const { ASSERT(m_exceptionInfo); return m_exceptionInfo->m_lineInfo.size(); }
 425         void addLineInfo(const LineInfo& lineInfo) { ASSERT(m_exceptionInfo); m_exceptionInfo->m_lineInfo.append(lineInfo); }
 426         LineInfo& lastLineInfo() { ASSERT(m_exceptionInfo); return m_exceptionInfo->m_lineInfo.last(); }
 427
 428 #if ENABLE(JIT)
 429         Vector<CallReturnOffsetToBytecodeIndex>& callReturnIndexVector() { ASSERT(m_exceptionInfo); return m_exceptionInfo->m_callReturnIndexVector; }
 430 #endif
 431
 432         // Constant Pool
 433
 434         size_t numberOfIdentifiers() const { return m_identifiers.size(); }
 435         void addIdentifier(const Identifier& i) { return m_identifiers.append(i); }
 436         Identifier& identifier(int index) { return m_identifiers[index]; }
 437
 438         size_t numberOfConstantRegisters() const { return m_constantRegisters.size(); }
 439         void addConstantRegister(const Register& r) { return m_constantRegisters.append(r); }
 440         Register& constantRegister(int index) { return m_constantRegisters[index - FirstConstantRegisterIndex]; }
 441         ALWAYS_INLINE bool isConstantRegisterIndex(int index) const { return index >= FirstConstantRegisterIndex; }
 442         ALWAYS_INLINE JSValue getConstant(int index) const { return m_constantRegisters[index - FirstConstantRegisterIndex].jsValue(); }
 443
 444         unsigned addFunctionDecl(NonNullPassRefPtr<FunctionExecutable> n) { unsigned size = m_functionDecls.size(); m_functionDecls.append(n); return size; }
 445         FunctionExecutable* functionDecl(int index) { return m_functionDecls[index].get(); }
 446         int numberOfFunctionDecls() { return m_functionDecls.size(); }
 447         unsigned addFunctionExpr(NonNullPassRefPtr<FunctionExecutable> n) { unsigned size = m_functionExprs.size(); m_functionExprs.append(n); return size; }
 448         FunctionExecutable* functionExpr(int index) { return m_functionExprs[index].get(); }
 449
 450         unsigned addRegExp(RegExp* r) { createRareDataIfNecessary(); unsigned size = m_rareData->m_regexps.size(); m_rareData->m_regexps.append(r); return size; }
 451         RegExp* regexp(int index) const { ASSERT(m_rareData); return m_rareData->m_regexps[index].get(); }
 452
 453
 454         // Jump Tables
 455
 456         size_t numberOfImmediateSwitchJumpTables() const { return m_rareData ? m_rareData->m_immediateSwitchJumpTables.size() : 0; }
 457         SimpleJumpTable& addImmediateSwitchJumpTable() { createRareDataIfNecessary(); m_rareData->m_immediateSwitchJumpTables.append(SimpleJumpTable()); return m_rareData->m_immediateSwitchJumpTables.last(); }
 458         SimpleJumpTable& immediateSwitchJumpTable(int tableIndex) { ASSERT(m_rareData); return m_rareData->m_immediateSwitchJumpTables[tableIndex]; }
 459
 460         size_t numberOfCharacterSwitchJumpTables() const { return m_rareData ? m_rareData->m_characterSwitchJumpTables.size() : 0; }
 461         SimpleJumpTable& addCharacterSwitchJumpTable() { createRareDataIfNecessary(); m_rareData->m_characterSwitchJumpTables.append(SimpleJumpTable()); return m_rareData->m_characterSwitchJumpTables.last(); }
 462         SimpleJumpTable& characterSwitchJumpTable(int tableIndex) { ASSERT(m_rareData); return m_rareData->m_characterSwitchJumpTables[tableIndex]; }
 463
 464         size_t numberOfStringSwitchJumpTables() const { return m_rareData ? m_rareData->m_stringSwitchJumpTables.size() : 0; }
 465         StringJumpTable& addStringSwitchJumpTable() { createRareDataIfNecessary(); m_rareData->m_stringSwitchJumpTables.append(StringJumpTable()); return m_rareData->m_stringSwitchJumpTables.last(); }
 466         StringJumpTable& stringSwitchJumpTable(int tableIndex) { ASSERT(m_rareData); return m_rareData->m_stringSwitchJumpTables[tableIndex]; }
 467
 468
 469         SymbolTable* symbolTable() { return m_symbolTable; }
 470         SharedSymbolTable* sharedSymbolTable() { ASSERT(m_codeType == FunctionCode); return static_cast<SharedSymbolTable*>(m_symbolTable); }
 471
 472         EvalCodeCache& evalCodeCache() { createRareDataIfNecessary(); return m_rareData->m_evalCodeCache; }
 473
 474         void shrinkToFit();
 475
 476         // FIXME: Make these remaining members private.
 477
 478         int m_numCalleeRegisters;
 479         int m_numVars;
 480         int m_numParameters;
 481
 482     private:
 483 #if !defined(NDEBUG) || ENABLE(OPCODE_SAMPLING)
 484         void dump(ExecState*, const Vector<Instruction>::const_iterator& begin, Vector<Instruction>::const_iterator&) const;
 485
 486         CString registerName(ExecState*, int r) const;
 487         void printUnaryOp(ExecState*, int location, Vector<Instruction>::const_iterator&, const char* op) const;
 488         void printBinaryOp(ExecState*, int location, Vector<Instruction>::const_iterator&, const char* op) const;
 489         void printConditionalJump(ExecState*, const Vector<Instruction>::const_iterator&, Vector<Instruction>::const_iterator&, int location, const char* op) const;
 490         void printGetByIdOp(ExecState*, int location, Vector<Instruction>::const_iterator&, const char* op) const;
 491         void printPutByIdOp(ExecState*, int location, Vector<Instruction>::const_iterator&, const char* op) const;
 492 #endif
 493
 494         void reparseForExceptionInfoIfNecessary(CallFrame*);
 495
 496         void createRareDataIfNecessary()
 497         {
 498             if (!m_rareData)
 499                 m_rareData.set(new RareData);
 500         }
 501
 502         ScriptExecutable* m_ownerExecutable;
 503         JSGlobalData* m_globalData;
 504
 505         Vector<Instruction> m_instructions;
 506 #ifndef NDEBUG
 507         unsigned m_instructionCount;
 508 #endif
 509
 510         int m_thisRegister;
 511
 512         bool m_needsFullScopeChain;
 513         bool m_usesEval;
 514         bool m_usesArguments;
 515         bool m_isNumericCompareFunction;
 516
 517         CodeType m_codeType;
 518
 519         RefPtr<SourceProvider> m_source;
 520         unsigned m_sourceOffset;
 521
 522 #if !ENABLE(JIT)
 523         Vector<unsigned> m_propertyAccessInstructions;
 524         Vector<unsigned> m_globalResolveInstructions;
 525 #else
 526         Vector<StructureStubInfo> m_structureStubInfos;
 527         Vector<GlobalResolveInfo> m_globalResolveInfos;
 528         Vector<CallLinkInfo> m_callLinkInfos;
 529         Vector<MethodCallLinkInfo> m_methodCallLinkInfos;
 530         Vector<CallLinkInfo*> m_linkedCallerList;
 531 #endif
 532
 533         Vector<unsigned> m_jumpTargets;
 534
 535         // Constant Pool
 536         Vector<Identifier> m_identifiers;
 537         Vector<Register> m_constantRegisters;
 538         Vector<RefPtr<FunctionExecutable> > m_functionDecls;
 539         Vector<RefPtr<FunctionExecutable> > m_functionExprs;
 540
 541         SymbolTable* m_symbolTable;
 542
 543         OwnPtr<ExceptionInfo> m_exceptionInfo;
 544
 545         struct RareData : FastAllocBase {
 546             Vector<HandlerInfo> m_exceptionHandlers;
 547
 548             // Rare Constants
 549             Vector<RefPtr<RegExp> > m_regexps;
 550
 551             // Jump Tables
 552             Vector<SimpleJumpTable> m_immediateSwitchJumpTables;
 553             Vector<SimpleJumpTable> m_characterSwitchJumpTables;
 554             Vector<StringJumpTable> m_stringSwitchJumpTables;
 555
 556             EvalCodeCache m_evalCodeCache;
 557
 558 #if ENABLE(JIT)
 559             Vector<FunctionRegisterInfo> m_functionRegisterInfos;
 560 #endif
 561         };
 562         OwnPtr<RareData> m_rareData;
 563     };
 564
 565     // Program code is not marked by any function, so we make the global object
 566     // responsible for marking it.
 567
 568     class GlobalCodeBlock : public CodeBlock {
 569     public:
 570         GlobalCodeBlock(ScriptExecutable* ownerExecutable, CodeType codeType, PassRefPtr<SourceProvider> sourceProvider, unsigned sourceOffset, JSGlobalObject* globalObject)
 571             : CodeBlock(ownerExecutable, codeType, sourceProvider, sourceOffset, &m_unsharedSymbolTable)
 572             , m_globalObject(globalObject)
 573         {
 574             m_globalObject->codeBlocks().add(this);
 575         }
 576
 577         ~GlobalCodeBlock()
 578         {
 579             if (m_globalObject)
 580                 m_globalObject->codeBlocks().remove(this);
 581         }
 582
 583         void clearGlobalObject() { m_globalObject = 0; }
 584
 585     private:
 586         JSGlobalObject* m_globalObject; // For program and eval nodes, the global object that marks the constant pool.
 587         SymbolTable m_unsharedSymbolTable;
 588     };
 589
 590     class ProgramCodeBlock : public GlobalCodeBlock {
 591     public:
 592         ProgramCodeBlock(ProgramExecutable* ownerExecutable, CodeType codeType, JSGlobalObject* globalObject, PassRefPtr<SourceProvider> sourceProvider)
 593             : GlobalCodeBlock(ownerExecutable, codeType, sourceProvider, 0, globalObject)
 594         {
 595         }
 596     };
 597
 598     class EvalCodeBlock : public GlobalCodeBlock {
 599     public:
 600         EvalCodeBlock(EvalExecutable* ownerExecutable, JSGlobalObject* globalObject, PassRefPtr<SourceProvider> sourceProvider, int baseScopeDepth)
 601             : GlobalCodeBlock(ownerExecutable, EvalCode, sourceProvider, 0, globalObject)
 602             , m_baseScopeDepth(baseScopeDepth)
 603         {
 604         }
 605
 606         int baseScopeDepth() const { return m_baseScopeDepth; }
 607
 608         const Identifier& variable(unsigned index) { return m_variables[index]; }
 609         unsigned numVariables() { return m_variables.size(); }
 610         void adoptVariables(Vector<Identifier>& variables)
 611         {
 612             ASSERT(m_variables.isEmpty());
 613             m_variables.swap(variables);
 614         }
 615
 616     private:
 617         int m_baseScopeDepth;
 618         Vector<Identifier> m_variables;
 619     };
 620
 621     class FunctionCodeBlock : public CodeBlock {
 622     public:
 623         // Rather than using the usual RefCounted::create idiom for SharedSymbolTable we just use new
 624         // as we need to initialise the CodeBlock before we could initialise any RefPtr to hold the shared
 625         // symbol table, so we just pass as a raw pointer with a ref count of 1.  We then manually deref
 626         // in the destructor.
 627         FunctionCodeBlock(FunctionExecutable* ownerExecutable, CodeType codeType, PassRefPtr<SourceProvider> sourceProvider, unsigned sourceOffset)
 628             : CodeBlock(ownerExecutable, codeType, sourceProvider, sourceOffset, new SharedSymbolTable)
 629         {
 630         }
 631         ~FunctionCodeBlock()
 632         {
 633             sharedSymbolTable()->deref();
 634         }
 635     };
 636
 637     inline Register& ExecState::r(int index)
 638     {
 639         CodeBlock* codeBlock = this->codeBlock();
 640         if (codeBlock->isConstantRegisterIndex(index))
 641             return codeBlock->constantRegister(index);
 642         return this[index];
 643     }
 644
 645 } // namespace JSC
 646
 647 #endif // CodeBlock_h