bytecode/CallLinkStatus.h

   1 /*
   2  * Copyright (C) 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 CallLinkStatus_h
  27 #define CallLinkStatus_h
  28
  29 #include "CodeSpecializationKind.h"
  30 #include "Intrinsic.h"
  31 #include "JSCJSValue.h"
  32
  33 namespace JSC {
  34
  35 class CodeBlock;
  36 class ExecutableBase;
  37 class InternalFunction;
  38 class JSFunction;
  39 class Structure;
  40
  41 class CallLinkStatus {
  42 public:
  43     CallLinkStatus()
  44         : m_executable(0)
  45         , m_structure(0)
  46         , m_couldTakeSlowPath(false)
  47         , m_isProved(false)
  48     {
  49     }
  50
  51     static CallLinkStatus takesSlowPath()
  52     {
  53         CallLinkStatus result;
  54         result.m_couldTakeSlowPath = true;
  55         return result;
  56     }
  57
  58     explicit CallLinkStatus(JSValue);
  59
  60     CallLinkStatus(ExecutableBase* executable, Structure* structure)
  61         : m_executable(executable)
  62         , m_structure(structure)
  63         , m_couldTakeSlowPath(false)
  64         , m_isProved(false)
  65     {
  66         ASSERT(!!executable == !!structure);
  67     }
  68
  69     CallLinkStatus& setIsProved(bool isProved)
  70     {
  71         m_isProved = isProved;
  72         return *this;
  73     }
  74
  75     static CallLinkStatus computeFor(CodeBlock*, unsigned bytecodeIndex);
  76
  77     CallLinkStatus& setHasBadFunctionExitSite(bool didHaveExitSite)
  78     {
  79         ASSERT(!m_isProved);
  80         if (didHaveExitSite) {
  81             // Turn this into a closure call.
  82             m_callTarget = JSValue();
  83         }
  84         return *this;
  85     }
  86
  87     CallLinkStatus& setHasBadCacheExitSite(bool didHaveExitSite)
  88     {
  89         ASSERT(!m_isProved);
  90         if (didHaveExitSite)
  91             *this = takesSlowPath();
  92         return *this;
  93     }
  94
  95     CallLinkStatus& setHasBadExecutableExitSite(bool didHaveExitSite)
  96     {
  97         ASSERT(!m_isProved);
  98         if (didHaveExitSite)
  99             *this = takesSlowPath();
 100         return *this;
 101     }
 102
 103     bool isSet() const { return m_callTarget || m_executable || m_couldTakeSlowPath; }
 104
 105     bool operator!() const { return !isSet(); }
 106
 107     bool couldTakeSlowPath() const { return m_couldTakeSlowPath; }
 108     bool isClosureCall() const { return m_executable && !m_callTarget; }
 109
 110     JSValue callTarget() const { return m_callTarget; }
 111     JSFunction* function() const;
 112     InternalFunction* internalFunction() const;
 113     Intrinsic intrinsicFor(CodeSpecializationKind) const;
 114     ExecutableBase* executable() const { return m_executable; }
 115     Structure* structure() const { return m_structure; }
 116     bool isProved() const { return m_isProved; }
 117     bool canOptimize() const { return (m_callTarget || m_executable) && !m_couldTakeSlowPath; }
 118
 119     void dump(PrintStream&) const;
 120
 121 private:
 122     static CallLinkStatus computeFromLLInt(CodeBlock*, unsigned bytecodeIndex);
 123
 124     JSValue m_callTarget;
 125     ExecutableBase* m_executable;
 126     Structure* m_structure;
 127     bool m_couldTakeSlowPath;
 128     bool m_isProved;
 129 };
 130
 131 } // namespace JSC
 132
 133 #endif // CallLinkStatus_h
 134