bytecode/CallLinkStatus.h

   1 /*
   2  * Copyright (C) 2012-2015 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 "CallLinkInfo.h"
  30 #include "CallVariant.h"
  31 #include "CodeOrigin.h"
  32 #include "CodeSpecializationKind.h"
  33 #include "ConcurrentJITLock.h"
  34 #include "ExitingJITType.h"
  35 #include "Intrinsic.h"
  36 #include "JSCJSValue.h"
  37
  38 namespace JSC {
  39
  40 class CodeBlock;
  41 class ExecutableBase;
  42 class InternalFunction;
  43 class JSFunction;
  44 class Structure;
  45 class CallLinkInfo;
  46
  47 class CallLinkStatus {
  48 public:
  49     CallLinkStatus()
  50         : m_couldTakeSlowPath(false)
  51         , m_isProved(false)
  52     {
  53     }
  54
  55     static CallLinkStatus takesSlowPath()
  56     {
  57         CallLinkStatus result;
  58         result.m_couldTakeSlowPath = true;
  59         return result;
  60     }
  61
  62     explicit CallLinkStatus(JSValue);
  63
  64     CallLinkStatus(CallVariant variant)
  65         : m_variants(1, variant)
  66         , m_couldTakeSlowPath(false)
  67         , m_isProved(false)
  68     {
  69     }
  70
  71     static CallLinkStatus computeFor(
  72         CodeBlock*, unsigned bytecodeIndex, const CallLinkInfoMap&);
  73
  74     struct ExitSiteData {
  75         ExitSiteData()
  76             : m_takesSlowPath(false)
  77             , m_badFunction(false)
  78         {
  79         }
  80
  81         bool m_takesSlowPath;
  82         bool m_badFunction;
  83     };
  84     static ExitSiteData computeExitSiteData(const ConcurrentJITLocker&, CodeBlock*, unsigned bytecodeIndex);
  85
  86 #if ENABLE(JIT)
  87     // Computes the status assuming that we never took slow path and never previously
  88     // exited.
  89     static CallLinkStatus computeFor(const ConcurrentJITLocker&, CodeBlock*, CallLinkInfo&);
  90     static CallLinkStatus computeFor(
  91         const ConcurrentJITLocker&, CodeBlock*, CallLinkInfo&, ExitSiteData);
  92 #endif
  93
  94     typedef HashMap<CodeOrigin, CallLinkStatus, CodeOriginApproximateHash> ContextMap;
  95
  96     // Computes all of the statuses of the DFG code block. Doesn't include statuses that had
  97     // no information. Currently we use this when compiling FTL code, to enable polyvariant
  98     // inlining.
  99     static void computeDFGStatuses(CodeBlock* dfgCodeBlock, ContextMap&);
 100
 101     // Helper that first consults the ContextMap and then does computeFor().
 102     static CallLinkStatus computeFor(
 103         CodeBlock*, CodeOrigin, const CallLinkInfoMap&, const ContextMap&);
 104
 105     void setProvenConstantCallee(CallVariant);
 106
 107     bool isSet() const { return !m_variants.isEmpty() || m_couldTakeSlowPath; }
 108
 109     bool operator!() const { return !isSet(); }
 110
 111     bool couldTakeSlowPath() const { return m_couldTakeSlowPath; }
 112
 113     CallVariantList variants() const { return m_variants; }
 114     unsigned size() const { return m_variants.size(); }
 115     CallVariant at(unsigned i) const { return m_variants[i]; }
 116     CallVariant operator[](unsigned i) const { return at(i); }
 117     bool isProved() const { return m_isProved; }
 118     bool canOptimize() const { return !m_variants.isEmpty(); }
 119
 120     bool isClosureCall() const; // Returns true if any callee is a closure call.
 121
 122     unsigned maxNumArguments() const { return m_maxNumArguments; }
 123
 124     void dump(PrintStream&) const;
 125
 126 private:
 127     void makeClosureCall();
 128
 129     static CallLinkStatus computeFromLLInt(const ConcurrentJITLocker&, CodeBlock*, unsigned bytecodeIndex);
 130 #if ENABLE(JIT)
 131     static CallLinkStatus computeFromCallLinkInfo(
 132         const ConcurrentJITLocker&, CallLinkInfo&);
 133 #endif
 134
 135     CallVariantList m_variants;
 136     bool m_couldTakeSlowPath;
 137     bool m_isProved;
 138     unsigned m_maxNumArguments;
 139 };
 140
 141 } // namespace JSC
 142
 143 #endif // CallLinkStatus_h
 144