1. 28 Mar, 2013 1 commit
  2. 27 Mar, 2013 1 commit
  3. 07 Mar, 2013 1 commit
    • ggaren@apple.com's avatar
      REGRESSION (r143759): 40% JSBench regression, 20% Octane/closure regression,... · 9b77c40d
      ggaren@apple.com authored
      REGRESSION (r143759): 40% JSBench regression, 20% Octane/closure regression, 40% Octane/jquery regression, 2% Octane regression
      https://bugs.webkit.org/show_bug.cgi?id=111797
      
      Reviewed by Oliver Hunt.
      
      The bot's testing configuration stresses the cache's starting guess
      of 1MB.
      
      This patch removes any starting guess, and just uses wall clock time
      to discover the initial working set size of an app, in code size.
      
      * runtime/CodeCache.cpp:
      (JSC::CodeCacheMap::pruneSlowCase): Update our timer as we go.
      
      Also fixed a bug where pruning from 0 to 0 would hang -- that case is
      a possibility now that we start with a capacity of 0.
      
      * runtime/CodeCache.h:
      (CodeCacheMap):
      (JSC::CodeCacheMap::CodeCacheMap):
      (JSC::CodeCacheMap::add):
      (JSC::CodeCacheMap::prune): Don't prune if we're in the middle of
      discovering the working set size of an app, in code size.
      
      
      git-svn-id: http://svn.webkit.org/repository/webkit/trunk@145171 268f45cc-cd09-0410-ab3c-d52691b4dbfc
      9b77c40d
  4. 06 Mar, 2013 1 commit
    • oliver@apple.com's avatar
      Bring back eager resolution of function scoped variables · 75f804e0
      oliver@apple.com authored
      https://bugs.webkit.org/show_bug.cgi?id=111497
      
      Reviewed by Geoffrey Garen.
      
      This reverts the get/put_scoped_var part of the great non-local
      variable resolution refactoring.  This still leaves all the lazy
      variable resolution logic as it's necessary for global property
      resolution, and i don't want to make the patch bigger than it
      already is.
      
      * bytecode/CodeBlock.cpp:
      (JSC::CodeBlock::dumpBytecode):
      (JSC::CodeBlock::CodeBlock):
      * bytecode/CodeBlock.h:
      (CodeBlock):
      * bytecode/Opcode.h:
      (JSC):
      (JSC::padOpcodeName):
      * bytecode/UnlinkedCodeBlock.cpp:
      (JSC::generateFunctionCodeBlock):
      (JSC::UnlinkedFunctionExecutable::codeBlockFor):
      (JSC::UnlinkedCodeBlock::UnlinkedCodeBlock):
      * bytecode/UnlinkedCodeBlock.h:
      (JSC):
      (UnlinkedFunctionExecutable):
      (UnlinkedCodeBlock):
      (JSC::UnlinkedCodeBlock::usesGlobalObject):
      (JSC::UnlinkedCodeBlock::setGlobalObjectRegister):
      (JSC::UnlinkedCodeBlock::globalObjectRegister):
      * bytecompiler/BytecodeGenerator.cpp:
      (JSC::ResolveResult::checkValidity):
      (JSC::BytecodeGenerator::BytecodeGenerator):
      (JSC::BytecodeGenerator::emitLoadGlobalObject):
      (JSC):
      (JSC::BytecodeGenerator::resolve):
      (JSC::BytecodeGenerator::resolveConstDecl):
      (JSC::BytecodeGenerator::emitResolve):
      (JSC::BytecodeGenerator::emitResolveBase):
      (JSC::BytecodeGenerator::emitResolveBaseForPut):
      (JSC::BytecodeGenerator::emitResolveWithBaseForPut):
      (JSC::BytecodeGenerator::emitResolveWithThis):
      (JSC::BytecodeGenerator::emitGetStaticVar):
      (JSC::BytecodeGenerator::emitPutStaticVar):
      * bytecompiler/BytecodeGenerator.h:
      (JSC::ResolveResult::lexicalResolve):
      (JSC::ResolveResult::isStatic):
      (JSC::ResolveResult::depth):
      (JSC::ResolveResult::index):
      (ResolveResult):
      (JSC::ResolveResult::ResolveResult):
      (BytecodeGenerator):
      * bytecompiler/NodesCodegen.cpp:
      (JSC::ResolveNode::isPure):
      (JSC::FunctionCallResolveNode::emitBytecode):
      (JSC::PostfixNode::emitResolve):
      (JSC::TypeOfResolveNode::emitBytecode):
      (JSC::PrefixNode::emitResolve):
      (JSC::ReadModifyResolveNode::emitBytecode):
      (JSC::AssignResolveNode::emitBytecode):
      (JSC::ConstDeclNode::emitCodeSingle):
      * dfg/DFGByteCodeParser.cpp:
      (JSC::DFG::ByteCodeParser::parseBlock):
      * dfg/DFGCapabilities.cpp:
      (JSC::DFG::debugFail):
      * dfg/DFGCapabilities.h:
      (JSC::DFG::canCompileOpcode):
      (JSC::DFG::canInlineOpcode):
      * jit/JIT.cpp:
      (JSC::JIT::privateCompileMainPass):
      * jit/JIT.h:
      (JIT):
      * jit/JITPropertyAccess.cpp:
      (JSC::JIT::emit_op_get_scoped_var):
      (JSC):
      (JSC::JIT::emit_op_put_scoped_var):
      * jit/JITPropertyAccess32_64.cpp:
      (JSC::JIT::emit_op_get_scoped_var):
      (JSC):
      (JSC::JIT::emit_op_put_scoped_var):
      * llint/LowLevelInterpreter32_64.asm:
      * llint/LowLevelInterpreter64.asm:
      * runtime/CodeCache.cpp:
      (JSC::CodeCache::getCodeBlock):
      (JSC::CodeCache::getProgramCodeBlock):
      (JSC::CodeCache::getEvalCodeBlock):
      * runtime/CodeCache.h:
      (JSC):
      (CodeCache):
      * runtime/Executable.cpp:
      (JSC::EvalExecutable::compileInternal):
      (JSC::FunctionExecutable::produceCodeBlockFor):
      * runtime/JSGlobalObject.cpp:
      (JSC::JSGlobalObject::createEvalCodeBlock):
      * runtime/JSGlobalObject.h:
      (JSGlobalObject):
      * runtime/Options.cpp:
      (JSC::Options::initialize):
      
      git-svn-id: http://svn.webkit.org/repository/webkit/trunk@145000 268f45cc-cd09-0410-ab3c-d52691b4dbfc
      75f804e0
  5. 25 Feb, 2013 1 commit
    • ggaren@apple.com's avatar
      Do one lookup per code cache insertion instead of two · 55cf8267
      ggaren@apple.com authored
      https://bugs.webkit.org/show_bug.cgi?id=110674
      
      Reviewed by Sam Weinig.
      
      Deployed the idiomatic "add null value" trick to avoid a second hash
      lookup when inserting an item.
      
      * runtime/CodeCache.cpp:
      (JSC::CodeCacheMap::pruneSlowCase): Factored this into a helper function
      to improve clarity and get some code off the hot path.
      
      (JSC::CodeCache::getCodeBlock):
      (JSC::CodeCache::getFunctionExecutableFromGlobalCode): Use the add() API
      to avoid two hash lookups. Be sure to remove items if parsing fails,
      otherwise we'll leave nulls in the table. (I'm guessing that caching parse
      errors is not a win.)
      
      * runtime/CodeCache.h:
      (JSC::SourceCodeValue::SourceCodeValue):
      (CodeCacheMap):
      (JSC::CodeCacheMap::add): Combined find() and set() into add().
      
      (JSC::CodeCacheMap::remove):
      (JSC::CodeCacheMap::age):
      (JSC::CodeCacheMap::prune): Refactored to support above changes.
      
      
      git-svn-id: http://svn.webkit.org/repository/webkit/trunk@143949 268f45cc-cd09-0410-ab3c-d52691b4dbfc
      55cf8267
  6. 22 Feb, 2013 1 commit
    • ggaren@apple.com's avatar
      Code cache size should adapt to workload · 275634c8
      ggaren@apple.com authored
      https://bugs.webkit.org/show_bug.cgi?id=110560
      
      Reviewed by Antti Koivisto.
      
      (*) 5% PLT arithmetic mean speedup
      (*) 10% PLT geometric mean speedup
      (*) 3.4X microbenchmark speedup
      (*) Reduces initial cache capacity by 16X
      
      * runtime/CodeCache.cpp:
      (JSC::CodeCache::CodeCache): Updated for interface change.
      
      * runtime/CodeCache.h:
      (JSC::SourceCodeValue::SourceCodeValue):
      (SourceCodeValue): Turned the cache value into a struct so it can track its age.
      
      (CodeCacheMap):
      (JSC::CodeCacheMap::CodeCacheMap):
      (JSC::CodeCacheMap::find):
      (JSC::CodeCacheMap::set):
      (JSC::CodeCacheMap::clear):
      (JSC::CodeCacheMap::pruneIfNeeded):
      (CodeCache): Grow and shrink in response to usage.
      
      
      git-svn-id: http://svn.webkit.org/repository/webkit/trunk@143759 268f45cc-cd09-0410-ab3c-d52691b4dbfc
      275634c8
  7. 19 Feb, 2013 3 commits
    • ggaren@apple.com's avatar
      Unreviewed, rolling in r143348. · 37030790
      ggaren@apple.com authored
      http://trac.webkit.org/changeset/143348
      https://bugs.webkit.org/show_bug.cgi?id=110242
      
      The bug was that isEmptyValue() was returning true for the deleted value.
      Fixed this and simplified things further by delegating to m_sourceCode
      for both isNull() and isHashTableDeletedValue(), so they can't be out of
      sync.
      
      * runtime/CodeCache.cpp:
      (JSC::CodeCache::getFunctionExecutableFromGlobalCode):
      * runtime/CodeCache.h:
      (JSC::SourceCodeKey::SourceCodeKey):
      (JSC::SourceCodeKey::isHashTableDeletedValue):
      (JSC::SourceCodeKey::hash):
      (JSC::SourceCodeKey::length):
      (JSC::SourceCodeKey::isNull):
      (JSC::SourceCodeKey::operator==):
      (SourceCodeKey):
      
      
      git-svn-id: http://svn.webkit.org/repository/webkit/trunk@143384 268f45cc-cd09-0410-ab3c-d52691b4dbfc
      37030790
    • commit-queue@webkit.org's avatar
      Unreviewed, rolling out r143348. · 61232230
      commit-queue@webkit.org authored
      http://trac.webkit.org/changeset/143348
      https://bugs.webkit.org/show_bug.cgi?id=110242
      
      "Caused a deleted value sentinel crash on the layout tests"
      (Requested by ggaren on #webkit).
      
      Patch by Sheriff Bot <webkit.review.bot@gmail.com> on 2013-02-19
      
      * runtime/CodeCache.cpp:
      (JSC::CodeCache::getFunctionExecutableFromGlobalCode):
      * runtime/CodeCache.h:
      (JSC::SourceCodeKey::SourceCodeKey):
      (JSC::SourceCodeKey::isHashTableDeletedValue):
      (JSC::SourceCodeKey::hash):
      (JSC::SourceCodeKey::length):
      (JSC::SourceCodeKey::isNull):
      (JSC::SourceCodeKey::operator==):
      (SourceCodeKey):
      
      git-svn-id: http://svn.webkit.org/repository/webkit/trunk@143366 268f45cc-cd09-0410-ab3c-d52691b4dbfc
      61232230
    • ggaren@apple.com's avatar
      Save space on keys in the CodeCache · de5cc65c
      ggaren@apple.com authored
      https://bugs.webkit.org/show_bug.cgi?id=110179
      
      Reviewed by Oliver Hunt.
      
      Share the SourceProvider's string instead of making our own copy. This
      chops off 16MB - 32MB from the CodeCache's memory footprint when full.
      (It's 16MB when the strings are LChar, and 32MB when they're UChar.)
      
      * runtime/CodeCache.cpp:
      (JSC::CodeCache::getFunctionExecutableFromGlobalCode):
      * runtime/CodeCache.h: Removed a defunct enum value.
      
      (JSC::SourceCodeKey::SourceCodeKey):
      (JSC::SourceCodeKey::isHashTableDeletedValue):
      (SourceCodeKey):
      (JSC::SourceCodeKey::hash):
      (JSC::SourceCodeKey::length):
      (JSC::SourceCodeKey::isNull):
      (JSC::SourceCodeKey::string):
      (JSC::SourceCodeKey::operator==): Store a SourceCode instead of a String
      so we can share our string with our SourceProvider. Cache our hash so
      we don't have to re-decode our string just to re-hash the table.
      
      
      git-svn-id: http://svn.webkit.org/repository/webkit/trunk@143348 268f45cc-cd09-0410-ab3c-d52691b4dbfc
      de5cc65c
  8. 17 Feb, 2013 1 commit
    • ggaren@apple.com's avatar
      Code cache should be explicit about what it caches · 818f283e
      ggaren@apple.com authored
      https://bugs.webkit.org/show_bug.cgi?id=110039
      
      Reviewed by Oliver Hunt.
      
      This patch makes the code cache more explicit in two ways:
      
      (1) The cache caches top-level scripts. Any sub-functions executed as a
      part of a script are cached with it and evicted with it.
      
      This simplifies things by eliminating out-of-band sub-function tracking,
      and fixes pathological cases where functions for live scripts would be
      evicted in favor of functions for dead scripts, and/or high probability
      functions executed early in script lifetime would be evicted in favor of
      low probability functions executed late in script lifetime, due to LRU.
      
      Statistical data from general browsing and PLT confirms that caching
      functions independently of scripts is not profitable.
      
      (2) The cache tracks script size, not script count.
      
      This reduces the worst-case cache size by a factor of infinity.
      
      Script size is a reasonable first-order estimate of in-memory footprint 
      for a cached script because there are no syntactic constructs that have
      super-linear memory footprint.
      
      * bytecode/UnlinkedCodeBlock.cpp:
      (JSC::generateFunctionCodeBlock): Moved this function out of the cache
      because it does not consult the cache, and is not managed by it.
      
      (JSC::UnlinkedFunctionExecutable::visitChildren): Visit our code blocks
      because they are strong references now, rather than weak, a la (1).
      
      (JSC::UnlinkedFunctionExecutable::codeBlockFor): Updated for interface changes.
      
      * bytecode/UnlinkedCodeBlock.h:
      (UnlinkedFunctionExecutable):
      (UnlinkedFunctionCodeBlock): Strong now, not weak, a la (1).
      
      * runtime/CodeCache.cpp:
      (JSC::CodeCache::CodeCache):
      * runtime/CodeCache.h:
      (JSC::SourceCodeKey::length):
      (SourceCodeKey):
      (CodeCacheMap):
      (JSC::CodeCacheMap::CodeCacheMap):
      (JSC::CodeCacheMap::find):
      (JSC::CodeCacheMap::set):
      (JSC::CodeCacheMap::clear):
      (CodeCache):
      (JSC::CodeCache::clear): Removed individual function tracking, due to (1).
      Added explicit character counting, for (2).
      
      You might think 16000000 characters is a lot. It is. But this patch
      didn't establish that limit -- it just took the existing limit and
      made it more visible. I intend to reduce the size of the cache in a
      future patch.
      
      
      git-svn-id: http://svn.webkit.org/repository/webkit/trunk@143133 268f45cc-cd09-0410-ab3c-d52691b4dbfc
      818f283e
  9. 14 Feb, 2013 1 commit
    • ggaren@apple.com's avatar
      Merged the global function cache into the source code cache · 036ef312
      ggaren@apple.com authored
      https://bugs.webkit.org/show_bug.cgi?id=108660
      
      Reviewed by Sam Weinig.
      
      This has a few benefits:
      
          (*) Saves a few kB by removing a second cache data structure.
      
          (*) Reduces the worst case memory usage of the cache by 1.75X. (Heavy
          use of 'new Function' and other techniques could cause us to fill
          both root caches, and they didn't trade off against each other.)
      
          (*) Paves the way for future improvements based on a non-trivial
          cache key (for example, shrinkable pointer to the key string, and
          more precise cache size accounting).
      
      Also cleaned up the cache implementation and simplified it a bit.
      
      * heap/Handle.h:
      (HandleBase):
      * heap/Strong.h:
      (Strong): Build!
      
      * runtime/CodeCache.cpp:
      (JSC):
      (JSC::CodeCache::getCodeBlock):
      (JSC::CodeCache::generateFunctionCodeBlock):
      (JSC::CodeCache::getFunctionExecutableFromGlobalCode):
      (JSC::CodeCache::usedFunctionCode): Updated for three interface changes:
      
          (*) SourceCodeKey is a class, not a pair.
      
          (*) Table values are abstract pointers, since they can be executables
          or code blocks. (In a future patch, I'd like to change this so we
          always store only code blocks. But that's too much for one patch.)
      
          (*) The cache function is named "set" because it always overwrites
          unconditionally.
      
      * runtime/CodeCache.h:
      (CacheMap):
      (JSC::CacheMap::find):
      (JSC::CacheMap::set):
      (JSC::CacheMap::clear): Added support for specifying hash traits, so we
      can use a SourceCodeKey.
      
      Removed side table and random number generator to save space and reduce
      complexity. Hash tables are already random, so we don't need another source
      of randomness.
      
      (SourceCodeKey):
      (JSC::SourceCodeKey::SourceCodeKey):
      (JSC::SourceCodeKey::isHashTableDeletedValue):
      (JSC::SourceCodeKey::hash):
      (JSC::SourceCodeKey::isNull):
      (JSC::SourceCodeKey::operator==):
      (JSC::SourceCodeKeyHash::hash):
      (JSC::SourceCodeKeyHash::equal):
      (SourceCodeKeyHash):
      (SourceCodeKeyHashTraits):
      (JSC::SourceCodeKeyHashTraits::isEmptyValue): A SourceCodeKey is just a
      fancy triplet: source code string; function name (or null, for non-functions);
      and flags. Flags and function name distinguish between functions and programs
      with identical code, so they can live in the same cache.
      
      I chose to use the source code string as the primary hashing reference
      because it's likely to be unique. We can use profiling to choose another
      technique in future, if collisions between functions and programs prove
      to be hot. I suspect they won't.
      
      (JSC::CodeCache::clear):
      (CodeCache): Removed the second cache.
      
      * heap/Handle.h:
      (HandleBase):
      * heap/Strong.h:
      (Strong):
      * runtime/CodeCache.cpp:
      (JSC):
      (JSC::CodeCache::getCodeBlock):
      (JSC::CodeCache::generateFunctionCodeBlock):
      (JSC::CodeCache::getFunctionExecutableFromGlobalCode):
      (JSC::CodeCache::usedFunctionCode):
      * runtime/CodeCache.h:
      (JSC):
      (CacheMap):
      (JSC::CacheMap::find):
      (JSC::CacheMap::set):
      (JSC::CacheMap::clear):
      (SourceCodeKey):
      (JSC::SourceCodeKey::SourceCodeKey):
      (JSC::SourceCodeKey::isHashTableDeletedValue):
      (JSC::SourceCodeKey::hash):
      (JSC::SourceCodeKey::isNull):
      (JSC::SourceCodeKey::operator==):
      (JSC::SourceCodeKeyHash::hash):
      (JSC::SourceCodeKeyHash::equal):
      (SourceCodeKeyHash):
      (SourceCodeKeyHashTraits):
      (JSC::SourceCodeKeyHashTraits::isEmptyValue):
      (JSC::CodeCache::clear):
      (CodeCache):
      
      
      git-svn-id: http://svn.webkit.org/repository/webkit/trunk@142966 268f45cc-cd09-0410-ab3c-d52691b4dbfc
      036ef312
  10. 23 Jan, 2013 1 commit
    • oliver@apple.com's avatar
      Harden JSC a bit with RELEASE_ASSERT · 903b0c0b
      oliver@apple.com authored
      https://bugs.webkit.org/show_bug.cgi?id=107766
      
      Reviewed by Mark Hahnenberg.
      
      Went through and replaced a pile of ASSERTs that were covering
      significantly important details (bounds checks, etc) where
      having the checks did not impact release performance in any
      measurable way.
      
      * API/JSContextRef.cpp:
      (JSContextCreateBacktrace):
      * assembler/MacroAssembler.h:
      (JSC::MacroAssembler::branchAdd32):
      (JSC::MacroAssembler::branchMul32):
      * bytecode/CodeBlock.cpp:
      (JSC::CodeBlock::dumpBytecode):
      (JSC::CodeBlock::handlerForBytecodeOffset):
      (JSC::CodeBlock::lineNumberForBytecodeOffset):
      (JSC::CodeBlock::bytecodeOffset):
      * bytecode/CodeBlock.h:
      (JSC::CodeBlock::bytecodeOffsetForCallAtIndex):
      (JSC::CodeBlock::bytecodeOffset):
      (JSC::CodeBlock::exceptionHandler):
      (JSC::CodeBlock::codeOrigin):
      (JSC::CodeBlock::immediateSwitchJumpTable):
      (JSC::CodeBlock::characterSwitchJumpTable):
      (JSC::CodeBlock::stringSwitchJumpTable):
      (JSC::CodeBlock::setIdentifiers):
      (JSC::baselineCodeBlockForInlineCallFrame):
      (JSC::ExecState::uncheckedR):
      * bytecode/CodeOrigin.cpp:
      (JSC::CodeOrigin::inlineStack):
      * bytecode/CodeOrigin.h:
      (JSC::CodeOrigin::CodeOrigin):
      * dfg/DFGCSEPhase.cpp:
      * dfg/DFGOSRExit.cpp:
      * dfg/DFGScratchRegisterAllocator.h:
      (JSC::DFG::ScratchRegisterAllocator::preserveUsedRegistersToScratchBuffer):
      (JSC::DFG::ScratchRegisterAllocator::restoreUsedRegistersFromScratchBuffer):
      * dfg/DFGSpeculativeJIT.h:
      (JSC::DFG::SpeculativeJIT::allocate):
      (JSC::DFG::SpeculativeJIT::spill):
      (JSC::DFG::SpeculativeJIT::integerResult):
      * dfg/DFGSpeculativeJIT64.cpp:
      (JSC::DFG::SpeculativeJIT::fillInteger):
      (JSC::DFG::SpeculativeJIT::fillDouble):
      (JSC::DFG::SpeculativeJIT::fillJSValue):
      (JSC::DFG::SpeculativeJIT::nonSpeculativeCompareNull):
      (JSC::DFG::SpeculativeJIT::emitCall):
      (JSC::DFG::SpeculativeJIT::fillSpeculateIntInternal):
      (JSC::DFG::SpeculativeJIT::fillSpeculateIntStrict):
      (JSC::DFG::SpeculativeJIT::fillSpeculateDouble):
      (JSC::DFG::SpeculativeJIT::fillSpeculateCell):
      (JSC::DFG::SpeculativeJIT::fillSpeculateBoolean):
      (JSC::DFG::SpeculativeJIT::compile):
      * dfg/DFGValueSource.h:
      (JSC::DFG::dataFormatToValueSourceKind):
      (JSC::DFG::ValueSource::ValueSource):
      * dfg/DFGVirtualRegisterAllocationPhase.cpp:
      * heap/BlockAllocator.cpp:
      (JSC::BlockAllocator::BlockAllocator):
      (JSC::BlockAllocator::releaseFreeRegions):
      (JSC::BlockAllocator::blockFreeingThreadMain):
      * heap/Heap.cpp:
      (JSC::Heap::lastChanceToFinalize):
      (JSC::Heap::collect):
      * interpreter/Interpreter.cpp:
      (JSC::Interpreter::throwException):
      (JSC::Interpreter::execute):
      * jit/GCAwareJITStubRoutine.cpp:
      (JSC::GCAwareJITStubRoutine::observeZeroRefCount):
      * jit/JIT.cpp:
      (JSC::JIT::privateCompileMainPass):
      (JSC::JIT::privateCompileSlowCases):
      * jit/JITExceptions.cpp:
      (JSC::genericThrow):
      * jit/JITInlines.h:
      (JSC::JIT::emitLoad):
      * jit/JITOpcodes.cpp:
      (JSC::JIT::emit_op_end):
      (JSC::JIT::emit_resolve_operations):
      * jit/JITStubRoutine.cpp:
      (JSC::JITStubRoutine::observeZeroRefCount):
      * jit/JITStubs.cpp:
      (JSC::returnToThrowTrampoline):
      * runtime/Arguments.cpp:
      (JSC::Arguments::getOwnPropertySlot):
      (JSC::Arguments::getOwnPropertyDescriptor):
      (JSC::Arguments::deleteProperty):
      (JSC::Arguments::defineOwnProperty):
      (JSC::Arguments::didTearOffActivation):
      * runtime/ArrayPrototype.cpp:
      (JSC::shift):
      (JSC::unshift):
      (JSC::arrayProtoFuncLastIndexOf):
      * runtime/ButterflyInlines.h:
      (JSC::Butterfly::growPropertyStorage):
      * runtime/CodeCache.cpp:
      (JSC::CodeCache::getFunctionExecutableFromGlobalCode):
      * runtime/CodeCache.h:
      (JSC::CacheMap::add):
      * runtime/Completion.cpp:
      (JSC::checkSyntax):
      (JSC::evaluate):
      * runtime/Executable.cpp:
      (JSC::FunctionExecutable::FunctionExecutable):
      (JSC::EvalExecutable::unlinkCalls):
      (JSC::ProgramExecutable::compileOptimized):
      (JSC::ProgramExecutable::unlinkCalls):
      (JSC::ProgramExecutable::initializeGlobalProperties):
      (JSC::FunctionExecutable::baselineCodeBlockFor):
      (JSC::FunctionExecutable::compileOptimizedForCall):
      (JSC::FunctionExecutable::compileOptimizedForConstruct):
      (JSC::FunctionExecutable::compileForCallInternal):
      (JSC::FunctionExecutable::compileForConstructInternal):
      (JSC::FunctionExecutable::unlinkCalls):
      (JSC::NativeExecutable::hashFor):
      * runtime/Executable.h:
      (JSC::EvalExecutable::compile):
      (JSC::ProgramExecutable::compile):
      (JSC::FunctionExecutable::compileForCall):
      (JSC::FunctionExecutable::compileForConstruct):
      * runtime/IndexingHeader.h:
      (JSC::IndexingHeader::setVectorLength):
      * runtime/JSArray.cpp:
      (JSC::JSArray::pop):
      (JSC::JSArray::shiftCountWithArrayStorage):
      (JSC::JSArray::shiftCountWithAnyIndexingType):
      (JSC::JSArray::unshiftCountWithArrayStorage):
      * runtime/JSGlobalObjectFunctions.cpp:
      (JSC::jsStrDecimalLiteral):
      * runtime/JSObject.cpp:
      (JSC::JSObject::copyButterfly):
      (JSC::JSObject::defineOwnIndexedProperty):
      (JSC::JSObject::putByIndexBeyondVectorLengthWithoutAttributes):
      * runtime/JSString.cpp:
      (JSC::JSRopeString::getIndexSlowCase):
      * yarr/YarrInterpreter.cpp:
      (JSC::Yarr::Interpreter::popParenthesesDisjunctionContext):
      
      git-svn-id: http://svn.webkit.org/repository/webkit/trunk@140619 268f45cc-cd09-0410-ab3c-d52691b4dbfc
      903b0c0b
  11. 11 Jan, 2013 1 commit
    • fpizlo@apple.com's avatar
      The JITThunks class should be in its own file, and doing so should not break the build · a4b4cbe9
      fpizlo@apple.com authored
      https://bugs.webkit.org/show_bug.cgi?id=105696
      
      Source/JavaScriptCore: 
      
      Rubber stamped by Sam Weinig and Geoffrey Garen.
              
      This patch was supposed to just move JITThunks into its own file. But then I
      realized that there is a horrible circular dependency chain between JSCell,
      JSGlobalData, CallFrame, and Weak, which only works because of magical include
      order in JITStubs.h, and the fact that JSGlobalData.h includes JITStubs.h
      before it includes JSCell or JSValue.
              
      I first tried to just get JITThunks.h to just magically do the same pointless
      includes that JITStubs.h had, but then I decided to actually fix the underflying
      problem, which was that JSCell needed CallFrame, CallFrame needed JSGlobalData,
      JSGlobalData needed JITThunks, JITThunks needed Weak, and Weak needed JSCell.
      Now, all of JSCell's outgoing dependencies are placed in JSCellInlines.h. This
      also gave me an opportunity to move JSValue inline methods from JSCell.h into
      JSValueInlines.h. But to make this really work, I needed to remove includes of
      *Inlines.h from other headers (CodeBlock.h for example included JSValueInlines.h,
      which defeats the whole entire purpose of having an Inlines.h file), and I needed
      to add includes of *Inlines.h into a bunch of .cpp files. I did this mostly by
      having .cpp files include Operations.h. In future, if you're adding a .cpp file
      to JSC, you'll almost certainly have to include Operations.h unless you enjoy
      link errors.
      
      * API/JSBase.cpp:
      * API/JSCallbackConstructor.cpp:
      * API/JSCallbackFunction.cpp:
      * API/JSCallbackObject.cpp:
      * API/JSClassRef.cpp:
      * API/JSContextRef.cpp:
      * API/JSObjectRef.cpp:
      * API/JSScriptRef.cpp:
      * API/JSWeakObjectMapRefPrivate.cpp:
      * JSCTypedArrayStubs.h:
      * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj:
      * JavaScriptCore.xcodeproj/project.pbxproj:
      * bytecode/ArrayAllocationProfile.cpp:
      * bytecode/CodeBlock.cpp:
      * bytecode/GetByIdStatus.cpp:
      * bytecode/LazyOperandValueProfile.cpp:
      * bytecode/ResolveGlobalStatus.cpp:
      * bytecode/SpeculatedType.cpp:
      * bytecode/UnlinkedCodeBlock.cpp:
      * bytecompiler/BytecodeGenerator.cpp:
      * debugger/Debugger.cpp:
      * debugger/DebuggerActivation.cpp:
      * debugger/DebuggerCallFrame.cpp:
      * dfg/DFGArgumentsSimplificationPhase.cpp:
      * dfg/DFGArrayMode.cpp:
      * dfg/DFGByteCodeParser.cpp:
      * dfg/DFGConstantFoldingPhase.cpp:
      * dfg/DFGDriver.cpp:
      * dfg/DFGFixupPhase.cpp:
      * dfg/DFGGraph.cpp:
      * dfg/DFGJITCompiler.cpp:
      * dfg/DFGOSREntry.cpp:
      * dfg/DFGOSRExitCompiler.cpp:
      * dfg/DFGOSRExitCompiler32_64.cpp:
      * dfg/DFGOSRExitCompiler64.cpp:
      * dfg/DFGPredictionPropagationPhase.cpp:
      * dfg/DFGSpeculativeJIT.cpp:
      (JSC::DFG::SpeculativeJIT::silentSavePlanForGPR):
      (DFG):
      (JSC::DFG::SpeculativeJIT::silentSavePlanForFPR):
      (JSC::DFG::SpeculativeJIT::silentSpill):
      (JSC::DFG::SpeculativeJIT::silentFill):
      * dfg/DFGSpeculativeJIT.h:
      (SpeculativeJIT):
      * dfg/DFGSpeculativeJIT32_64.cpp:
      * dfg/DFGSpeculativeJIT64.cpp:
      * dfg/DFGStructureCheckHoistingPhase.cpp:
      * dfg/DFGVariableEventStream.cpp:
      * heap/CopiedBlock.h:
      * heap/CopiedSpace.cpp:
      * heap/HandleSet.cpp:
      * heap/Heap.cpp:
      * heap/HeapStatistics.cpp:
      * heap/SlotVisitor.cpp:
      * heap/WeakBlock.cpp:
      * interpreter/CallFrame.cpp:
      * interpreter/CallFrame.h:
      * jit/ClosureCallStubRoutine.cpp:
      * jit/GCAwareJITStubRoutine.cpp:
      * jit/JIT.cpp:
      * jit/JITArithmetic.cpp:
      * jit/JITArithmetic32_64.cpp:
      * jit/JITCall.cpp:
      * jit/JITCall32_64.cpp:
      * jit/JITCode.h:
      * jit/JITExceptions.cpp:
      * jit/JITStubs.h:
      * jit/JITThunks.h:
      * jsc.cpp:
      * llint/LLIntExceptions.cpp:
      * profiler/LegacyProfiler.cpp:
      * profiler/ProfileGenerator.cpp:
      * profiler/ProfilerBytecode.cpp:
      * profiler/ProfilerBytecodeSequence.cpp:
      * profiler/ProfilerBytecodes.cpp:
      * profiler/ProfilerCompilation.cpp:
      * profiler/ProfilerCompiledBytecode.cpp:
      * profiler/ProfilerDatabase.cpp:
      * profiler/ProfilerOSRExit.cpp:
      * profiler/ProfilerOSRExitSite.cpp:
      * profiler/ProfilerOrigin.cpp:
      * profiler/ProfilerOriginStack.cpp:
      * profiler/ProfilerProfiledBytecodes.cpp:
      * runtime/ArgList.cpp:
      * runtime/Arguments.cpp:
      * runtime/ArrayConstructor.cpp:
      * runtime/BooleanConstructor.cpp:
      * runtime/BooleanObject.cpp:
      * runtime/BooleanPrototype.cpp:
      * runtime/CallData.cpp:
      * runtime/CodeCache.cpp:
      * runtime/Completion.cpp:
      * runtime/ConstructData.cpp:
      * runtime/DateConstructor.cpp:
      * runtime/DateInstance.cpp:
      * runtime/DatePrototype.cpp:
      * runtime/Error.cpp:
      * runtime/ErrorConstructor.cpp:
      * runtime/ErrorInstance.cpp:
      * runtime/ErrorPrototype.cpp:
      * runtime/ExceptionHelpers.cpp:
      * runtime/Executable.cpp:
      * runtime/FunctionConstructor.cpp:
      * runtime/FunctionPrototype.cpp:
      * runtime/GetterSetter.cpp:
      * runtime/Identifier.cpp:
      * runtime/InternalFunction.cpp:
      * runtime/JSActivation.cpp:
      * runtime/JSBoundFunction.cpp:
      * runtime/JSCell.cpp:
      * runtime/JSCell.h:
      (JSC):
      * runtime/JSCellInlines.h: Added.
      (JSC):
      (JSC::JSCell::JSCell):
      (JSC::JSCell::finishCreation):
      (JSC::JSCell::structure):
      (JSC::JSCell::visitChildren):
      (JSC::allocateCell):
      (JSC::isZapped):
      (JSC::JSCell::isObject):
      (JSC::JSCell::isString):
      (JSC::JSCell::isGetterSetter):
      (JSC::JSCell::isProxy):
      (JSC::JSCell::isAPIValueWrapper):
      (JSC::JSCell::setStructure):
      (JSC::JSCell::methodTable):
      (JSC::JSCell::inherits):
      (JSC::JSCell::fastGetOwnPropertySlot):
      (JSC::JSCell::fastGetOwnProperty):
      (JSC::JSCell::toBoolean):
      * runtime/JSDateMath.cpp:
      * runtime/JSFunction.cpp:
      * runtime/JSFunction.h:
      (JSC):
      * runtime/JSGlobalData.h:
      (JSC):
      (JSGlobalData):
      * runtime/JSGlobalObject.cpp:
      * runtime/JSGlobalObjectFunctions.cpp:
      * runtime/JSLock.cpp:
      * runtime/JSNameScope.cpp:
      * runtime/JSNotAnObject.cpp:
      * runtime/JSONObject.cpp:
      * runtime/JSObject.h:
      (JSC):
      * runtime/JSProxy.cpp:
      * runtime/JSScope.cpp:
      * runtime/JSSegmentedVariableObject.cpp:
      * runtime/JSString.h:
      (JSC):
      * runtime/JSStringJoiner.cpp:
      * runtime/JSSymbolTableObject.cpp:
      * runtime/JSValue.cpp:
      * runtime/JSValueInlines.h:
      (JSC::JSValue::toInt32):
      (JSC::JSValue::toUInt32):
      (JSC):
      (JSC::JSValue::isUInt32):
      (JSC::JSValue::asUInt32):
      (JSC::JSValue::asNumber):
      (JSC::jsNaN):
      (JSC::JSValue::JSValue):
      (JSC::JSValue::encode):
      (JSC::JSValue::decode):
      (JSC::JSValue::operator bool):
      (JSC::JSValue::operator==):
      (JSC::JSValue::operator!=):
      (JSC::JSValue::isEmpty):
      (JSC::JSValue::isUndefined):
      (JSC::JSValue::isNull):
      (JSC::JSValue::isUndefinedOrNull):
      (JSC::JSValue::isCell):
      (JSC::JSValue::isInt32):
      (JSC::JSValue::isDouble):
      (JSC::JSValue::isTrue):
      (JSC::JSValue::isFalse):
      (JSC::JSValue::tag):
      (JSC::JSValue::payload):
      (JSC::JSValue::asInt32):
      (JSC::JSValue::asDouble):
      (JSC::JSValue::asCell):
      (JSC::JSValue::isNumber):
      (JSC::JSValue::isBoolean):
      (JSC::JSValue::asBoolean):
      (JSC::reinterpretDoubleToInt64):
      (JSC::reinterpretInt64ToDouble):
      (JSC::JSValue::isString):
      (JSC::JSValue::isPrimitive):
      (JSC::JSValue::isGetterSetter):
      (JSC::JSValue::isObject):
      (JSC::JSValue::getString):
      (JSC::::getString):
      (JSC::JSValue::getObject):
      (JSC::JSValue::getUInt32):
      (JSC::JSValue::toPrimitive):
      (JSC::JSValue::getPrimitiveNumber):
      (JSC::JSValue::toNumber):
      (JSC::JSValue::toObject):
      (JSC::JSValue::isFunction):
      (JSC::JSValue::inherits):
      (JSC::JSValue::toThisObject):
      (JSC::JSValue::get):
      (JSC::JSValue::put):
      (JSC::JSValue::putByIndex):
      (JSC::JSValue::structureOrUndefined):
      (JSC::JSValue::equal):
      (JSC::JSValue::equalSlowCaseInline):
      (JSC::JSValue::strictEqualSlowCaseInline):
      (JSC::JSValue::strictEqual):
      * runtime/JSVariableObject.cpp:
      * runtime/JSWithScope.cpp:
      * runtime/JSWrapperObject.cpp:
      * runtime/LiteralParser.cpp:
      * runtime/Lookup.cpp:
      * runtime/NameConstructor.cpp:
      * runtime/NameInstance.cpp:
      * runtime/NamePrototype.cpp:
      * runtime/NativeErrorConstructor.cpp:
      * runtime/NativeErrorPrototype.cpp:
      * runtime/NumberConstructor.cpp:
      * runtime/NumberObject.cpp:
      * runtime/ObjectConstructor.cpp:
      * runtime/ObjectPrototype.cpp:
      * runtime/Operations.h:
      (JSC):
      * runtime/PropertySlot.cpp:
      * runtime/RegExp.cpp:
      * runtime/RegExpCache.cpp:
      * runtime/RegExpCachedResult.cpp:
      * runtime/RegExpConstructor.cpp:
      * runtime/RegExpMatchesArray.cpp:
      * runtime/RegExpObject.cpp:
      * runtime/RegExpPrototype.cpp:
      * runtime/SmallStrings.cpp:
      * runtime/SparseArrayValueMap.cpp:
      * runtime/StrictEvalActivation.cpp:
      * runtime/StringConstructor.cpp:
      * runtime/StringObject.cpp:
      * runtime/StringRecursionChecker.cpp:
      * runtime/Structure.h:
      (JSC):
      * runtime/StructureChain.cpp:
      * runtime/TimeoutChecker.cpp:
      * testRegExp.cpp:
      
      Source/WebCore: 
      
      Rubber stamped by Sam Weinig.
      
      All .cpp files that use the JSC internal API must now transitively include
      Operations.h, and none of the major JSC headers do it for you to avoid
      circularity. WebCore doesn't have to worry about circularity with JSC, so
      this changes all of the major WebCore JSC base headers to include
      Operations.h.
      
      * bindings/js/BindingState.h:
      * bindings/js/JSArrayBufferViewHelper.h:
      * bindings/js/JSCustomXPathNSResolver.h:
      * bindings/js/JSDOMBinding.h:
      * bindings/js/JSDOMGlobalObject.h:
      * bindings/js/JSDictionary.h:
      * bindings/js/JSMessagePortCustom.h:
      * bindings/js/JSNodeFilterCondition.h:
      * bindings/js/ScriptValue.h:
      * bindings/js/ScriptWrappable.h:
      * bindings/js/SerializedScriptValue.cpp:
      * bridge/c/c_utility.h:
      * bridge/jsc/BridgeJSC.h:
      * dom/Node.cpp:
      * html/HTMLCanvasElement.cpp:
      * html/HTMLImageLoader.cpp:
      * plugins/efl/PluginViewEfl.cpp:
      * xml/XMLHttpRequest.cpp:
      
      
      
      git-svn-id: http://svn.webkit.org/repository/webkit/trunk@139541 268f45cc-cd09-0410-ab3c-d52691b4dbfc
      a4b4cbe9
  12. 02 Jan, 2013 1 commit
    • ggaren@apple.com's avatar
      Some renaming in the CodeCache · 446dffa4
      ggaren@apple.com authored
      https://bugs.webkit.org/show_bug.cgi?id=105966
      
      Reviewed by Gavin Barraclough.
      
      CodeBlockKey => SourceCodeKey because the key is not a CodeBlock.
      
      m_recentlyUsedFunctionCode => m_recentlyUsedFunctions to match other names.
      
      GlobalFunctionKey => FunctionKey because the key is not unique to globalness.
      
      m_cachedGlobalFunctions => m_globalFunctions because "cached" is redundant
      for data members in an object called "CodeCache".
      
      kMaxRootCodeBlockEntries => kMaxRootEntries because there are no non-CodeBlock
      entries in a CodeBlock cache.
      
      kMaxFunctionCodeBlocks => kMaxChildFunctionEntries to clarify that this
      number models a parent-child relationship.
      
      Also removed the initial "k" from enum constants. That's an interesting
      style for calling out constants, but it's not the WebKit style.
      
      Finally, a behavior change: Use MaxRootEntries for the limit on global
      functions, and not MaxChildFunctionEntries. Previously, there was an
      unused constant that seemed to have been intended for this purpose.
      
      * runtime/CodeCache.cpp:
      (JSC::CodeCache::makeSourceCodeKey):
      (JSC::CodeCache::getCodeBlock):
      (JSC::CodeCache::generateFunctionCodeBlock):
      (JSC::CodeCache::makeFunctionKey):
      (JSC::CodeCache::getFunctionExecutableFromGlobalCode):
      (JSC::CodeCache::usedFunctionCode):
      * runtime/CodeCache.h:
      (JSC::CodeCache::clear):
      
      
      git-svn-id: http://svn.webkit.org/repository/webkit/trunk@138675 268f45cc-cd09-0410-ab3c-d52691b4dbfc
      446dffa4
  13. 06 Dec, 2012 1 commit
  14. 30 Nov, 2012 1 commit
    • oliver@apple.com's avatar
      Add direct string->function code cache · 72b0c04c
      oliver@apple.com authored
      https://bugs.webkit.org/show_bug.cgi?id=103764
      
      Reviewed by Michael Saboff.
      
      A fairly logically simple patch.  We now track the start of the
      unique portion of a functions body, and use that as our key for
      unlinked function code.  This allows us to cache identical code
      in different contexts, leading to a small but consistent improvement
      on the benchmarks we track.
      
      * bytecode/UnlinkedCodeBlock.cpp:
      (JSC::UnlinkedFunctionExecutable::UnlinkedFunctionExecutable):
      * bytecode/UnlinkedCodeBlock.h:
      (JSC::UnlinkedFunctionExecutable::functionStartOffset):
      (UnlinkedFunctionExecutable):
      * parser/ASTBuilder.h:
      (ASTBuilder):
      (JSC::ASTBuilder::setFunctionStart):
      * parser/Nodes.cpp:
      * parser/Nodes.h:
      (JSC::FunctionBodyNode::setFunctionStart):
      (JSC::FunctionBodyNode::functionStart):
      (FunctionBodyNode):
      * parser/Parser.cpp:
      (JSC::::parseFunctionInfo):
      * parser/Parser.h:
      (JSC::Parser::findCachedFunctionInfo):
      * parser/SyntaxChecker.h:
      (JSC::SyntaxChecker::setFunctionStart):
      * runtime/CodeCache.cpp:
      (JSC::CodeCache::generateFunctionCodeBlock):
      (JSC::CodeCache::getFunctionCodeBlock):
      (JSC::CodeCache::usedFunctionCode):
      * runtime/CodeCache.h:
      
      git-svn-id: http://svn.webkit.org/repository/webkit/trunk@136261 268f45cc-cd09-0410-ab3c-d52691b4dbfc
      72b0c04c
  15. 08 Nov, 2012 1 commit
    • oliver@apple.com's avatar
      Improve effectiveness of function-level caching · 27e0eed2
      oliver@apple.com authored
      https://bugs.webkit.org/show_bug.cgi?id=101667
      
      Reviewed by Filip Pizlo.
      
      Added a random-eviction based cache for unlinked functions, and switch
      UnlinkedFunctionExecutable's code references to Weak<>, thereby letting
      us remove the explicit UnlinkedFunctionExecutable::clearCode() calls that
      were being triggered by GC.
      
      Refactored the random eviction part of the CodeCache into a separate data
      structure so that I didn't have to duplicate the code again, and then used
      that for the new function cache.
      
      * bytecode/UnlinkedCodeBlock.cpp:
      (JSC::UnlinkedFunctionExecutable::visitChildren):
      (JSC::UnlinkedFunctionExecutable::codeBlockFor):
      * bytecode/UnlinkedCodeBlock.h:
      (JSC::UnlinkedFunctionExecutable::clearCodeForRecompilation):
      (UnlinkedFunctionExecutable):
      * debugger/Debugger.cpp:
      * runtime/CodeCache.cpp:
      (JSC::CodeCache::getCodeBlock):
      (JSC::CodeCache::generateFunctionCodeBlock):
      (JSC::CodeCache::getFunctionExecutableFromGlobalCode):
      (JSC::CodeCache::usedFunctionCode):
      (JSC):
      * runtime/Executable.cpp:
      (JSC::FunctionExecutable::clearUnlinkedCodeForRecompilationIfNotCompiling):
      (JSC::FunctionExecutable::clearCode):
      * runtime/Executable.h:
      (FunctionExecutable):
      
      git-svn-id: http://svn.webkit.org/repository/webkit/trunk@133975 268f45cc-cd09-0410-ab3c-d52691b4dbfc
      27e0eed2
  16. 06 Nov, 2012 1 commit
    • oliver@apple.com's avatar
      Reduce parser overhead in JSC · f0c01b8e
      oliver@apple.com authored
      https://bugs.webkit.org/show_bug.cgi?id=101127
      
      Reviewed by Filip Pizlo.
      
      An exciting journey into the world of architecture in which our hero
      adds yet another layer to JSC codegeneration.
      
      This patch adds a marginally more compact form of bytecode that is
      free from any data specific to a given execution context, and that
      does store any data structures necessary for execution.  To actually
      execute this UnlinkedBytecode we still need to instantiate a real
      CodeBlock, but this is a much faster linear time operation than any
      of the earlier parsing or code generation passes.
      
      As the unlinked code is context free we can then simply use a cache
      from source to unlinked code mapping to completely avoid all of the
      old parser overhead.  The cache is currently very simple and memory
      heavy, using the complete source text as a key (rather than SourceCode
      or equivalent), and a random eviction policy.
      
      This seems to produce a substantial win when loading identical content
      in different contexts.
      
      * API/tests/testapi.c:
      (main):
      * CMakeLists.txt:
      * GNUmakefile.list.am:
      * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj:
      * JavaScriptCore.xcodeproj/project.pbxproj:
      * bytecode/CodeBlock.cpp:
      * bytecode/CodeBlock.h:
          Moved a number of fields, and a bunch of logic to UnlinkedCodeBlock.h/cpp
      * bytecode/Opcode.h:
          Added a global const init no op instruction needed to get correct
          behaviour without any associated semantics.
      * bytecode/UnlinkedCodeBlock.cpp: Added.
      * bytecode/UnlinkedCodeBlock.h: Added.
          A fairly shallow, GC allocated version of the old CodeBlock
          classes with a 32bit instruction size, and just metadata
          size tracking.
      * bytecompiler/BytecodeGenerator.cpp:
      * bytecompiler/BytecodeGenerator.h:
          Replace direct access to m_symbolTable with access through
          symbolTable().  ProgramCode no longer has a symbol table at
          all so some previously unconditional (and pointless) uses
          of symbolTable get null checks.
          A few other changes to deal with type changes due to us generating
          unlinked code (eg. pointer free, so profile indices rather than
          pointers).
      * dfg/DFGByteCodeParser.cpp:
      * dfg/DFGCapabilities.h:
          Support global_init_nop
      * interpreter/Interpreter.cpp:
          Now get the ProgramExecutable to initialise new global properties
          before starting execution.
      * jit/JIT.cpp:
      * jit/JITDriver.h:
      * jit/JITStubs.cpp:
      * llint/LLIntData.cpp:
      * llint/LLIntSlowPaths.cpp:
      * llint/LowLevelInterpreter.asm:
      * llint/LowLevelInterpreter32_64.asm:
      * llint/LowLevelInterpreter64.asm:
          Adding init_global_const_nop everywhere else
      * parser/Parser.h:
      * parser/ParserModes.h: Added.
      * parser/ParserTokens.h:
          Parser no longer needs a global object or callframe to function
      * runtime/CodeCache.cpp: Added.
      * runtime/CodeCache.h: Added.
          A simple, random eviction, Source->UnlinkedCode cache
      * runtime/Executable.cpp:
      * runtime/Executable.h:
          Executables now reference their unlinked counterparts, and
          request code specifically for the target global object.
      * runtime/JSGlobalData.cpp:
      * runtime/JSGlobalData.h:
          GlobalData now owns a CodeCache and a set of new structures
          for the unlinked code types.
      * runtime/JSGlobalObject.cpp:
      * runtime/JSGlobalObject.h:
          Utility functions used by executables to perform compilation
      
      * runtime/JSType.h:
        Add new JSTypes for unlinked code
      
      git-svn-id: http://svn.webkit.org/repository/webkit/trunk@133688 268f45cc-cd09-0410-ab3c-d52691b4dbfc
      f0c01b8e