bytecode/CodeOrigin.h

   1 /*
   2  * Copyright (C) 2011, 2012, 2013 Apple Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
  17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #ifndef CodeOrigin_h
  27 #define CodeOrigin_h
  28
  29 #include "CodeBlockHash.h"
  30 #include "CodeSpecializationKind.h"
  31 #include "ValueRecovery.h"
  32 #include "WriteBarrier.h"
  33 #include <wtf/BitVector.h>
  34 #include <wtf/PrintStream.h>
  35 #include <wtf/StdLibExtras.h>
  36 #include <wtf/Vector.h>
  37
  38 namespace JSC {
  39
  40 struct InlineCallFrame;
  41 class ExecState;
  42 class ExecutableBase;
  43 class JSFunction;
  44
  45 struct CodeOrigin {
  46     static const unsigned maximumBytecodeIndex = (1u << 29) - 1;
  47
  48     // Bytecode offset that you'd use to re-execute this instruction.
  49     unsigned bytecodeIndex : 29;
  50     // Bytecode offset corresponding to the opcode that gives the result (needed to handle
  51     // op_call/op_call_put_result and op_method_check/op_get_by_id).
  52     unsigned valueProfileOffset : 3;
  53
  54     InlineCallFrame* inlineCallFrame;
  55
  56     CodeOrigin()
  57         : bytecodeIndex(maximumBytecodeIndex)
  58         , valueProfileOffset(0)
  59         , inlineCallFrame(0)
  60     {
  61     }
  62
  63     explicit CodeOrigin(unsigned bytecodeIndex, InlineCallFrame* inlineCallFrame = 0, unsigned valueProfileOffset = 0)
  64         : bytecodeIndex(bytecodeIndex)
  65         , valueProfileOffset(valueProfileOffset)
  66         , inlineCallFrame(inlineCallFrame)
  67     {
  68         RELEASE_ASSERT(bytecodeIndex <= maximumBytecodeIndex);
  69         RELEASE_ASSERT(valueProfileOffset < (1u << 3));
  70     }
  71
  72     bool isSet() const { return bytecodeIndex != maximumBytecodeIndex; }
  73
  74     unsigned bytecodeIndexForValueProfile() const
  75     {
  76         return bytecodeIndex + valueProfileOffset;
  77     }
  78
  79     // The inline depth is the depth of the inline stack, so 1 = not inlined,
  80     // 2 = inlined one deep, etc.
  81     unsigned inlineDepth() const;
  82
  83     // If the code origin corresponds to inlined code, gives you the heap object that
  84     // would have owned the code if it had not been inlined. Otherwise returns 0.
  85     ExecutableBase* codeOriginOwner() const;
  86
  87     unsigned stackOffset() const;
  88
  89     static unsigned inlineDepthForCallFrame(InlineCallFrame*);
  90
  91     bool operator==(const CodeOrigin& other) const;
  92
  93     bool operator!=(const CodeOrigin& other) const { return !(*this == other); }
  94
  95     // Get the inline stack. This is slow, and is intended for debugging only.
  96     Vector<CodeOrigin> inlineStack() const;
  97
  98     void dump(PrintStream&) const;
  99 };
 100
 101 struct InlineCallFrame {
 102     Vector<ValueRecovery> arguments;
 103     WriteBarrier<ExecutableBase> executable;
 104     WriteBarrier<JSFunction> callee; // This may be null, indicating that this is a closure call and that the JSFunction and JSScope are already on the stack.
 105     CodeOrigin caller;
 106     BitVector capturedVars; // Indexed by the machine call frame's variable numbering.
 107     unsigned stackOffset : 31;
 108     bool isCall : 1;
 109
 110     CodeSpecializationKind specializationKind() const { return specializationFromIsCall(isCall); }
 111
 112     bool isClosureCall() const { return !callee; }
 113
 114     // Get the callee given a machine call frame to which this InlineCallFrame belongs.
 115     JSFunction* calleeForCallFrame(ExecState*) const;
 116
 117     String inferredName() const;
 118     CodeBlockHash hash() const;
 119
 120     CodeBlock* baselineCodeBlock() const;
 121
 122     void dumpBriefFunctionInformation(PrintStream&) const;
 123     void dump(PrintStream&) const;
 124
 125     MAKE_PRINT_METHOD(InlineCallFrame, dumpBriefFunctionInformation, briefFunctionInformation);
 126 };
 127
 128 struct CodeOriginAtCallReturnOffset {
 129     CodeOrigin codeOrigin;
 130     unsigned callReturnOffset;
 131 };
 132
 133 inline unsigned CodeOrigin::stackOffset() const
 134 {
 135     if (!inlineCallFrame)
 136         return 0;
 137
 138     return inlineCallFrame->stackOffset;
 139 }
 140
 141 inline bool CodeOrigin::operator==(const CodeOrigin& other) const
 142 {
 143     return bytecodeIndex == other.bytecodeIndex
 144         && inlineCallFrame == other.inlineCallFrame;
 145 }
 146
 147 inline unsigned getCallReturnOffsetForCodeOrigin(CodeOriginAtCallReturnOffset* data)
 148 {
 149     return data->callReturnOffset;
 150 }
 151
 152 inline ExecutableBase* CodeOrigin::codeOriginOwner() const
 153 {
 154     if (!inlineCallFrame)
 155         return 0;
 156     return inlineCallFrame->executable.get();
 157 }
 158
 159 } // namespace JSC
 160
 161 #endif // CodeOrigin_h
 162