CodeBlock.h 47.9 KB
Newer Older
1
/*
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
 * Copyright (C) 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc. All rights reserved.
 * Copyright (C) 2008 Cameron Zwarich <cwzwarich@uwaterloo.ca>
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1.  Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 * 2.  Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
 *     its contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
29

30 31 32
#ifndef CodeBlock_h
#define CodeBlock_h

33
#include "ArrayProfile.h"
34
#include "ByValInfo.h"
35
#include "BytecodeConventions.h"
36
#include "BytecodeLivenessAnalysis.h"
37 38
#include "CallLinkInfo.h"
#include "CallReturnOffsetToBytecodeOffset.h"
39
#include "CodeBlockHash.h"
40
#include "CodeBlockSet.h"
41
#include "ConcurrentJITLock.h"
42
#include "CodeOrigin.h"
43
#include "CodeType.h"
44
#include "CompactJITCodeMap.h"
45
#include "DFGCommon.h"
46
#include "DFGCommonData.h"
47
#include "DFGExitProfile.h"
48
#include "DFGMinifiedGraph.h"
49
#include "DFGOSREntry.h"
50
#include "DFGOSRExit.h"
51
#include "DFGVariableEventStream.h"
52
#include "DeferredCompilationCallback.h"
53
#include "EvalCodeCache.h"
54
#include "ExecutionCounter.h"
55 56
#include "ExpressionRangeInfo.h"
#include "HandlerInfo.h"
57
#include "ObjectAllocationProfile.h"
58
#include "Options.h"
59
#include "Operations.h"
60
#include "PutPropertySlot.h"
61
#include "Instruction.h"
62
#include "JITCode.h"
63
#include "JITWriteBarrier.h"
64
#include "JSGlobalObject.h"
65
#include "JumpTable.h"
66
#include "LLIntCallLinkInfo.h"
67
#include "LazyOperandValueProfile.h"
68
#include "LineInfo.h"
69
#include "ProfilerCompilation.h"
70
#include "RegExpObject.h"
71
#include "StructureStubInfo.h"
72
#include "UnconditionalFinalizer.h"
73
#include "ValueProfile.h"
74
#include "VirtualRegister.h"
75
#include "Watchpoint.h"
76
#include <wtf/Bag.h>
77
#include <wtf/FastMalloc.h>
78
#include <wtf/PassOwnPtr.h>
79
#include <wtf/RefCountedArray.h>
80
#include <wtf/RefPtr.h>
81
#include <wtf/SegmentedVector.h>
82
#include <wtf/Vector.h>
83
#include <wtf/text/WTFString.h>
84

85
namespace JSC {
86

87 88 89
class ExecState;
class LLIntOffsetsExtractor;
class RepatchBuffer;
90

91
inline VirtualRegister unmodifiedArgumentsRegister(VirtualRegister argumentsRegister) { return VirtualRegister(argumentsRegister.offset() + 1); }
92

93
static ALWAYS_INLINE int missingThisObjectMarker() { return std::numeric_limits<int>::max(); }
94

95 96
enum ReoptimizationMode { DontCountReoptimization, CountReoptimization };

97
class CodeBlock : public ThreadSafeRefCounted<CodeBlock>, public UnconditionalFinalizer, public WeakReferenceHarvester {
98
    WTF_MAKE_FAST_ALLOCATED;
99
    friend class BytecodeLivenessAnalysis;
100 101 102 103 104 105
    friend class JIT;
    friend class LLIntOffsetsExtractor;
public:
    enum CopyParsedBlockTag { CopyParsedBlock };
protected:
    CodeBlock(CopyParsedBlockTag, CodeBlock& other);
106 107
        
    CodeBlock(ScriptExecutable* ownerExecutable, UnlinkedCodeBlock*, JSScope*, PassRefPtr<SourceProvider>, unsigned sourceOffset, unsigned firstLineColumnOffset);
108

109 110
    WriteBarrier<JSGlobalObject> m_globalObject;
    Heap* m_heap;
111

112 113
public:
    JS_EXPORT_PRIVATE virtual ~CodeBlock();
114

115
    UnlinkedCodeBlock* unlinkedCodeBlock() const { return m_unlinkedCode.get(); }
116

117 118
    CString inferredName() const;
    CodeBlockHash hash() const;
119 120
    bool hasHash() const;
    bool isSafeToComputeHash() const;
121 122 123 124
    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.
    CString sourceCodeOnOneLine() const; // As sourceCodeForTools(), but replaces all whitespace runs with a single space.
    void dumpAssumingJITType(PrintStream&, JITCode::JITType) const;
    void dump(PrintStream&) const;
125

126 127
    int numParameters() const { return m_numParameters; }
    void setNumParameters(int newValue);
128

129 130
    int* addressOfNumParameters() { return &m_numParameters; }
    static ptrdiff_t offsetOfNumParameters() { return OBJECT_OFFSETOF(CodeBlock, m_numParameters); }
131

132 133 134 135 136 137 138 139 140
    CodeBlock* alternative() { return m_alternative.get(); }
    PassRefPtr<CodeBlock> releaseAlternative() { return m_alternative.release(); }
    void setAlternative(PassRefPtr<CodeBlock> alternative) { m_alternative = alternative; }
    
    CodeSpecializationKind specializationKind() const
    {
        return specializationFromIsConstruct(m_isConstructor);
    }
    
141
    CodeBlock* baselineAlternative();
142 143 144
    
    // FIXME: Get rid of this.
    // https://bugs.webkit.org/show_bug.cgi?id=123677
145
    CodeBlock* baselineVersion();
146

147
    void visitAggregate(SlotVisitor&);
148

149
    static void dumpStatistics();
150

151 152 153 154 155 156
    void dumpBytecode(PrintStream& = WTF::dataFile());
    void dumpBytecode(PrintStream&, unsigned bytecodeOffset);
    void printStructures(PrintStream&, const Instruction*);
    void printStructure(PrintStream&, const char* name, const Instruction*, int operand);

    bool isStrictMode() const { return m_isStrictMode; }
157
    ECMAMode ecmaMode() const { return isStrictMode() ? StrictMode : NotStrictMode; }
158 159 160

    inline bool isKnownNotImmediate(int index)
    {
161
        if (index == m_thisRegister.offset() && !m_isStrictMode)
162 163 164 165
            return true;

        if (isConstantRegisterIndex(index))
            return getConstant(index).isCell();
166

167 168 169 170 171 172 173 174 175 176 177 178 179
        return false;
    }

    ALWAYS_INLINE bool isTemporaryRegisterIndex(int index)
    {
        return index >= m_numVars;
    }

    HandlerInfo* handlerForBytecodeOffset(unsigned bytecodeOffset);
    unsigned lineNumberForBytecodeOffset(unsigned bytecodeOffset);
    unsigned columnNumberForBytecodeOffset(unsigned bytecodeOffset);
    void expressionRangeForBytecodeOffset(unsigned bytecodeOffset, int& divot,
                                          int& startOffset, int& endOffset, unsigned& line, unsigned& column);
weinig@apple.com's avatar
weinig@apple.com committed
180

181
#if ENABLE(JIT)
182 183 184
    StructureStubInfo* addStubInfo();
    Bag<StructureStubInfo>::iterator begin() { return m_stubInfos.begin(); }
    Bag<StructureStubInfo>::iterator end() { return m_stubInfos.end(); }
185

186
    void resetStub(StructureStubInfo&);
187 188
    
    void getStubInfoMap(const ConcurrentJITLocker&, StubInfoMap& result);
189

190 191 192 193
    ByValInfo& getByValInfo(unsigned bytecodeIndex)
    {
        return *(binarySearch<ByValInfo, unsigned>(m_byValInfos, m_byValInfos.size(), bytecodeIndex, getByValInfoBytecodeIndex));
    }
194

195 196 197 198
    CallLinkInfo& getCallLinkInfo(ReturnAddressPtr returnAddress)
    {
        return *(binarySearch<CallLinkInfo, void*>(m_callLinkInfos, m_callLinkInfos.size(), returnAddress.value(), getCallLinkInfoReturnLocation));
    }
199

200 201
    CallLinkInfo& getCallLinkInfo(unsigned bytecodeIndex)
    {
202
        ASSERT(!JITCode::isOptimizingJIT(jitType()));
203 204
        return *(binarySearch<CallLinkInfo, unsigned>(m_callLinkInfos, m_callLinkInfos.size(), bytecodeIndex, getCallLinkInfoBytecodeIndex));
    }
205
#endif // ENABLE(JIT)
206

207 208
    void unlinkIncomingCalls();

209
#if ENABLE(JIT)
210
    void unlinkCalls();
211 212 213
        
    void linkIncomingCall(ExecState* callerFrame, CallLinkInfo*);
        
214 215 216 217
    bool isIncomingCallAlreadyLinked(CallLinkInfo* incoming)
    {
        return m_incomingCalls.isOnList(incoming);
    }
218 219
#endif // ENABLE(JIT)

220
#if ENABLE(LLINT)
221
    void linkIncomingCall(ExecState* callerFrame, LLIntCallLinkInfo*);
222
#endif // ENABLE(LLINT)
223

224 225 226 227 228 229 230 231 232 233 234 235 236 237
    void setJITCodeMap(PassOwnPtr<CompactJITCodeMap> jitCodeMap)
    {
        m_jitCodeMap = jitCodeMap;
    }
    CompactJITCodeMap* jitCodeMap()
    {
        return m_jitCodeMap.get();
    }
    
    unsigned bytecodeOffset(Instruction* returnAddress)
    {
        RELEASE_ASSERT(returnAddress >= instructions().begin() && returnAddress < instructions().end());
        return static_cast<Instruction*>(returnAddress) - instructions().begin();
    }
238

239
    bool isNumericCompareFunction() { return m_unlinkedCode->isNumericCompareFunction(); }
240

241 242 243
    unsigned numberOfInstructions() const { return m_instructions.size(); }
    RefCountedArray<Instruction>& instructions() { return m_instructions; }
    const RefCountedArray<Instruction>& instructions() const { return m_instructions; }
244

245
    size_t predictedMachineCodeSize();
246

247
    bool usesOpcode(OpcodeID);
248

249
    unsigned instructionCount() { return m_instructions.size(); }
250

251
    int argumentIndexAfterCapture(size_t argument);
fpizlo@apple.com's avatar
fpizlo@apple.com committed
252 253 254
    
    bool hasSlowArguments();
    const SlowArgument* machineSlowArguments();
255

256 257 258 259 260 261
    // Exactly equivalent to codeBlock->ownerExecutable()->installCode(codeBlock);
    void install();
    
    // Exactly equivalent to codeBlock->ownerExecutable()->newReplacementCodeBlockFor(codeBlock->specializationKind())
    PassRefPtr<CodeBlock> newReplacement();
    
262 263
    void setJITCode(PassRefPtr<JITCode> code, MacroAssemblerCodePtr codeWithArityCheck)
    {
264 265
        ASSERT(m_heap->isDeferred());
        m_heap->reportExtraMemoryCost(code->size());
266 267 268 269 270 271 272 273 274 275 276 277 278 279 280
        ConcurrentJITLocker locker(m_lock);
        WTF::storeStoreFence(); // This is probably not needed because the lock will also do something similar, but it's good to be paranoid.
        m_jitCode = code;
        m_jitCodeWithArityCheck = codeWithArityCheck;
    }
    PassRefPtr<JITCode> jitCode() { return m_jitCode; }
    MacroAssemblerCodePtr jitCodeWithArityCheck() { return m_jitCodeWithArityCheck; }
    JITCode::JITType jitType() const
    {
        JITCode* jitCode = m_jitCode.get();
        WTF::loadLoadFence();
        JITCode::JITType result = JITCode::jitTypeFor(jitCode);
        WTF::loadLoadFence(); // This probably isn't needed. Oh well, paranoia is good.
        return result;
    }
281 282

#if ENABLE(JIT)
283 284 285 286
    bool hasBaselineJITProfiling() const
    {
        return jitType() == JITCode::BaselineJIT;
    }
287
    
288
    virtual CodeBlock* replacement() = 0;
289

290 291
    virtual DFG::CapabilityLevel capabilityLevelInternal() = 0;
    DFG::CapabilityLevel capabilityLevel()
292
    {
293 294
        DFG::CapabilityLevel result = capabilityLevelInternal();
        m_capabilityLevelState = result;
295 296
        return result;
    }
297
    DFG::CapabilityLevel capabilityLevelState() { return m_capabilityLevelState; }
298

299 300
    bool hasOptimizedReplacement(JITCode::JITType typeToReplace);
    bool hasOptimizedReplacement(); // the typeToReplace is my JITType
301 302
#endif

303 304
    void jettison(ReoptimizationMode = DontCountReoptimization);
    
305
    ScriptExecutable* ownerExecutable() const { return m_ownerExecutable.get(); }
306

307 308
    void setVM(VM* vm) { m_vm = vm; }
    VM* vm() { return m_vm; }
309

310 311
    void setThisRegister(VirtualRegister thisRegister) { m_thisRegister = thisRegister; }
    VirtualRegister thisRegister() const { return m_thisRegister; }
312

313 314
    bool needsFullScopeChain() const { return m_unlinkedCode->needsFullScopeChain(); }
    bool usesEval() const { return m_unlinkedCode->usesEval(); }
315

316
    void setArgumentsRegister(VirtualRegister argumentsRegister)
317
    {
318
        ASSERT(argumentsRegister.isValid());
319 320 321
        m_argumentsRegister = argumentsRegister;
        ASSERT(usesArguments());
    }
322
    VirtualRegister argumentsRegister() const
323 324 325 326
    {
        ASSERT(usesArguments());
        return m_argumentsRegister;
    }
327
    VirtualRegister uncheckedArgumentsRegister()
328 329
    {
        if (!usesArguments())
330
            return VirtualRegister();
331 332
        return argumentsRegister();
    }
333
    void setActivationRegister(VirtualRegister activationRegister)
334 335 336
    {
        m_activationRegister = activationRegister;
    }
337 338

    VirtualRegister activationRegister() const
339 340 341 342
    {
        ASSERT(needsFullScopeChain());
        return m_activationRegister;
    }
343 344

    VirtualRegister uncheckedActivationRegister()
345 346
    {
        if (!needsFullScopeChain())
347
            return VirtualRegister();
348 349
        return activationRegister();
    }
350 351

    bool usesArguments() const { return m_argumentsRegister.isValid(); }
352

353 354
    bool needsActivation() const
    {
355
        return m_needsActivation;
356
    }
357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377
    
    unsigned captureCount() const
    {
        if (!symbolTable())
            return 0;
        return symbolTable()->captureCount();
    }
    
    int captureStart() const
    {
        if (!symbolTable())
            return 0;
        return symbolTable()->captureStart();
    }
    
    int captureEnd() const
    {
        if (!symbolTable())
            return 0;
        return symbolTable()->captureEnd();
    }
378

fpizlo@apple.com's avatar
fpizlo@apple.com committed
379 380 381 382
    bool isCaptured(VirtualRegister operand, InlineCallFrame* = 0) const;
    
    int framePointerOffsetToGetActivationRegisters(int machineCaptureStart);
    int framePointerOffsetToGetActivationRegisters();
383

384
    CodeType codeType() const { return m_unlinkedCode->codeType(); }
385 386 387 388 389 390
    PutPropertySlot::Context putByIdContext() const
    {
        if (codeType() == EvalCode)
            return PutPropertySlot::PutByIdEval;
        return PutPropertySlot::PutById;
    }
391

392 393 394
    SourceProvider* source() const { return m_source.get(); }
    unsigned sourceOffset() const { return m_sourceOffset; }
    unsigned firstLineColumnOffset() const { return m_firstLineColumnOffset; }
395

396 397
    size_t numberOfJumpTargets() const { return m_unlinkedCode->numberOfJumpTargets(); }
    unsigned jumpTarget(int index) const { return m_unlinkedCode->jumpTarget(index); }
398

399
    void createActivation(CallFrame*);
400

401
    void clearEvalCache();
402

403
    String nameForRegister(VirtualRegister);
404

405
#if ENABLE(JIT)
406 407 408
    void setNumberOfByValInfos(size_t size) { m_byValInfos.grow(size); }
    size_t numberOfByValInfos() const { return m_byValInfos.size(); }
    ByValInfo& byValInfo(size_t index) { return m_byValInfos[index]; }
409

410 411 412
    void setNumberOfCallLinkInfos(size_t size) { m_callLinkInfos.grow(size); }
    size_t numberOfCallLinkInfos() const { return m_callLinkInfos.size(); }
    CallLinkInfo& callLinkInfo(int index) { return m_callLinkInfos[index]; }
413
#endif
414

415
#if ENABLE(VALUE_PROFILER)
416 417 418 419 420 421 422 423 424 425 426 427
    unsigned numberOfArgumentValueProfiles()
    {
        ASSERT(m_numParameters >= 0);
        ASSERT(m_argumentValueProfiles.size() == static_cast<unsigned>(m_numParameters));
        return m_argumentValueProfiles.size();
    }
    ValueProfile* valueProfileForArgument(unsigned argumentIndex)
    {
        ValueProfile* result = &m_argumentValueProfiles[argumentIndex];
        ASSERT(result->m_bytecodeOffset == -1);
        return result;
    }
428

429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446
    unsigned numberOfValueProfiles() { return m_valueProfiles.size(); }
    ValueProfile* valueProfile(int index) { return &m_valueProfiles[index]; }
    ValueProfile* valueProfileForBytecodeOffset(int bytecodeOffset)
    {
        ValueProfile* result = binarySearch<ValueProfile, int>(
                                                               m_valueProfiles, m_valueProfiles.size(), bytecodeOffset,
                                                               getValueProfileBytecodeOffset<ValueProfile>);
        ASSERT(result->m_bytecodeOffset != -1);
        ASSERT(instructions()[bytecodeOffset + opcodeLength(
                                                            m_vm->interpreter->getOpcodeID(
                                                                                           instructions()[
                                                                                                          bytecodeOffset].u.opcode)) - 1].u.profile == result);
        return result;
    }
    SpeculatedType valueProfilePredictionForBytecodeOffset(const ConcurrentJITLocker& locker, int bytecodeOffset)
    {
        return valueProfileForBytecodeOffset(bytecodeOffset)->computeUpdatedPrediction(locker);
    }
447

448 449 450 451 452 453 454 455 456 457
    unsigned totalNumberOfValueProfiles()
    {
        return numberOfArgumentValueProfiles() + numberOfValueProfiles();
    }
    ValueProfile* getFromAllValueProfiles(unsigned index)
    {
        if (index < numberOfArgumentValueProfiles())
            return valueProfileForArgument(index);
        return valueProfile(index - numberOfArgumentValueProfiles());
    }
458

459 460 461 462 463 464 465 466 467 468
    RareCaseProfile* addRareCaseProfile(int bytecodeOffset)
    {
        m_rareCaseProfiles.append(RareCaseProfile(bytecodeOffset));
        return &m_rareCaseProfiles.last();
    }
    unsigned numberOfRareCaseProfiles() { return m_rareCaseProfiles.size(); }
    RareCaseProfile* rareCaseProfile(int index) { return &m_rareCaseProfiles[index]; }
    RareCaseProfile* rareCaseProfileForBytecodeOffset(int bytecodeOffset)
    {
        return tryBinarySearch<RareCaseProfile, int>(
469 470
            m_rareCaseProfiles, m_rareCaseProfiles.size(), bytecodeOffset,
            getRareCaseProfileBytecodeOffset);
471
    }
472

473 474 475 476 477 478 479
    bool likelyToTakeSlowCase(int bytecodeOffset)
    {
        if (!hasBaselineJITProfiling())
            return false;
        unsigned value = rareCaseProfileForBytecodeOffset(bytecodeOffset)->m_counter;
        return value >= Options::likelyToTakeSlowCaseMinimumCount();
    }
480

481 482 483 484 485 486 487
    bool couldTakeSlowCase(int bytecodeOffset)
    {
        if (!hasBaselineJITProfiling())
            return false;
        unsigned value = rareCaseProfileForBytecodeOffset(bytecodeOffset)->m_counter;
        return value >= Options::couldTakeSlowCaseMinimumCount();
    }
488

489 490 491 492 493 494 495 496 497 498 499 500 501
    RareCaseProfile* addSpecialFastCaseProfile(int bytecodeOffset)
    {
        m_specialFastCaseProfiles.append(RareCaseProfile(bytecodeOffset));
        return &m_specialFastCaseProfiles.last();
    }
    unsigned numberOfSpecialFastCaseProfiles() { return m_specialFastCaseProfiles.size(); }
    RareCaseProfile* specialFastCaseProfile(int index) { return &m_specialFastCaseProfiles[index]; }
    RareCaseProfile* specialFastCaseProfileForBytecodeOffset(int bytecodeOffset)
    {
        return tryBinarySearch<RareCaseProfile, int>(
                                                     m_specialFastCaseProfiles, m_specialFastCaseProfiles.size(), bytecodeOffset,
                                                     getRareCaseProfileBytecodeOffset);
    }
502

503 504 505 506 507 508 509
    bool likelyToTakeSpecialFastCase(int bytecodeOffset)
    {
        if (!hasBaselineJITProfiling())
            return false;
        unsigned specialFastCaseCount = specialFastCaseProfileForBytecodeOffset(bytecodeOffset)->m_counter;
        return specialFastCaseCount >= Options::likelyToTakeSlowCaseMinimumCount();
    }
510

511 512 513 514 515 516 517
    bool couldTakeSpecialFastCase(int bytecodeOffset)
    {
        if (!hasBaselineJITProfiling())
            return false;
        unsigned specialFastCaseCount = specialFastCaseProfileForBytecodeOffset(bytecodeOffset)->m_counter;
        return specialFastCaseCount >= Options::couldTakeSlowCaseMinimumCount();
    }
518

519 520 521 522 523 524 525 526 527
    bool likelyToTakeDeepestSlowCase(int bytecodeOffset)
    {
        if (!hasBaselineJITProfiling())
            return false;
        unsigned slowCaseCount = rareCaseProfileForBytecodeOffset(bytecodeOffset)->m_counter;
        unsigned specialFastCaseCount = specialFastCaseProfileForBytecodeOffset(bytecodeOffset)->m_counter;
        unsigned value = slowCaseCount - specialFastCaseCount;
        return value >= Options::likelyToTakeSlowCaseMinimumCount();
    }
528

529 530 531 532 533 534 535 536 537
    bool likelyToTakeAnySlowCase(int bytecodeOffset)
    {
        if (!hasBaselineJITProfiling())
            return false;
        unsigned slowCaseCount = rareCaseProfileForBytecodeOffset(bytecodeOffset)->m_counter;
        unsigned specialFastCaseCount = specialFastCaseProfileForBytecodeOffset(bytecodeOffset)->m_counter;
        unsigned value = slowCaseCount + specialFastCaseCount;
        return value >= Options::likelyToTakeSlowCaseMinimumCount();
    }
538

539 540 541 542 543 544 545 546 547
    unsigned numberOfArrayProfiles() const { return m_arrayProfiles.size(); }
    const ArrayProfileVector& arrayProfiles() { return m_arrayProfiles; }
    ArrayProfile* addArrayProfile(unsigned bytecodeOffset)
    {
        m_arrayProfiles.append(ArrayProfile(bytecodeOffset));
        return &m_arrayProfiles.last();
    }
    ArrayProfile* getArrayProfile(unsigned bytecodeOffset);
    ArrayProfile* getOrAddArrayProfile(unsigned bytecodeOffset);
548 549
#endif

550
    // Exception handling support
551

552 553 554 555 556 557 558 559 560 561 562 563 564
    size_t numberOfExceptionHandlers() const { return m_rareData ? m_rareData->m_exceptionHandlers.size() : 0; }
    void allocateHandlers(const Vector<UnlinkedHandlerInfo>& unlinkedHandlers)
    {
        size_t count = unlinkedHandlers.size();
        if (!count)
            return;
        createRareDataIfNecessary();
        m_rareData->m_exceptionHandlers.resize(count);
        for (size_t i = 0; i < count; ++i) {
            m_rareData->m_exceptionHandlers[i].start = unlinkedHandlers[i].start;
            m_rareData->m_exceptionHandlers[i].end = unlinkedHandlers[i].end;
            m_rareData->m_exceptionHandlers[i].target = unlinkedHandlers[i].target;
            m_rareData->m_exceptionHandlers[i].scopeDepth = unlinkedHandlers[i].scopeDepth;
565 566
        }

567 568 569 570
    }
    HandlerInfo& exceptionHandler(int index) { RELEASE_ASSERT(m_rareData); return m_rareData->m_exceptionHandlers[index]; }

    bool hasExpressionInfo() { return m_unlinkedCode->hasExpressionInfo(); }
571

572
#if ENABLE(DFG_JIT)
573
    Vector<CodeOrigin, 0, UnsafeVectorOverflow>& codeOrigins()
574
    {
575
        return m_jitCode->dfgCommon()->codeOrigins;
576
    }
577
    
578 579 580
    // Having code origins implies that there has been some inlining.
    bool hasCodeOrigins()
    {
581
        return JITCode::isOptimizingJIT(jitType());
582
    }
583
        
584 585
    bool canGetCodeOrigin(unsigned index)
    {
586
        if (!hasCodeOrigins())
587
            return false;
588
        return index < codeOrigins().size();
589
    }
590

591 592
    CodeOrigin codeOrigin(unsigned index)
    {
593
        return codeOrigins()[index];
594
    }
595

596 597 598
    bool addFrequentExitSite(const DFG::FrequentExitSite& site)
    {
        ASSERT(JITCode::isBaselineCode(jitType()));
599 600 601 602 603 604 605 606
        ConcurrentJITLocker locker(m_lock);
        return m_exitProfile.add(locker, site);
    }
        
    bool hasExitSite(const DFG::FrequentExitSite& site) const
    {
        ConcurrentJITLocker locker(m_lock);
        return m_exitProfile.hasExitSite(locker, site);
607
    }
608

609
    DFG::ExitProfile& exitProfile() { return m_exitProfile; }
610

611 612 613 614
    CompressedLazyOperandValueProfileHolder& lazyOperandValueProfiles()
    {
        return m_lazyOperandValueProfiles;
    }
fpizlo@apple.com's avatar
fpizlo@apple.com committed
615 616 617 618 619 620
#else // ENABLE(DFG_JIT)
    bool addFrequentExitSite(const DFG::FrequentExitSite&)
    {
        return false;
    }
#endif // ENABLE(DFG_JIT)
621

622
    // Constant Pool
623 624 625 626 627 628 629 630 631 632
#if ENABLE(DFG_JIT)
    size_t numberOfIdentifiers() const { return m_unlinkedCode->numberOfIdentifiers() + numberOfDFGIdentifiers(); }
    size_t numberOfDFGIdentifiers() const
    {
        if (!JITCode::isOptimizingJIT(jitType()))
            return 0;

        return m_jitCode->dfgCommon()->dfgIdentifiers.size();
    }

633 634 635 636 637
    const Identifier& identifier(int index) const
    {
        size_t unlinkedIdentifiers = m_unlinkedCode->numberOfIdentifiers();
        if (static_cast<unsigned>(index) < unlinkedIdentifiers)
            return m_unlinkedCode->identifier(index);
638 639
        ASSERT(JITCode::isOptimizingJIT(jitType()));
        return m_jitCode->dfgCommon()->dfgIdentifiers[index - unlinkedIdentifiers];
640
    }
641 642 643 644
#else
    size_t numberOfIdentifiers() const { return m_unlinkedCode->numberOfIdentifiers(); }
    const Identifier& identifier(int index) const { return m_unlinkedCode->identifier(index); }
#endif
645

646
    Vector<WriteBarrier<Unknown>>& constants() { return m_constantRegisters; }
647 648 649 650 651 652 653 654
    size_t numberOfConstantRegisters() const { return m_constantRegisters.size(); }
    unsigned addConstant(JSValue v)
    {
        unsigned result = m_constantRegisters.size();
        m_constantRegisters.append(WriteBarrier<Unknown>());
        m_constantRegisters.last().set(m_globalObject->vm(), m_ownerExecutable.get(), v);
        return result;
    }
655

656
    unsigned addConstantLazily()
657
    {
658
        unsigned result = m_constantRegisters.size();
659
        m_constantRegisters.append(WriteBarrier<Unknown>());
660
        return result;
661
    }
662

663
    bool findConstant(JSValue, unsigned& result);
664 665 666 667
    unsigned addOrFindConstant(JSValue);
    WriteBarrier<Unknown>& constantRegister(int index) { return m_constantRegisters[index - FirstConstantRegisterIndex]; }
    ALWAYS_INLINE bool isConstantRegisterIndex(int index) const { return index >= FirstConstantRegisterIndex; }
    ALWAYS_INLINE JSValue getConstant(int index) const { return m_constantRegisters[index - FirstConstantRegisterIndex].get(); }
668

669 670 671
    FunctionExecutable* functionDecl(int index) { return m_functionDecls[index].get(); }
    int numberOfFunctionDecls() { return m_functionDecls.size(); }
    FunctionExecutable* functionExpr(int index) { return m_functionExprs[index].get(); }
672

673
    RegExp* regexp(int index) const { return m_unlinkedCode->regexp(index); }
674

675 676 677 678 679 680 681 682 683 684 685 686 687
    unsigned numberOfConstantBuffers() const
    {
        if (!m_rareData)
            return 0;
        return m_rareData->m_constantBuffers.size();
    }
    unsigned addConstantBuffer(const Vector<JSValue>& buffer)
    {
        createRareDataIfNecessary();
        unsigned size = m_rareData->m_constantBuffers.size();
        m_rareData->m_constantBuffers.append(buffer);
        return size;
    }
688

689 690 691 692 693 694 695 696 697
    Vector<JSValue>& constantBufferAsVector(unsigned index)
    {
        ASSERT(m_rareData);
        return m_rareData->m_constantBuffers[index];
    }
    JSValue* constantBuffer(unsigned index)
    {
        return constantBufferAsVector(index).data();
    }
698

699
    JSGlobalObject* globalObject() { return m_globalObject.get(); }
700

701
    JSGlobalObject* globalObjectFor(CodeOrigin);
702

703 704 705 706 707 708
    BytecodeLivenessAnalysis& livenessAnalysis()
    {
        if (!m_livenessAnalysis)
            m_livenessAnalysis = std::make_unique<BytecodeLivenessAnalysis>(this);
        return *m_livenessAnalysis;
    }
709

710
    // Jump Tables
711

712 713 714 715
    size_t numberOfSwitchJumpTables() const { return m_rareData ? m_rareData->m_switchJumpTables.size() : 0; }
    SimpleJumpTable& addSwitchJumpTable() { createRareDataIfNecessary(); m_rareData->m_switchJumpTables.append(SimpleJumpTable()); return m_rareData->m_switchJumpTables.last(); }
    SimpleJumpTable& switchJumpTable(int tableIndex) { RELEASE_ASSERT(m_rareData); return m_rareData->m_switchJumpTables[tableIndex]; }
    void clearSwitchJumpTables()
716 717 718
    {
        if (!m_rareData)
            return;
719
        m_rareData->m_switchJumpTables.clear();
720
    }
721

722 723 724
    size_t numberOfStringSwitchJumpTables() const { return m_rareData ? m_rareData->m_stringSwitchJumpTables.size() : 0; }
    StringJumpTable& addStringSwitchJumpTable() { createRareDataIfNecessary(); m_rareData->m_stringSwitchJumpTables.append(StringJumpTable()); return m_rareData->m_stringSwitchJumpTables.last(); }
    StringJumpTable& stringSwitchJumpTable(int tableIndex) { RELEASE_ASSERT(m_rareData); return m_rareData->m_stringSwitchJumpTables[tableIndex]; }
725

726

727
    SharedSymbolTable* symbolTable() const { return m_unlinkedCode->symbolTable(); }
728

729
    EvalCodeCache& evalCodeCache() { createRareDataIfNecessary(); return m_rareData->m_evalCodeCache; }
730

731 732 733
    enum ShrinkMode {
        // Shrink prior to generating machine code that may point directly into vectors.
        EarlyShrink,
734

735 736 737 738 739 740
        // Shrink after generating machine code, and after possibly creating new vectors
        // and appending to others. At this time it is not safe to shrink certain vectors
        // because we would have generated machine code that references them directly.
        LateShrink
    };
    void shrinkToFit(ShrinkMode);
741

742 743
    void copyPostParseDataFrom(CodeBlock* alternative);
    void copyPostParseDataFromAlternative();
744

745 746
    // Functions for controlling when JITting kicks in, in a mixed mode
    // execution world.
747

748 749 750 751
    bool checkIfJITThresholdReached()
    {
        return m_llintExecuteCounter.checkIfThresholdCrossedAndSet(this);
    }
752

753 754 755 756
    void dontJITAnytimeSoon()
    {
        m_llintExecuteCounter.deferIndefinitely();
    }
757

758 759 760 761
    void jitAfterWarmUp()
    {
        m_llintExecuteCounter.setNewThreshold(Options::thresholdForJITAfterWarmUp(), this);
    }
762

763 764 765 766
    void jitSoon()
    {
        m_llintExecuteCounter.setNewThreshold(Options::thresholdForJITSoon(), this);
    }
767

768 769 770 771
    const ExecutionCounter& llintExecuteCounter() const
    {
        return m_llintExecuteCounter;
    }
772

773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795
    // Functions for controlling when tiered compilation kicks in. This
    // controls both when the optimizing compiler is invoked and when OSR
    // entry happens. Two triggers exist: the loop trigger and the return
    // trigger. In either case, when an addition to m_jitExecuteCounter
    // causes it to become non-negative, the optimizing compiler is
    // invoked. This includes a fast check to see if this CodeBlock has
    // already been optimized (i.e. replacement() returns a CodeBlock
    // that was optimized with a higher tier JIT than this one). In the
    // case of the loop trigger, if the optimized compilation succeeds
    // (or has already succeeded in the past) then OSR is attempted to
    // redirect program flow into the optimized code.

    // These functions are called from within the optimization triggers,
    // and are used as a single point at which we define the heuristics
    // for how much warm-up is mandated before the next optimization
    // trigger files. All CodeBlocks start out with optimizeAfterWarmUp(),
    // as this is called from the CodeBlock constructor.

    // When we observe a lot of speculation failures, we trigger a
    // reoptimization. But each time, we increase the optimization trigger
    // to avoid thrashing.
    unsigned reoptimizationRetryCounter() const;
    void countReoptimization();
796
#if ENABLE(JIT)
797
    unsigned numberOfDFGCompiles();
798 799 800

    int32_t codeTypeThresholdMultiplier() const;

801
    int32_t adjustedCounterValue(int32_t desiredThreshold);
802 803 804 805 806

    int32_t* addressOfJITExecuteCounter()
    {
        return &m_jitExecuteCounter.m_counter;
    }
807

808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867
    static ptrdiff_t offsetOfJITExecuteCounter() { return OBJECT_OFFSETOF(CodeBlock, m_jitExecuteCounter) + OBJECT_OFFSETOF(ExecutionCounter, m_counter); }
    static ptrdiff_t offsetOfJITExecutionActiveThreshold() { return OBJECT_OFFSETOF(CodeBlock, m_jitExecuteCounter) + OBJECT_OFFSETOF(ExecutionCounter, m_activeThreshold); }
    static ptrdiff_t offsetOfJITExecutionTotalCount() { return OBJECT_OFFSETOF(CodeBlock, m_jitExecuteCounter) + OBJECT_OFFSETOF(ExecutionCounter, m_totalCount); }

    const ExecutionCounter& jitExecuteCounter() const { return m_jitExecuteCounter; }

    unsigned optimizationDelayCounter() const { return m_optimizationDelayCounter; }

    // Check if the optimization threshold has been reached, and if not,
    // adjust the heuristics accordingly. Returns true if the threshold has
    // been reached.
    bool checkIfOptimizationThresholdReached();

    // Call this to force the next optimization trigger to fire. This is
    // rarely wise, since optimization triggers are typically more
    // expensive than executing baseline code.
    void optimizeNextInvocation();

    // Call this to prevent optimization from happening again. Note that
    // optimization will still happen after roughly 2^29 invocations,
    // so this is really meant to delay that as much as possible. This
    // is called if optimization failed, and we expect it to fail in
    // the future as well.
    void dontOptimizeAnytimeSoon();

    // Call this to reinitialize the counter to its starting state,
    // forcing a warm-up to happen before the next optimization trigger
    // fires. This is called in the CodeBlock constructor. It also
    // makes sense to call this if an OSR exit occurred. Note that
    // OSR exit code is code generated, so the value of the execute
    // counter that this corresponds to is also available directly.
    void optimizeAfterWarmUp();

    // Call this to force an optimization trigger to fire only after
    // a lot of warm-up.
    void optimizeAfterLongWarmUp();

    // Call this to cause an optimization trigger to fire soon, but
    // not necessarily the next one. This makes sense if optimization
    // succeeds. Successfuly optimization means that all calls are
    // relinked to the optimized code, so this only affects call
    // frames that are still executing this CodeBlock. The value here
    // is tuned to strike a balance between the cost of OSR entry
    // (which is too high to warrant making every loop back edge to
    // trigger OSR immediately) and the cost of executing baseline
    // code (which is high enough that we don't necessarily want to
    // have a full warm-up). The intuition for calling this instead of
    // optimizeNextInvocation() is for the case of recursive functions
    // with loops. Consider that there may be N call frames of some
    // recursive function, for a reasonably large value of N. The top
    // one triggers optimization, and then returns, and then all of
    // the others return. We don't want optimization to be triggered on
    // each return, as that would be superfluous. It only makes sense
    // to trigger optimization if one of those functions becomes hot
    // in the baseline code.
    void optimizeSoon();

    void forceOptimizationSlowPathConcurrently();

    void setOptimizationThresholdBasedOnCompilationResult(CompilationResult);
868
    
869
    uint32_t osrExitCounter() const { return m_osrExitCounter; }
870

871
    void countOSRExit() { m_osrExitCounter++; }
872

873
    uint32_t* addressOfOSRExitCounter() { return &m_osrExitCounter; }
874

875
    static ptrdiff_t offsetOfOSRExitCounter() { return OBJECT_OFFSETOF(CodeBlock, m_osrExitCounter); }
876

877 878 879 880 881
    uint32_t adjustedExitCountThreshold(uint32_t desiredThreshold);
    uint32_t exitCountThresholdForReoptimization();
    uint32_t exitCountThresholdForReoptimizationFromLoop();
    bool shouldReoptimizeNow();
    bool shouldReoptimizeFromLoopNow();
882 883 884
#else // No JIT
    void optimizeAfterWarmUp() { }
    unsigned numberOfDFGCompiles() { return 0; }
885
#endif
ggaren@apple.com's avatar
ggaren@apple.com committed
886

887
#if ENABLE(VALUE_PROFILER)
888
    bool shouldOptimizeNow();
889
    void updateAllValueProfilePredictions();
890
    void updateAllArrayPredictions();
891
    void updateAllPredictions();
892
#else
893
    bool updateAllPredictionsAndCheckIfShouldOptimizeNow() { return false; }
894
    void updateAllValueProfilePredictions() { }
895
    void updateAllArrayPredictions() { }
896
    void updateAllPredictions() { }
897
#endif
898

899
#if ENABLE(VERBOSE_VALUE_PROFILE)
900
    void dumpValueProfiles();
901
#endif
902

903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924
    // FIXME: Make these remaining members private.

    int m_numCalleeRegisters;
    int m_numVars;
    bool m_isConstructor;
    
    // This is intentionally public; it's the responsibility of anyone doing any
    // of the following to hold the lock:
    //
    // - Modifying any inline cache in this code block.
    //
    // - Quering any inline cache in this code block, from a thread other than
    //   the main thread.
    //
    // Additionally, it's only legal to modify the inline cache on the main
    // thread. This means that the main thread can query the inline cache without
    // locking. This is crucial since executing the inline cache is effectively
    // "querying" it.
    //
    // Another exception to the rules is that the GC can do whatever it wants
    // without holding any locks, because the GC is guaranteed to wait until any
    // concurrent compilation threads finish what they're doing.
925
    mutable ConcurrentJITLock m_lock;
926
    
927
    bool m_shouldAlwaysBeInlined;
928
    bool m_allTransitionsHaveBeenMarked; // Initialized and used on every GC.
929
    
930 931
    bool m_didFailFTLCompilation;
    
932
protected:
933 934
    virtual void visitWeakReferences(SlotVisitor&) OVERRIDE;
    virtual void finalizeUnconditionally() OVERRIDE;
935

936
#if ENABLE(DFG_JIT)
937
    void tallyFrequentExitSites();
938
#else
939
    void tallyFrequentExitSites() { }
940 941
#endif

942
private:
943
    friend class CodeBlockSet;
944
    
945 946
    CodeBlock* specialOSREntryBlockOrNull();
    
947 948
    void noticeIncomingCall(ExecState* callerFrame);
    
949
    double optimizationThresholdScalingFactor();
950 951

#if ENABLE(JIT)
952
    ClosureCallStubRoutine* findClosureCallForReturnPC(ReturnAddressPtr);
953
#endif
954
        
955
#if ENABLE(VALUE_PROFILER)
956
    void updateAllPredictionsAndCountLiveness(unsigned& numberOfLiveNonArgumentValueProfiles, unsigned& numberOfSamplesInProfiles);
957
#endif
958

959
    void setConstantRegisters(const Vector<WriteBarrier<Unknown>>& constants)
960 961 962 963 964 965
    {
        size_t count = constants.size();
        m_constantRegisters.resize(count);
        for (size_t i = 0; i < count; i++)
            m_constantRegisters[i].set(*m_vm, ownerExecutable(), constants[i].get());
    }
966

967
    void dumpBytecode(PrintStream&, ExecState*, const Instruction* begin, const Instruction*&, const StubInfoMap& = StubInfoMap());
968 969 970 971 972 973

    CString registerName(int r) const;
    void printUnaryOp(PrintStream&, ExecState*, int location, const Instruction*&, const char* op);
    void printBinaryOp(PrintStream&, ExecState*, int location, const Instruction*&, const char* op);
    void printConditionalJump(PrintStream&, ExecState*, const Instruction*, const Instruction*&, int location, const char* op);
    void printGetByIdOp(PrintStream&, ExecState*, int location, const Instruction*&);
974
    void printGetByIdCacheStatus(PrintStream&, ExecState*, int location, const StubInfoMap&);
975
    enum CacheDumpMode { DumpCaches, DontDumpCaches };
976
    void printCallOp(PrintStream&, ExecState*, int location, const Instruction*&, const char* op, CacheDumpMode, bool& hasPrintedProfiling);
977
    void printPutByIdOp(PrintStream&, ExecState*, int location, const Instruction*&, const char* op);
978 979 980 981 982 983 984 985 986 987 988
    void printLocationAndOp(PrintStream& out, ExecState*, int location, const Instruction*&, const char* op)
    {
        out.printf("[%4d] %-17s ", location, op);
    }

    void printLocationOpAndRegisterOperand(PrintStream& out, ExecState* exec, int location, const Instruction*& it, const char* op, int operand)
    {
        printLocationAndOp(out, exec, location, it, op);
        out.printf("%s", registerName(operand).data());
    }

989 990 991
    void beginDumpProfiling(PrintStream&, bool& hasPrintedProfiling);
    void dumpValueProfiling(PrintStream&, const Instruction*&, bool& hasPrintedProfiling);
    void dumpArrayProfiling(PrintStream&, const Instruction*&, bool& hasPrintedProfiling);
992
#if ENABLE(VALUE_PROFILER)
993
    void dumpRareCaseProfile(PrintStream&, const char* name, RareCaseProfile*, bool& hasPrintedProfiling);
994
#endif
995
        
996
#if ENABLE(DFG_JIT)
997 998
    bool shouldImmediatelyAssumeLivenessDuringScan()
    {
999 1000 1001
        // Interpreter and Baseline JIT CodeBlocks don't need to be jettisoned when
        // their weak references go stale. So if a basline JIT CodeBlock gets
        // scanned, we can assume that this means that it's live.
1002 1003 1004 1005 1006 1007
        if (!JITCode::isOptimizingJIT(jitType()))
            return true;

        // For simplicity, we don't attempt to jettison code blocks during GC if
        // they are executing. Instead we strongly mark their weak references to
        // allow them to continue to execute soundly.
1008
        if (m_mayBeExecuting)