runtime/TestRunnerUtils.cpp

   1 /*
   2  * Copyright (C) 2013, 2014 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 #include "config.h"
  27 #include "TestRunnerUtils.h"
  28
  29 #include "CodeBlock.h"
  30 #include "JSCInlines.h"
  31
  32 namespace JSC {
  33
  34 FunctionExecutable* getExecutableForFunction(JSValue theFunctionValue)
  35 {
  36     JSFunction* theFunction = jsDynamicCast<JSFunction*>(theFunctionValue);
  37     if (!theFunction)
  38         return 0;
  39
  40     FunctionExecutable* executable = jsDynamicCast<FunctionExecutable*>(
  41         theFunction->executable());
  42     return executable;
  43 }
  44
  45 CodeBlock* getSomeBaselineCodeBlockForFunction(JSValue theFunctionValue)
  46 {
  47     FunctionExecutable* executable = getExecutableForFunction(theFunctionValue);
  48     if (!executable)
  49         return 0;
  50
  51     CodeBlock* baselineCodeBlock = executable->baselineCodeBlockFor(CodeForCall);
  52
  53     if (!baselineCodeBlock)
  54         baselineCodeBlock = executable->baselineCodeBlockFor(CodeForConstruct);
  55
  56     return baselineCodeBlock;
  57 }
  58
  59 JSValue numberOfDFGCompiles(JSValue theFunctionValue)
  60 {
  61     bool pretendToHaveManyCompiles = false;
  62 #if ENABLE(DFG_JIT)
  63     if (!Options::useJIT() || !Options::useDFGJIT())
  64         pretendToHaveManyCompiles = true;
  65 #else
  66     pretendToHaveManyCompiles = true;
  67 #endif
  68
  69     if (CodeBlock* baselineCodeBlock = getSomeBaselineCodeBlockForFunction(theFunctionValue)) {
  70         if (pretendToHaveManyCompiles)
  71             return jsNumber(1000000.0);
  72         return jsNumber(baselineCodeBlock->numberOfDFGCompiles());
  73     }
  74
  75     return jsNumber(0);
  76 }
  77
  78 JSValue setNeverInline(JSValue theFunctionValue)
  79 {
  80     if (FunctionExecutable* executable = getExecutableForFunction(theFunctionValue))
  81         executable->setNeverInline(true);
  82
  83     return jsUndefined();
  84 }
  85
  86 JSValue optimizeNextInvocation(JSValue theFunctionValue)
  87 {
  88 #if ENABLE(JIT)
  89     if (CodeBlock* baselineCodeBlock = getSomeBaselineCodeBlockForFunction(theFunctionValue))
  90         baselineCodeBlock->optimizeNextInvocation();
  91 #else
  92     UNUSED_PARAM(theFunctionValue);
  93 #endif
  94
  95     return jsUndefined();
  96 }
  97
  98 JSValue numberOfDFGCompiles(ExecState* exec)
  99 {
 100     if (exec->argumentCount() < 1)
 101         return jsUndefined();
 102     return numberOfDFGCompiles(exec->uncheckedArgument(0));
 103 }
 104
 105 JSValue setNeverInline(ExecState* exec)
 106 {
 107     if (exec->argumentCount() < 1)
 108         return jsUndefined();
 109     return setNeverInline(exec->uncheckedArgument(0));
 110 }
 111
 112 JSValue optimizeNextInvocation(ExecState* exec)
 113 {
 114     if (exec->argumentCount() < 1)
 115         return jsUndefined();
 116     return optimizeNextInvocation(exec->uncheckedArgument(0));
 117 }
 118
 119 } // namespace JSC
 120