Source/JavaScriptCore/bytecode/CodeBlock.h

   1 /*
   2  * Copyright (C) 2008-2017 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 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 #pragma once
  31
  32 #include "ArrayProfile.h"
  33 #include "ByValInfo.h"
  34 #include "BytecodeConventions.h"
  35 #include "CallLinkInfo.h"
  36 #include "CodeBlockHash.h"
  37 #include "CodeOrigin.h"
  38 #include "CodeType.h"
  39 #include "CompactJITCodeMap.h"
  40 #include "CompilationResult.h"
  41 #include "ConcurrentJSLock.h"
  42 #include "DFGCommon.h"
  43 #include "DFGExitProfile.h"
  44 #include "DirectEvalCodeCache.h"
  45 #include "EvalExecutable.h"
  46 #include "ExecutionCounter.h"
  47 #include "ExpressionRangeInfo.h"
  48 #include "FunctionExecutable.h"
  49 #include "HandlerInfo.h"
  50 #include "Instruction.h"
  51 #include "JITCode.h"
  52 #include "JITMathICForwards.h"
  53 #include "JSCell.h"
  54 #include "JSGlobalObject.h"
  55 #include "JumpTable.h"
  56 #include "LLIntCallLinkInfo.h"
  57 #include "LLIntPrototypeLoadAdaptiveStructureWatchpoint.h"
  58 #include "LazyOperandValueProfile.h"
  59 #include "ModuleProgramExecutable.h"
  60 #include "ObjectAllocationProfile.h"
  61 #include "Options.h"
  62 #include "Printer.h"
  63 #include "ProfilerJettisonReason.h"
  64 #include "ProgramExecutable.h"
  65 #include "PutPropertySlot.h"
  66 #include "UnconditionalFinalizer.h"
  67 #include "ValueProfile.h"
  68 #include "VirtualRegister.h"
  69 #include "Watchpoint.h"
  70 #include <wtf/Bag.h>
  71 #include <wtf/FastMalloc.h>
  72 #include <wtf/RefCountedArray.h>
  73 #include <wtf/RefPtr.h>
  74 #include <wtf/SegmentedVector.h>
  75 #include <wtf/Vector.h>
  76 #include <wtf/text/WTFString.h>
  77
  78 namespace JSC {
  79
  80 #if ENABLE(DFG_JIT)
  81 namespace DFG {
  82 struct OSRExitState;
  83 } // namespace DFG
  84 #endif
  85
  86 class BytecodeLivenessAnalysis;
  87 class CodeBlockSet;
  88 class ExecState;
  89 class JSModuleEnvironment;
  90 class LLIntOffsetsExtractor;
  91 class PCToCodeOriginMap;
  92 class RegisterAtOffsetList;
  93 class StructureStubInfo;
  94
  95 enum class AccessType : int8_t;
  96
  97 struct ArithProfile;
  98
  99 typedef HashMap<CodeOrigin, StructureStubInfo*, CodeOriginApproximateHash> StubInfoMap;
 100
 101 enum ReoptimizationMode { DontCountReoptimization, CountReoptimization };
 102
 103 class CodeBlock : public JSCell {
 104     typedef JSCell Base;
 105     friend class BytecodeLivenessAnalysis;
 106     friend class JIT;
 107     friend class LLIntOffsetsExtractor;
 108
 109     class UnconditionalFinalizer : public JSC::UnconditionalFinalizer {
 110         void finalizeUnconditionally() override;
 111     };
 112
 113     class WeakReferenceHarvester : public JSC::WeakReferenceHarvester {
 114         void visitWeakReferences(SlotVisitor&) override;
 115     };
 116
 117 public:
 118     enum CopyParsedBlockTag { CopyParsedBlock };
 119
 120     static const unsigned StructureFlags = Base::StructureFlags | StructureIsImmortal;
 121
 122     DECLARE_INFO;
 123
 124 protected:
 125     CodeBlock(VM*, Structure*, CopyParsedBlockTag, CodeBlock& other);
 126     CodeBlock(VM*, Structure*, ScriptExecutable* ownerExecutable, UnlinkedCodeBlock*, JSScope*, RefPtr<SourceProvider>&&, unsigned sourceOffset, unsigned firstLineColumnOffset);
 127
 128     void finishCreation(VM&, CopyParsedBlockTag, CodeBlock& other);
 129     bool finishCreation(VM&, ScriptExecutable* ownerExecutable, UnlinkedCodeBlock*, JSScope*);
 130
 131     WriteBarrier<JSGlobalObject> m_globalObject;
 132
 133 public:
 134     JS_EXPORT_PRIVATE ~CodeBlock();
 135
 136     UnlinkedCodeBlock* unlinkedCodeBlock() const { return m_unlinkedCode.get(); }
 137
 138     CString inferredName() const;
 139     CodeBlockHash hash() const;
 140     bool hasHash() const;
 141     bool isSafeToComputeHash() const;
 142     CString hashAsStringIfPossible() const;
 143     CString sourceCodeForTools() const; // Not quite the actual source we parsed; this will do things like prefix the source for a function with a reified signature.
 144     CString sourceCodeOnOneLine() const; // As sourceCodeForTools(), but replaces all whitespace runs with a single space.
 145     void dumpAssumingJITType(PrintStream&, JITCode::JITType) const;
 146     JS_EXPORT_PRIVATE void dump(PrintStream&) const;
 147
 148     int numParameters() const { return m_numParameters; }
 149     void setNumParameters(int newValue);
 150
 151     int numberOfArgumentsToSkip() const { return m_numberOfArgumentsToSkip; }
 152
 153     int numCalleeLocals() const { return m_numCalleeLocals; }
 154
 155     int* addressOfNumParameters() { return &m_numParameters; }
 156     static ptrdiff_t offsetOfNumParameters() { return OBJECT_OFFSETOF(CodeBlock, m_numParameters); }
 157
 158     CodeBlock* alternative() const { return static_cast<CodeBlock*>(m_alternative.get()); }
 159     void setAlternative(VM&, CodeBlock*);
 160
 161     template <typename Functor> void forEachRelatedCodeBlock(Functor&& functor)
 162     {
 163         Functor f(std::forward<Functor>(functor));
 164         Vector<CodeBlock*, 4> codeBlocks;
 165         codeBlocks.append(this);
 166
 167         while (!codeBlocks.isEmpty()) {
 168             CodeBlock* currentCodeBlock = codeBlocks.takeLast();
 169             f(currentCodeBlock);
 170
 171             if (CodeBlock* alternative = currentCodeBlock->alternative())
 172                 codeBlocks.append(alternative);
 173             if (CodeBlock* osrEntryBlock = currentCodeBlock->specialOSREntryBlockOrNull())
 174                 codeBlocks.append(osrEntryBlock);
 175         }
 176     }
 177
 178     CodeSpecializationKind specializationKind() const
 179     {
 180         return specializationFromIsConstruct(m_isConstructor);
 181     }
 182
 183     CodeBlock* alternativeForJettison();
 184     JS_EXPORT_PRIVATE CodeBlock* baselineAlternative();
 185
 186     // FIXME: Get rid of this.
 187     // https://bugs.webkit.org/show_bug.cgi?id=123677
 188     CodeBlock* baselineVersion();
 189
 190     static size_t estimatedSize(JSCell*);
 191     static void visitChildren(JSCell*, SlotVisitor&);
 192     void visitChildren(SlotVisitor&);
 193     void visitWeakly(SlotVisitor&);
 194     void clearVisitWeaklyHasBeenCalled();
 195
 196     void dumpSource();
 197     void dumpSource(PrintStream&);
 198
 199     void dumpBytecode();
 200     void dumpBytecode(PrintStream&);
 201     void dumpBytecode(PrintStream& out, const Instruction* begin, const Instruction*& it, const StubInfoMap& = StubInfoMap(), const CallLinkInfoMap& = CallLinkInfoMap());
 202     void dumpBytecode(PrintStream& out, unsigned bytecodeOffset, const StubInfoMap& = StubInfoMap(), const CallLinkInfoMap& = CallLinkInfoMap());
 203
 204     void dumpExceptionHandlers(PrintStream&);
 205     void printStructures(PrintStream&, const Instruction*);
 206     void printStructure(PrintStream&, const char* name, const Instruction*, int operand);
 207
 208     void dumpMathICStats();
 209
 210     bool isStrictMode() const { return m_isStrictMode; }
 211     ECMAMode ecmaMode() const { return isStrictMode() ? StrictMode : NotStrictMode; }
 212
 213     bool hasInstalledVMTrapBreakpoints() const;
 214     bool installVMTrapBreakpoints();
 215
 216     inline bool isKnownNotImmediate(int index)
 217     {
 218         if (index == m_thisRegister.offset() && !m_isStrictMode)
 219             return true;
 220
 221         if (isConstantRegisterIndex(index))
 222             return getConstant(index).isCell();
 223
 224         return false;
 225     }
 226
 227     ALWAYS_INLINE bool isTemporaryRegisterIndex(int index)
 228     {
 229         return index >= m_numVars;
 230     }
 231
 232     HandlerInfo* handlerForBytecodeOffset(unsigned bytecodeOffset, RequiredHandler = RequiredHandler::AnyHandler);
 233     HandlerInfo* handlerForIndex(unsigned, RequiredHandler = RequiredHandler::AnyHandler);
 234     void removeExceptionHandlerForCallSite(CallSiteIndex);
 235     unsigned lineNumberForBytecodeOffset(unsigned bytecodeOffset);
 236     unsigned columnNumberForBytecodeOffset(unsigned bytecodeOffset);
 237     void expressionRangeForBytecodeOffset(unsigned bytecodeOffset, int& divot,
 238         int& startOffset, int& endOffset, unsigned& line, unsigned& column) const;
 239
 240     std::optional<unsigned> bytecodeOffsetFromCallSiteIndex(CallSiteIndex);
 241
 242     void getStubInfoMap(const ConcurrentJSLocker&, StubInfoMap& result);
 243     void getStubInfoMap(StubInfoMap& result);
 244
 245     void getCallLinkInfoMap(const ConcurrentJSLocker&, CallLinkInfoMap& result);
 246     void getCallLinkInfoMap(CallLinkInfoMap& result);
 247
 248     void getByValInfoMap(const ConcurrentJSLocker&, ByValInfoMap& result);
 249     void getByValInfoMap(ByValInfoMap& result);
 250
 251 #if ENABLE(JIT)
 252     StructureStubInfo* addStubInfo(AccessType);
 253     JITAddIC* addJITAddIC(ArithProfile*);
 254     JITMulIC* addJITMulIC(ArithProfile*);
 255     JITNegIC* addJITNegIC(ArithProfile*);
 256     JITSubIC* addJITSubIC(ArithProfile*);
 257     Bag<StructureStubInfo>::iterator stubInfoBegin() { return m_stubInfos.begin(); }
 258     Bag<StructureStubInfo>::iterator stubInfoEnd() { return m_stubInfos.end(); }
 259
 260     // O(n) operation. Use getStubInfoMap() unless you really only intend to get one
 261     // stub info.
 262     StructureStubInfo* findStubInfo(CodeOrigin);
 263
 264     ByValInfo* addByValInfo();
 265
 266     CallLinkInfo* addCallLinkInfo();
 267     Bag<CallLinkInfo>::iterator callLinkInfosBegin() { return m_callLinkInfos.begin(); }
 268     Bag<CallLinkInfo>::iterator callLinkInfosEnd() { return m_callLinkInfos.end(); }
 269
 270     // This is a slow function call used primarily for compiling OSR exits in the case
 271     // that there had been inlining. Chances are if you want to use this, you're really
 272     // looking for a CallLinkInfoMap to amortize the cost of calling this.
 273     CallLinkInfo* getCallLinkInfoForBytecodeIndex(unsigned bytecodeIndex);
 274
 275     // We call this when we want to reattempt compiling something with the baseline JIT. Ideally
 276     // the baseline JIT would not add data to CodeBlock, but instead it would put its data into
 277     // a newly created JITCode, which could be thrown away if we bail on JIT compilation. Then we
 278     // would be able to get rid of this silly function.
 279     // FIXME: https://bugs.webkit.org/show_bug.cgi?id=159061
 280     void resetJITData();
 281 #endif // ENABLE(JIT)
 282
 283     void unlinkIncomingCalls();
 284
 285 #if ENABLE(JIT)
 286     void linkIncomingCall(ExecState* callerFrame, CallLinkInfo*);
 287     void linkIncomingPolymorphicCall(ExecState* callerFrame, PolymorphicCallNode*);
 288 #endif // ENABLE(JIT)
 289
 290     void linkIncomingCall(ExecState* callerFrame, LLIntCallLinkInfo*);
 291
 292     void setJITCodeMap(std::unique_ptr<CompactJITCodeMap> jitCodeMap)
 293     {
 294         m_jitCodeMap = WTFMove(jitCodeMap);
 295     }
 296     CompactJITCodeMap* jitCodeMap()
 297     {
 298         return m_jitCodeMap.get();
 299     }
 300
 301     static void clearLLIntGetByIdCache(Instruction*);
 302
 303     unsigned bytecodeOffset(Instruction* returnAddress)
 304     {
 305         RELEASE_ASSERT(returnAddress >= instructions().begin() && returnAddress < instructions().end());
 306         return static_cast<Instruction*>(returnAddress) - instructions().begin();
 307     }
 308
 309     typedef JSC::Instruction Instruction;
 310     typedef RefCountedArray<Instruction>& UnpackedInstructions;
 311
 312     unsigned numberOfInstructions() const { return m_instructions.size(); }
 313     RefCountedArray<Instruction>& instructions() { return m_instructions; }
 314     const RefCountedArray<Instruction>& instructions() const { return m_instructions; }
 315
 316     size_t predictedMachineCodeSize();
 317
 318     bool usesOpcode(OpcodeID);
 319
 320     unsigned instructionCount() const { return m_instructions.size(); }
 321
 322     // Exactly equivalent to codeBlock->ownerExecutable()->newReplacementCodeBlockFor(codeBlock->specializationKind())
 323     CodeBlock* newReplacement();
 324
 325     void setJITCode(Ref<JITCode>&& code)
 326     {
 327         ASSERT(heap()->isDeferred());
 328         heap()->reportExtraMemoryAllocated(code->size());
 329         ConcurrentJSLocker locker(m_lock);
 330         WTF::storeStoreFence(); // This is probably not needed because the lock will also do something similar, but it's good to be paranoid.
 331         m_jitCode = WTFMove(code);
 332     }
 333     RefPtr<JITCode> jitCode() { return m_jitCode; }
 334     static ptrdiff_t jitCodeOffset() { return OBJECT_OFFSETOF(CodeBlock, m_jitCode); }
 335     JITCode::JITType jitType() const
 336     {
 337         JITCode* jitCode = m_jitCode.get();
 338         WTF::loadLoadFence();
 339         JITCode::JITType result = JITCode::jitTypeFor(jitCode);
 340         WTF::loadLoadFence(); // This probably isn't needed. Oh well, paranoia is good.
 341         return result;
 342     }
 343
 344     bool hasBaselineJITProfiling() const
 345     {
 346         return jitType() == JITCode::BaselineJIT;
 347     }
 348
 349 #if ENABLE(JIT)
 350     CodeBlock* replacement();
 351
 352     DFG::CapabilityLevel computeCapabilityLevel();
 353     DFG::CapabilityLevel capabilityLevel();
 354     DFG::CapabilityLevel capabilityLevelState() { return static_cast<DFG::CapabilityLevel>(m_capabilityLevelState); }
 355
 356     bool hasOptimizedReplacement(JITCode::JITType typeToReplace);
 357     bool hasOptimizedReplacement(); // the typeToReplace is my JITType
 358 #endif
 359
 360     void jettison(Profiler::JettisonReason, ReoptimizationMode = DontCountReoptimization, const FireDetail* = nullptr);
 361
 362     ExecutableBase* ownerExecutable() const { return m_ownerExecutable.get(); }
 363     ScriptExecutable* ownerScriptExecutable() const { return jsCast<ScriptExecutable*>(m_ownerExecutable.get()); }
 364
 365     VM* vm() const { return m_vm; }
 366
 367     void setThisRegister(VirtualRegister thisRegister) { m_thisRegister = thisRegister; }
 368     VirtualRegister thisRegister() const { return m_thisRegister; }
 369
 370     bool usesEval() const { return m_unlinkedCode->usesEval(); }
 371
 372     void setScopeRegister(VirtualRegister scopeRegister)
 373     {
 374         ASSERT(scopeRegister.isLocal() || !scopeRegister.isValid());
 375         m_scopeRegister = scopeRegister;
 376     }
 377
 378     VirtualRegister scopeRegister() const
 379     {
 380         return m_scopeRegister;
 381     }
 382
 383     CodeType codeType() const
 384     {
 385         return static_cast<CodeType>(m_codeType);
 386     }
 387
 388     PutPropertySlot::Context putByIdContext() const
 389     {
 390         if (codeType() == EvalCode)
 391             return PutPropertySlot::PutByIdEval;
 392         return PutPropertySlot::PutById;
 393     }
 394
 395     SourceProvider* source() const { return m_source.get(); }
 396     unsigned sourceOffset() const { return m_sourceOffset; }
 397     unsigned firstLineColumnOffset() const { return m_firstLineColumnOffset; }
 398
 399     size_t numberOfJumpTargets() const { return m_unlinkedCode->numberOfJumpTargets(); }
 400     unsigned jumpTarget(int index) const { return m_unlinkedCode->jumpTarget(index); }
 401
 402     String nameForRegister(VirtualRegister);
 403
 404     unsigned numberOfArgumentValueProfiles()
 405     {
 406         ASSERT(m_numParameters >= 0);
 407         ASSERT(m_argumentValueProfiles.size() == static_cast<unsigned>(m_numParameters));
 408         return m_argumentValueProfiles.size();
 409     }
 410     ValueProfile& valueProfileForArgument(unsigned argumentIndex)
 411     {
 412         ValueProfile& result = m_argumentValueProfiles[argumentIndex];
 413         ASSERT(result.m_bytecodeOffset == -1);
 414         return result;
 415     }
 416
 417     unsigned numberOfValueProfiles() { return m_valueProfiles.size(); }
 418     ValueProfile& valueProfile(int index) { return m_valueProfiles[index]; }
 419     ValueProfile& valueProfileForBytecodeOffset(int bytecodeOffset);
 420     ValueProfile* tryGetValueProfileForBytecodeOffset(int bytecodeOffset);
 421     SpeculatedType valueProfilePredictionForBytecodeOffset(const ConcurrentJSLocker& locker, int bytecodeOffset)
 422     {
 423         if (ValueProfile* valueProfile = tryGetValueProfileForBytecodeOffset(bytecodeOffset))
 424             return valueProfile->computeUpdatedPrediction(locker);
 425         return SpecNone;
 426     }
 427
 428     unsigned totalNumberOfValueProfiles()
 429     {
 430         return numberOfArgumentValueProfiles() + numberOfValueProfiles();
 431     }
 432     ValueProfile& getFromAllValueProfiles(unsigned index)
 433     {
 434         if (index < numberOfArgumentValueProfiles())
 435             return valueProfileForArgument(index);
 436         return valueProfile(index - numberOfArgumentValueProfiles());
 437     }
 438
 439     RareCaseProfile* addRareCaseProfile(int bytecodeOffset);
 440     unsigned numberOfRareCaseProfiles() { return m_rareCaseProfiles.size(); }
 441     RareCaseProfile* rareCaseProfileForBytecodeOffset(int bytecodeOffset);
 442     unsigned rareCaseProfileCountForBytecodeOffset(int bytecodeOffset);
 443
 444     bool likelyToTakeSlowCase(int bytecodeOffset)
 445     {
 446         if (!hasBaselineJITProfiling())
 447             return false;
 448         unsigned value = rareCaseProfileCountForBytecodeOffset(bytecodeOffset);
 449         return value >= Options::likelyToTakeSlowCaseMinimumCount();
 450     }
 451
 452     bool couldTakeSlowCase(int bytecodeOffset)
 453     {
 454         if (!hasBaselineJITProfiling())
 455             return false;
 456         unsigned value = rareCaseProfileCountForBytecodeOffset(bytecodeOffset);
 457         return value >= Options::couldTakeSlowCaseMinimumCount();
 458     }
 459
 460     ArithProfile* arithProfileForBytecodeOffset(int bytecodeOffset);
 461     ArithProfile* arithProfileForPC(Instruction*);
 462
 463     bool couldTakeSpecialFastCase(int bytecodeOffset);
 464
 465     unsigned numberOfArrayProfiles() const { return m_arrayProfiles.size(); }
 466     const ArrayProfileVector& arrayProfiles() { return m_arrayProfiles; }
 467     ArrayProfile* addArrayProfile(const ConcurrentJSLocker&, unsigned bytecodeOffset);
 468     ArrayProfile* addArrayProfile(unsigned bytecodeOffset);
 469     ArrayProfile* getArrayProfile(const ConcurrentJSLocker&, unsigned bytecodeOffset);
 470     ArrayProfile* getArrayProfile(unsigned bytecodeOffset);
 471     ArrayProfile* getOrAddArrayProfile(const ConcurrentJSLocker&, unsigned bytecodeOffset);
 472     ArrayProfile* getOrAddArrayProfile(unsigned bytecodeOffset);
 473
 474     // Exception handling support
 475
 476     size_t numberOfExceptionHandlers() const { return m_rareData ? m_rareData->m_exceptionHandlers.size() : 0; }
 477     HandlerInfo& exceptionHandler(int index) { RELEASE_ASSERT(m_rareData); return m_rareData->m_exceptionHandlers[index]; }
 478
 479     bool hasExpressionInfo() { return m_unlinkedCode->hasExpressionInfo(); }
 480
 481 #if ENABLE(DFG_JIT)
 482     Vector<CodeOrigin, 0, UnsafeVectorOverflow>& codeOrigins();
 483
 484     // Having code origins implies that there has been some inlining.
 485     bool hasCodeOrigins()
 486     {
 487         return JITCode::isOptimizingJIT(jitType());
 488     }
 489
 490     bool canGetCodeOrigin(CallSiteIndex index)
 491     {
 492         if (!hasCodeOrigins())
 493             return false;
 494         return index.bits() < codeOrigins().size();
 495     }
 496
 497     CodeOrigin codeOrigin(CallSiteIndex index)
 498     {
 499         return codeOrigins()[index.bits()];
 500     }
 501
 502     bool addFrequentExitSite(const DFG::FrequentExitSite& site)
 503     {
 504         ASSERT(JITCode::isBaselineCode(jitType()));
 505         ConcurrentJSLocker locker(m_lock);
 506         return m_exitProfile.add(locker, this, site);
 507     }
 508
 509     bool hasExitSite(const ConcurrentJSLocker& locker, const DFG::FrequentExitSite& site) const
 510     {
 511         return m_exitProfile.hasExitSite(locker, site);
 512     }
 513     bool hasExitSite(const DFG::FrequentExitSite& site) const
 514     {
 515         ConcurrentJSLocker locker(m_lock);
 516         return hasExitSite(locker, site);
 517     }
 518
 519     DFG::ExitProfile& exitProfile() { return m_exitProfile; }
 520
 521     CompressedLazyOperandValueProfileHolder& lazyOperandValueProfiles()
 522     {
 523         return m_lazyOperandValueProfiles;
 524     }
 525 #endif // ENABLE(DFG_JIT)
 526
 527     // Constant Pool
 528 #if ENABLE(DFG_JIT)
 529     size_t numberOfIdentifiers() const { return m_unlinkedCode->numberOfIdentifiers() + numberOfDFGIdentifiers(); }
 530     size_t numberOfDFGIdentifiers() const;
 531     const Identifier& identifier(int index) const;
 532 #else
 533     size_t numberOfIdentifiers() const { return m_unlinkedCode->numberOfIdentifiers(); }
 534     const Identifier& identifier(int index) const { return m_unlinkedCode->identifier(index); }
 535 #endif
 536
 537     Vector<WriteBarrier<Unknown>>& constants() { return m_constantRegisters; }
 538     Vector<SourceCodeRepresentation>& constantsSourceCodeRepresentation() { return m_constantsSourceCodeRepresentation; }
 539     unsigned addConstant(JSValue v)
 540     {
 541         unsigned result = m_constantRegisters.size();
 542         m_constantRegisters.append(WriteBarrier<Unknown>());
 543         m_constantRegisters.last().set(*m_vm, this, v);
 544         m_constantsSourceCodeRepresentation.append(SourceCodeRepresentation::Other);
 545         return result;
 546     }
 547
 548     unsigned addConstantLazily()
 549     {
 550         unsigned result = m_constantRegisters.size();
 551         m_constantRegisters.append(WriteBarrier<Unknown>());
 552         m_constantsSourceCodeRepresentation.append(SourceCodeRepresentation::Other);
 553         return result;
 554     }
 555
 556     const Vector<WriteBarrier<Unknown>>& constantRegisters() { return m_constantRegisters; }
 557     WriteBarrier<Unknown>& constantRegister(int index) { return m_constantRegisters[index - FirstConstantRegisterIndex]; }
 558     static ALWAYS_INLINE bool isConstantRegisterIndex(int index) { return index >= FirstConstantRegisterIndex; }
 559     ALWAYS_INLINE JSValue getConstant(int index) const { return m_constantRegisters[index - FirstConstantRegisterIndex].get(); }
 560     ALWAYS_INLINE SourceCodeRepresentation constantSourceCodeRepresentation(int index) const { return m_constantsSourceCodeRepresentation[index - FirstConstantRegisterIndex]; }
 561
 562     FunctionExecutable* functionDecl(int index) { return m_functionDecls[index].get(); }
 563     int numberOfFunctionDecls() { return m_functionDecls.size(); }
 564     FunctionExecutable* functionExpr(int index) { return m_functionExprs[index].get(); }
 565
 566     RegExp* regexp(int index) const { return m_unlinkedCode->regexp(index); }
 567     unsigned numberOfRegExps() const { return m_unlinkedCode->numberOfRegExps(); }
 568
 569     const Vector<BitVector>& bitVectors() const { return m_unlinkedCode->bitVectors(); }
 570     const BitVector& bitVector(size_t i) { return m_unlinkedCode->bitVector(i); }
 571
 572     unsigned numberOfConstantBuffers() const
 573     {
 574         if (!m_rareData)
 575             return 0;
 576         return m_rareData->m_constantBuffers.size();
 577     }
 578     unsigned addConstantBuffer(const Vector<JSValue>& buffer)
 579     {
 580         createRareDataIfNecessary();
 581         unsigned size = m_rareData->m_constantBuffers.size();
 582         m_rareData->m_constantBuffers.append(buffer);
 583         return size;
 584     }
 585
 586     Vector<JSValue>& constantBufferAsVector(unsigned index)
 587     {
 588         ASSERT(m_rareData);
 589         return m_rareData->m_constantBuffers[index];
 590     }
 591     JSValue* constantBuffer(unsigned index)
 592     {
 593         return constantBufferAsVector(index).data();
 594     }
 595
 596     Heap* heap() const { return &m_vm->heap; }
 597     JSGlobalObject* globalObject() { return m_globalObject.get(); }
 598
 599     JSGlobalObject* globalObjectFor(CodeOrigin);
 600
 601     BytecodeLivenessAnalysis& livenessAnalysis()
 602     {
 603         {
 604             ConcurrentJSLocker locker(m_lock);
 605             if (!!m_livenessAnalysis)
 606                 return *m_livenessAnalysis;
 607         }
 608         return livenessAnalysisSlow();
 609     }
 610
 611     void validate();
 612
 613     // Jump Tables
 614
 615     size_t numberOfSwitchJumpTables() const { return m_rareData ? m_rareData->m_switchJumpTables.size() : 0; }
 616     SimpleJumpTable& addSwitchJumpTable() { createRareDataIfNecessary(); m_rareData->m_switchJumpTables.append(SimpleJumpTable()); return m_rareData->m_switchJumpTables.last(); }
 617     SimpleJumpTable& switchJumpTable(int tableIndex) { RELEASE_ASSERT(m_rareData); return m_rareData->m_switchJumpTables[tableIndex]; }
 618     void clearSwitchJumpTables()
 619     {
 620         if (!m_rareData)
 621             return;
 622         m_rareData->m_switchJumpTables.clear();
 623     }
 624
 625     size_t numberOfStringSwitchJumpTables() const { return m_rareData ? m_rareData->m_stringSwitchJumpTables.size() : 0; }
 626     StringJumpTable& addStringSwitchJumpTable() { createRareDataIfNecessary(); m_rareData->m_stringSwitchJumpTables.append(StringJumpTable()); return m_rareData->m_stringSwitchJumpTables.last(); }
 627     StringJumpTable& stringSwitchJumpTable(int tableIndex) { RELEASE_ASSERT(m_rareData); return m_rareData->m_stringSwitchJumpTables[tableIndex]; }
 628
 629     DirectEvalCodeCache& directEvalCodeCache() { createRareDataIfNecessary(); return m_rareData->m_directEvalCodeCache; }
 630
 631     enum ShrinkMode {
 632         // Shrink prior to generating machine code that may point directly into vectors.
 633         EarlyShrink,
 634
 635         // Shrink after generating machine code, and after possibly creating new vectors
 636         // and appending to others. At this time it is not safe to shrink certain vectors
 637         // because we would have generated machine code that references them directly.
 638         LateShrink
 639     };
 640     void shrinkToFit(ShrinkMode);
 641
 642     // Functions for controlling when JITting kicks in, in a mixed mode
 643     // execution world.
 644
 645     bool checkIfJITThresholdReached()
 646     {
 647         return m_llintExecuteCounter.checkIfThresholdCrossedAndSet(this);
 648     }
 649
 650     void dontJITAnytimeSoon()
 651     {
 652         m_llintExecuteCounter.deferIndefinitely();
 653     }
 654
 655     int32_t thresholdForJIT(int32_t threshold);
 656     void jitAfterWarmUp();
 657     void jitSoon();
 658
 659     const BaselineExecutionCounter& llintExecuteCounter() const
 660     {
 661         return m_llintExecuteCounter;
 662     }
 663
 664     typedef HashMap<Structure*, Bag<LLIntPrototypeLoadAdaptiveStructureWatchpoint>> StructureWatchpointMap;
 665     StructureWatchpointMap& llintGetByIdWatchpointMap() { return m_llintGetByIdWatchpointMap; }
 666
 667     // Functions for controlling when tiered compilation kicks in. This
 668     // controls both when the optimizing compiler is invoked and when OSR
 669     // entry happens. Two triggers exist: the loop trigger and the return
 670     // trigger. In either case, when an addition to m_jitExecuteCounter
 671     // causes it to become non-negative, the optimizing compiler is
 672     // invoked. This includes a fast check to see if this CodeBlock has
 673     // already been optimized (i.e. replacement() returns a CodeBlock
 674     // that was optimized with a higher tier JIT than this one). In the
 675     // case of the loop trigger, if the optimized compilation succeeds
 676     // (or has already succeeded in the past) then OSR is attempted to
 677     // redirect program flow into the optimized code.
 678
 679     // These functions are called from within the optimization triggers,
 680     // and are used as a single point at which we define the heuristics
 681     // for how much warm-up is mandated before the next optimization
 682     // trigger files. All CodeBlocks start out with optimizeAfterWarmUp(),
 683     // as this is called from the CodeBlock constructor.
 684
 685     // When we observe a lot of speculation failures, we trigger a
 686     // reoptimization. But each time, we increase the optimization trigger
 687     // to avoid thrashing.
 688     JS_EXPORT_PRIVATE unsigned reoptimizationRetryCounter() const;
 689     void countReoptimization();
 690 #if ENABLE(JIT)
 691     static unsigned numberOfLLIntBaselineCalleeSaveRegisters() { return RegisterSet::llintBaselineCalleeSaveRegisters().numberOfSetRegisters(); }
 692     static size_t llintBaselineCalleeSaveSpaceAsVirtualRegisters();
 693     size_t calleeSaveSpaceAsVirtualRegisters();
 694
 695     unsigned numberOfDFGCompiles();
 696
 697     int32_t codeTypeThresholdMultiplier() const;
 698
 699     int32_t adjustedCounterValue(int32_t desiredThreshold);
 700
 701     int32_t* addressOfJITExecuteCounter()
 702     {
 703         return &m_jitExecuteCounter.m_counter;
 704     }
 705
 706     static ptrdiff_t offsetOfJITExecuteCounter() { return OBJECT_OFFSETOF(CodeBlock, m_jitExecuteCounter) + OBJECT_OFFSETOF(BaselineExecutionCounter, m_counter); }
 707     static ptrdiff_t offsetOfJITExecutionActiveThreshold() { return OBJECT_OFFSETOF(CodeBlock, m_jitExecuteCounter) + OBJECT_OFFSETOF(BaselineExecutionCounter, m_activeThreshold); }
 708     static ptrdiff_t offsetOfJITExecutionTotalCount() { return OBJECT_OFFSETOF(CodeBlock, m_jitExecuteCounter) + OBJECT_OFFSETOF(BaselineExecutionCounter, m_totalCount); }
 709
 710     const BaselineExecutionCounter& jitExecuteCounter() const { return m_jitExecuteCounter; }
 711
 712     unsigned optimizationDelayCounter() const { return m_optimizationDelayCounter; }
 713
 714     // Check if the optimization threshold has been reached, and if not,
 715     // adjust the heuristics accordingly. Returns true if the threshold has
 716     // been reached.
 717     bool checkIfOptimizationThresholdReached();
 718
 719     // Call this to force the next optimization trigger to fire. This is
 720     // rarely wise, since optimization triggers are typically more
 721     // expensive than executing baseline code.
 722     void optimizeNextInvocation();
 723
 724     // Call this to prevent optimization from happening again. Note that
 725     // optimization will still happen after roughly 2^29 invocations,
 726     // so this is really meant to delay that as much as possible. This
 727     // is called if optimization failed, and we expect it to fail in
 728     // the future as well.
 729     void dontOptimizeAnytimeSoon();
 730
 731     // Call this to reinitialize the counter to its starting state,
 732     // forcing a warm-up to happen before the next optimization trigger
 733     // fires. This is called in the CodeBlock constructor. It also
 734     // makes sense to call this if an OSR exit occurred. Note that
 735     // OSR exit code is code generated, so the value of the execute
 736     // counter that this corresponds to is also available directly.
 737     void optimizeAfterWarmUp();
 738
 739     // Call this to force an optimization trigger to fire only after
 740     // a lot of warm-up.
 741     void optimizeAfterLongWarmUp();
 742
 743     // Call this to cause an optimization trigger to fire soon, but
 744     // not necessarily the next one. This makes sense if optimization
 745     // succeeds. Successfuly optimization means that all calls are
 746     // relinked to the optimized code, so this only affects call
 747     // frames that are still executing this CodeBlock. The value here
 748     // is tuned to strike a balance between the cost of OSR entry
 749     // (which is too high to warrant making every loop back edge to
 750     // trigger OSR immediately) and the cost of executing baseline
 751     // code (which is high enough that we don't necessarily want to
 752     // have a full warm-up). The intuition for calling this instead of
 753     // optimizeNextInvocation() is for the case of recursive functions
 754     // with loops. Consider that there may be N call frames of some
 755     // recursive function, for a reasonably large value of N. The top
 756     // one triggers optimization, and then returns, and then all of
 757     // the others return. We don't want optimization to be triggered on
 758     // each return, as that would be superfluous. It only makes sense
 759     // to trigger optimization if one of those functions becomes hot
 760     // in the baseline code.
 761     void optimizeSoon();
 762
 763     void forceOptimizationSlowPathConcurrently();
 764
 765     void setOptimizationThresholdBasedOnCompilationResult(CompilationResult);
 766
 767     uint32_t osrExitCounter() const { return m_osrExitCounter; }
 768
 769     void countOSRExit() { m_osrExitCounter++; }
 770
 771     enum class OptimizeAction { None, ReoptimizeNow };
 772 #if ENABLE(DFG_JIT)
 773     OptimizeAction updateOSRExitCounterAndCheckIfNeedToReoptimize(DFG::OSRExitState&);
 774 #endif
 775
 776     static ptrdiff_t offsetOfOSRExitCounter() { return OBJECT_OFFSETOF(CodeBlock, m_osrExitCounter); }
 777
 778     uint32_t adjustedExitCountThreshold(uint32_t desiredThreshold);
 779     uint32_t exitCountThresholdForReoptimization();
 780     uint32_t exitCountThresholdForReoptimizationFromLoop();
 781     bool shouldReoptimizeNow();
 782     bool shouldReoptimizeFromLoopNow();
 783
 784     void setCalleeSaveRegisters(RegisterSet);
 785     void setCalleeSaveRegisters(std::unique_ptr<RegisterAtOffsetList>);
 786
 787     RegisterAtOffsetList* calleeSaveRegisters() const { return m_calleeSaveRegisters.get(); }
 788 #else // No JIT
 789     static unsigned numberOfLLIntBaselineCalleeSaveRegisters() { return 0; }
 790     static size_t llintBaselineCalleeSaveSpaceAsVirtualRegisters() { return 0; };
 791     void optimizeAfterWarmUp() { }
 792     unsigned numberOfDFGCompiles() { return 0; }
 793 #endif
 794
 795     bool shouldOptimizeNow();
 796     void updateAllValueProfilePredictions();
 797     void updateAllArrayPredictions();
 798     void updateAllPredictions();
 799
 800     unsigned frameRegisterCount();
 801     int stackPointerOffset();
 802
 803     bool hasOpDebugForLineAndColumn(unsigned line, unsigned column);
 804
 805     bool hasDebuggerRequests() const { return m_debuggerRequests; }
 806     void* debuggerRequestsAddress() { return &m_debuggerRequests; }
 807
 808     void addBreakpoint(unsigned numBreakpoints);
 809     void removeBreakpoint(unsigned numBreakpoints)
 810     {
 811         ASSERT(m_numBreakpoints >= numBreakpoints);
 812         m_numBreakpoints -= numBreakpoints;
 813     }
 814
 815     enum SteppingMode {
 816         SteppingModeDisabled,
 817         SteppingModeEnabled
 818     };
 819     void setSteppingMode(SteppingMode);
 820
 821     void clearDebuggerRequests()
 822     {
 823         m_steppingMode = SteppingModeDisabled;
 824         m_numBreakpoints = 0;
 825     }
 826
 827     bool wasCompiledWithDebuggingOpcodes() const { return m_unlinkedCode->wasCompiledWithDebuggingOpcodes(); }
 828
 829     // FIXME: Make these remaining members private.
 830
 831     int m_numCalleeLocals;
 832     int m_numVars;
 833
 834     // This is intentionally public; it's the responsibility of anyone doing any
 835     // of the following to hold the lock:
 836     //
 837     // - Modifying any inline cache in this code block.
 838     //
 839     // - Quering any inline cache in this code block, from a thread other than
 840     //   the main thread.
 841     //
 842     // Additionally, it's only legal to modify the inline cache on the main
 843     // thread. This means that the main thread can query the inline cache without
 844     // locking. This is crucial since executing the inline cache is effectively
 845     // "querying" it.
 846     //
 847     // Another exception to the rules is that the GC can do whatever it wants
 848     // without holding any locks, because the GC is guaranteed to wait until any
 849     // concurrent compilation threads finish what they're doing.
 850     mutable ConcurrentJSLock m_lock;
 851
 852     bool m_visitWeaklyHasBeenCalled;
 853
 854     bool m_shouldAlwaysBeInlined; // Not a bitfield because the JIT wants to store to it.
 855
 856 #if ENABLE(JIT)
 857     unsigned m_capabilityLevelState : 2; // DFG::CapabilityLevel
 858 #endif
 859
 860     bool m_allTransitionsHaveBeenMarked : 1; // Initialized and used on every GC.
 861
 862     bool m_didFailJITCompilation : 1;
 863     bool m_didFailFTLCompilation : 1;
 864     bool m_hasBeenCompiledWithFTL : 1;
 865     bool m_isConstructor : 1;
 866     bool m_isStrictMode : 1;
 867     unsigned m_codeType : 2; // CodeType
 868
 869     // Internal methods for use by validation code. It would be private if it wasn't
 870     // for the fact that we use it from anonymous namespaces.
 871     void beginValidationDidFail();
 872     NO_RETURN_DUE_TO_CRASH void endValidationDidFail();
 873
 874     struct RareData {
 875         WTF_MAKE_FAST_ALLOCATED;
 876     public:
 877         Vector<HandlerInfo> m_exceptionHandlers;
 878
 879         // Buffers used for large array literals
 880         Vector<Vector<JSValue>> m_constantBuffers;
 881
 882         // Jump Tables
 883         Vector<SimpleJumpTable> m_switchJumpTables;
 884         Vector<StringJumpTable> m_stringSwitchJumpTables;
 885
 886         DirectEvalCodeCache m_directEvalCodeCache;
 887     };
 888
 889     void clearExceptionHandlers()
 890     {
 891         if (m_rareData)
 892             m_rareData->m_exceptionHandlers.clear();
 893     }
 894
 895     void appendExceptionHandler(const HandlerInfo& handler)
 896     {
 897         createRareDataIfNecessary(); // We may be handling the exception of an inlined call frame.
 898         m_rareData->m_exceptionHandlers.append(handler);
 899     }
 900
 901     CallSiteIndex newExceptionHandlingCallSiteIndex(CallSiteIndex originalCallSite);
 902
 903     void ensureCatchLivenessIsComputedForBytecodeOffset(unsigned bytecodeOffset)
 904     {
 905         if (!!m_instructions[bytecodeOffset + 3].u.pointer) {
 906 #if !ASSERT_DISABLED
 907             ConcurrentJSLocker locker(m_lock);
 908             bool found = false;
 909             for (auto& profile : m_catchProfiles) {
 910                 if (profile.get() == m_instructions[bytecodeOffset + 3].u.pointer) {
 911                     found = true;
 912                     break;
 913                 }
 914             }
 915             ASSERT(found);
 916 #endif
 917             return;
 918         }
 919
 920         ensureCatchLivenessIsComputedForBytecodeOffsetSlow(bytecodeOffset);
 921     }
 922
 923 #if ENABLE(JIT)
 924     void setPCToCodeOriginMap(std::unique_ptr<PCToCodeOriginMap>&&);
 925     std::optional<CodeOrigin> findPC(void* pc);
 926 #endif
 927
 928 protected:
 929     void finalizeLLIntInlineCaches();
 930     void finalizeBaselineJITInlineCaches();
 931
 932 #if ENABLE(DFG_JIT)
 933     void tallyFrequentExitSites();
 934 #else
 935     void tallyFrequentExitSites() { }
 936 #endif
 937
 938 private:
 939     friend class CodeBlockSet;
 940
 941     BytecodeLivenessAnalysis& livenessAnalysisSlow();
 942
 943     CodeBlock* specialOSREntryBlockOrNull();
 944
 945     void noticeIncomingCall(ExecState* callerFrame);
 946
 947     double optimizationThresholdScalingFactor();
 948
 949     void updateAllPredictionsAndCountLiveness(unsigned& numberOfLiveNonArgumentValueProfiles, unsigned& numberOfSamplesInProfiles);
 950
 951     void setConstantIdentifierSetRegisters(VM&, const Vector<ConstantIndentifierSetEntry>& constants);
 952
 953     void setConstantRegisters(const Vector<WriteBarrier<Unknown>>& constants, const Vector<SourceCodeRepresentation>& constantsSourceCodeRepresentation);
 954
 955     void replaceConstant(int index, JSValue value)
 956     {
 957         ASSERT(isConstantRegisterIndex(index) && static_cast<size_t>(index - FirstConstantRegisterIndex) < m_constantRegisters.size());
 958         m_constantRegisters[index - FirstConstantRegisterIndex].set(*m_vm, this, value);
 959     }
 960
 961     bool shouldVisitStrongly(const ConcurrentJSLocker&);
 962     bool shouldJettisonDueToWeakReference();
 963     bool shouldJettisonDueToOldAge(const ConcurrentJSLocker&);
 964
 965     void propagateTransitions(const ConcurrentJSLocker&, SlotVisitor&);
 966     void determineLiveness(const ConcurrentJSLocker&, SlotVisitor&);
 967
 968     void stronglyVisitStrongReferences(const ConcurrentJSLocker&, SlotVisitor&);
 969     void stronglyVisitWeakReferences(const ConcurrentJSLocker&, SlotVisitor&);
 970     void visitOSRExitTargets(const ConcurrentJSLocker&, SlotVisitor&);
 971
 972     std::chrono::milliseconds timeSinceCreation()
 973     {
 974         return std::chrono::duration_cast<std::chrono::milliseconds>(
 975             std::chrono::steady_clock::now() - m_creationTime);
 976     }
 977
 978     void createRareDataIfNecessary()
 979     {
 980         if (!m_rareData)
 981             m_rareData = std::make_unique<RareData>();
 982     }
 983
 984     void insertBasicBlockBoundariesForControlFlowProfiler(RefCountedArray<Instruction>&);
 985     void ensureCatchLivenessIsComputedForBytecodeOffsetSlow(unsigned);
 986
 987     WriteBarrier<UnlinkedCodeBlock> m_unlinkedCode;
 988     int m_numParameters;
 989     int m_numberOfArgumentsToSkip { 0 };
 990     union {
 991         unsigned m_debuggerRequests;
 992         struct {
 993             unsigned m_hasDebuggerStatement : 1;
 994             unsigned m_steppingMode : 1;
 995             unsigned m_numBreakpoints : 30;
 996         };
 997     };
 998     WriteBarrier<ExecutableBase> m_ownerExecutable;
 999     VM* m_vm;
1000
1001     RefCountedArray<Instruction> m_instructions;
1002     VirtualRegister m_thisRegister;
1003     VirtualRegister m_scopeRegister;
1004     mutable CodeBlockHash m_hash;
1005
1006     RefPtr<SourceProvider> m_source;
1007     unsigned m_sourceOffset;
1008     unsigned m_firstLineColumnOffset;
1009
1010     RefCountedArray<LLIntCallLinkInfo> m_llintCallLinkInfos;
1011     SentinelLinkedList<LLIntCallLinkInfo, BasicRawSentinelNode<LLIntCallLinkInfo>> m_incomingLLIntCalls;
1012     StructureWatchpointMap m_llintGetByIdWatchpointMap;
1013     RefPtr<JITCode> m_jitCode;
1014 #if ENABLE(JIT)
1015     std::unique_ptr<RegisterAtOffsetList> m_calleeSaveRegisters;
1016     Bag<StructureStubInfo> m_stubInfos;
1017     Bag<JITAddIC> m_addICs;
1018     Bag<JITMulIC> m_mulICs;
1019     Bag<JITNegIC> m_negICs;
1020     Bag<JITSubIC> m_subICs;
1021     Bag<ByValInfo> m_byValInfos;
1022     Bag<CallLinkInfo> m_callLinkInfos;
1023     SentinelLinkedList<CallLinkInfo, BasicRawSentinelNode<CallLinkInfo>> m_incomingCalls;
1024     SentinelLinkedList<PolymorphicCallNode, BasicRawSentinelNode<PolymorphicCallNode>> m_incomingPolymorphicCalls;
1025     std::unique_ptr<PCToCodeOriginMap> m_pcToCodeOriginMap;
1026 #endif
1027     std::unique_ptr<CompactJITCodeMap> m_jitCodeMap;
1028 #if ENABLE(DFG_JIT)
1029     // This is relevant to non-DFG code blocks that serve as the profiled code block
1030     // for DFG code blocks.
1031     DFG::ExitProfile m_exitProfile;
1032     CompressedLazyOperandValueProfileHolder m_lazyOperandValueProfiles;
1033 #endif
1034     RefCountedArray<ValueProfile> m_argumentValueProfiles;
1035     RefCountedArray<ValueProfile> m_valueProfiles;
1036     Vector<std::unique_ptr<ValueProfileAndOperandBuffer>> m_catchProfiles;
1037     SegmentedVector<RareCaseProfile, 8> m_rareCaseProfiles;
1038     RefCountedArray<ArrayAllocationProfile> m_arrayAllocationProfiles;
1039     ArrayProfileVector m_arrayProfiles;
1040     RefCountedArray<ObjectAllocationProfile> m_objectAllocationProfiles;
1041
1042     // Constant Pool
1043     COMPILE_ASSERT(sizeof(Register) == sizeof(WriteBarrier<Unknown>), Register_must_be_same_size_as_WriteBarrier_Unknown);
1044     // TODO: This could just be a pointer to m_unlinkedCodeBlock's data, but the DFG mutates
1045     // it, so we're stuck with it for now.
1046     Vector<WriteBarrier<Unknown>> m_constantRegisters;
1047     Vector<SourceCodeRepresentation> m_constantsSourceCodeRepresentation;
1048     RefCountedArray<WriteBarrier<FunctionExecutable>> m_functionDecls;
1049     RefCountedArray<WriteBarrier<FunctionExecutable>> m_functionExprs;
1050
1051     WriteBarrier<CodeBlock> m_alternative;
1052
1053     BaselineExecutionCounter m_llintExecuteCounter;
1054
1055     BaselineExecutionCounter m_jitExecuteCounter;
1056     uint32_t m_osrExitCounter;
1057     uint16_t m_optimizationDelayCounter;
1058     uint16_t m_reoptimizationRetryCounter;
1059
1060     std::chrono::steady_clock::time_point m_creationTime;
1061
1062     std::unique_ptr<BytecodeLivenessAnalysis> m_livenessAnalysis;
1063
1064     std::unique_ptr<RareData> m_rareData;
1065
1066     UnconditionalFinalizer m_unconditionalFinalizer;
1067     WeakReferenceHarvester m_weakReferenceHarvester;
1068 };
1069
1070 inline Register& ExecState::r(int index)
1071 {
1072     CodeBlock* codeBlock = this->codeBlock();
1073     if (codeBlock->isConstantRegisterIndex(index))
1074         return *reinterpret_cast<Register*>(&codeBlock->constantRegister(index));
1075     return this[index];
1076 }
1077
1078 inline Register& ExecState::r(VirtualRegister reg)
1079 {
1080     return r(reg.offset());
1081 }
1082
1083 inline Register& ExecState::uncheckedR(int index)
1084 {
1085     RELEASE_ASSERT(index < FirstConstantRegisterIndex);
1086     return this[index];
1087 }
1088
1089 inline Register& ExecState::uncheckedR(VirtualRegister reg)
1090 {
1091     return uncheckedR(reg.offset());
1092 }
1093
1094 inline void CodeBlock::clearVisitWeaklyHasBeenCalled()
1095 {
1096     m_visitWeaklyHasBeenCalled = false;
1097 }
1098
1099 template <typename ExecutableType>
1100 JSObject* ScriptExecutable::prepareForExecution(VM& vm, JSFunction* function, JSScope* scope, CodeSpecializationKind kind, CodeBlock*& resultCodeBlock)
1101 {
1102     if (hasJITCodeFor(kind)) {
1103         if (std::is_same<ExecutableType, EvalExecutable>::value)
1104             resultCodeBlock = jsCast<CodeBlock*>(jsCast<EvalExecutable*>(this)->codeBlock());
1105         else if (std::is_same<ExecutableType, ProgramExecutable>::value)
1106             resultCodeBlock = jsCast<CodeBlock*>(jsCast<ProgramExecutable*>(this)->codeBlock());
1107         else if (std::is_same<ExecutableType, ModuleProgramExecutable>::value)
1108             resultCodeBlock = jsCast<CodeBlock*>(jsCast<ModuleProgramExecutable*>(this)->codeBlock());
1109         else if (std::is_same<ExecutableType, FunctionExecutable>::value)
1110             resultCodeBlock = jsCast<CodeBlock*>(jsCast<FunctionExecutable*>(this)->codeBlockFor(kind));
1111         else
1112             RELEASE_ASSERT_NOT_REACHED();
1113         return nullptr;
1114     }
1115     return prepareForExecutionImpl(vm, function, scope, kind, resultCodeBlock);
1116 }
1117
1118 #define CODEBLOCK_LOG_EVENT(codeBlock, summary, details) \
1119     (codeBlock->vm()->logEvent(codeBlock, summary, [&] () { return toCString details; }))
1120
1121
1122 void setPrinter(Printer::PrintRecord&, CodeBlock*);
1123
1124 } // namespace JSC
1125
1126 namespace WTF {
1127
1128 JS_EXPORT_PRIVATE void printInternal(PrintStream&, JSC::CodeBlock*);
1129
1130 } // namespace WTF