LCOV - code coverage report
Current view: top level - src/builtins - builtins.cc (source / functions) Hit Total Coverage
Test: app.info Lines: 40 55 72.7 %
Date: 2017-04-26 Functions: 212 657 32.3 %

          Line data    Source code
       1             : // Copyright 2012 the V8 project authors. All rights reserved.
       2             : // Use of this source code is governed by a BSD-style license that can be
       3             : // found in the LICENSE file.
       4             : 
       5             : #include "src/builtins/builtins.h"
       6             : #include "src/api.h"
       7             : #include "src/assembler-inl.h"
       8             : #include "src/builtins/builtins-descriptors.h"
       9             : #include "src/callable.h"
      10             : #include "src/isolate.h"
      11             : #include "src/macro-assembler.h"
      12             : #include "src/objects-inl.h"
      13             : #include "src/visitors.h"
      14             : 
      15             : namespace v8 {
      16             : namespace internal {
      17             : 
      18             : // Forward declarations for C++ builtins.
      19             : #define FORWARD_DECLARE(Name) \
      20             :   Object* Builtin_##Name(int argc, Object** args, Isolate* isolate);
      21             : BUILTIN_LIST_C(FORWARD_DECLARE)
      22             : 
      23       60782 : Builtins::Builtins() : initialized_(false) {
      24       60782 :   memset(builtins_, 0, sizeof(builtins_[0]) * builtin_count);
      25       60782 : }
      26             : 
      27       59284 : Builtins::~Builtins() {}
      28             : 
      29       59285 : void Builtins::TearDown() { initialized_ = false; }
      30             : 
      31      172396 : void Builtins::IterateBuiltins(RootVisitor* v) {
      32             :   v->VisitRootPointers(Root::kBuiltins, &builtins_[0],
      33      172396 :                        &builtins_[0] + builtin_count);
      34      172396 : }
      35             : 
      36           0 : const char* Builtins::Lookup(byte* pc) {
      37             :   // may be called during initialization (disassembler!)
      38           0 :   if (initialized_) {
      39           0 :     for (int i = 0; i < builtin_count; i++) {
      40           0 :       Code* entry = Code::cast(builtins_[i]);
      41           0 :       if (entry->contains(pc)) return name(i);
      42             :     }
      43             :   }
      44             :   return NULL;
      45             : }
      46             : 
      47       45327 : Handle<Code> Builtins::NewFunctionContext(ScopeType scope_type) {
      48       45327 :   switch (scope_type) {
      49             :     case ScopeType::EVAL_SCOPE:
      50             :       return FastNewFunctionContextEval();
      51             :     case ScopeType::FUNCTION_SCOPE:
      52             :       return FastNewFunctionContextFunction();
      53             :     default:
      54           0 :       UNREACHABLE();
      55             :   }
      56             :   return Handle<Code>::null();
      57             : }
      58             : 
      59       92354 : Handle<Code> Builtins::NewCloneShallowArray(
      60             :     AllocationSiteMode allocation_mode) {
      61       92354 :   switch (allocation_mode) {
      62             :     case TRACK_ALLOCATION_SITE:
      63             :       return FastCloneShallowArrayTrack();
      64             :     case DONT_TRACK_ALLOCATION_SITE:
      65             :       return FastCloneShallowArrayDontTrack();
      66             :     default:
      67           0 :       UNREACHABLE();
      68             :   }
      69             :   return Handle<Code>::null();
      70             : }
      71             : 
      72       47983 : Handle<Code> Builtins::NewCloneShallowObject(int length) {
      73       47983 :   switch (length) {
      74             :     case 0:
      75             :       return FastCloneShallowObject0();
      76             :     case 1:
      77             :       return FastCloneShallowObject1();
      78             :     case 2:
      79             :       return FastCloneShallowObject2();
      80             :     case 3:
      81             :       return FastCloneShallowObject3();
      82             :     case 4:
      83             :       return FastCloneShallowObject4();
      84             :     case 5:
      85             :       return FastCloneShallowObject5();
      86             :     case 6:
      87             :       return FastCloneShallowObject6();
      88             :     default:
      89           0 :       UNREACHABLE();
      90             :   }
      91             :   return Handle<Code>::null();
      92             : }
      93             : 
      94        2200 : Handle<Code> Builtins::NonPrimitiveToPrimitive(ToPrimitiveHint hint) {
      95        2200 :   switch (hint) {
      96             :     case ToPrimitiveHint::kDefault:
      97             :       return NonPrimitiveToPrimitive_Default();
      98             :     case ToPrimitiveHint::kNumber:
      99             :       return NonPrimitiveToPrimitive_Number();
     100             :     case ToPrimitiveHint::kString:
     101             :       return NonPrimitiveToPrimitive_String();
     102             :   }
     103           0 :   UNREACHABLE();
     104             :   return Handle<Code>::null();
     105             : }
     106             : 
     107         215 : Handle<Code> Builtins::OrdinaryToPrimitive(OrdinaryToPrimitiveHint hint) {
     108         215 :   switch (hint) {
     109             :     case OrdinaryToPrimitiveHint::kNumber:
     110             :       return OrdinaryToPrimitive_Number();
     111             :     case OrdinaryToPrimitiveHint::kString:
     112             :       return OrdinaryToPrimitive_String();
     113             :   }
     114           0 :   UNREACHABLE();
     115             :   return Handle<Code>::null();
     116             : }
     117             : 
     118             : // static
     119        5739 : Callable Builtins::CallableFor(Isolate* isolate, Name name) {
     120        5739 :   switch (name) {
     121             : #define CASE(Name, ...)                                              \
     122             :   case k##Name: {                                                    \
     123             :     Handle<Code> code = isolate->builtins()->Name();                 \
     124             :     auto descriptor = Builtin_##Name##_InterfaceDescriptor(isolate); \
     125             :     return Callable(code, descriptor);                               \
     126             :   }
     127        5696 :     BUILTIN_LIST(IGNORE_BUILTIN, IGNORE_BUILTIN, IGNORE_BUILTIN, CASE, CASE,
     128             :                  CASE, IGNORE_BUILTIN, IGNORE_BUILTIN)
     129             : #undef CASE
     130             :     case kConsoleAssert: {
     131             :       Handle<Code> code = isolate->builtins()->ConsoleAssert();
     132          86 :       return Callable(code, BuiltinDescriptor(isolate));
     133             :     }
     134             :     default:
     135           0 :       UNREACHABLE();
     136             :       return Callable(Handle<Code>::null(), VoidDescriptor(isolate));
     137             :   }
     138             : }
     139             : 
     140             : // static
     141      283062 : const char* Builtins::name(int index) {
     142      283062 :   switch (index) {
     143             : #define CASE(Name, ...) \
     144             :   case k##Name:         \
     145             :     return #Name;
     146         426 :     BUILTIN_LIST_ALL(CASE)
     147             : #undef CASE
     148             :     default:
     149           0 :       UNREACHABLE();
     150             :       break;
     151             :   }
     152             :   return "";
     153             : }
     154             : 
     155             : // static
     156       11764 : Address Builtins::CppEntryOf(int index) {
     157             :   DCHECK(0 <= index && index < builtin_count);
     158       11764 :   switch (index) {
     159             : #define CASE(Name, ...) \
     160             :   case k##Name:         \
     161             :     return FUNCTION_ADDR(Builtin_##Name);
     162             :     BUILTIN_LIST_C(CASE)
     163             : #undef CASE
     164             :     default:
     165             :       return nullptr;
     166             :   }
     167             :   UNREACHABLE();
     168             : }
     169             : 
     170             : // static
     171       11764 : bool Builtins::IsCpp(int index) {
     172             :   DCHECK(0 <= index && index < builtin_count);
     173       11764 :   switch (index) {
     174             : #define CASE(Name, ...) \
     175             :   case k##Name:         \
     176             :     return true;
     177             : #define BUILTIN_LIST_CPP(V)                                       \
     178             :   BUILTIN_LIST(V, IGNORE_BUILTIN, IGNORE_BUILTIN, IGNORE_BUILTIN, \
     179             :                IGNORE_BUILTIN, IGNORE_BUILTIN, IGNORE_BUILTIN, IGNORE_BUILTIN)
     180             :     BUILTIN_LIST_CPP(CASE)
     181             : #undef BUILTIN_LIST_CPP
     182             : #undef CASE
     183             :     default:
     184          93 :       return false;
     185             :   }
     186             :   UNREACHABLE();
     187             : }
     188             : 
     189             : // static
     190           0 : bool Builtins::IsApi(int index) {
     191             :   DCHECK(0 <= index && index < builtin_count);
     192           0 :   switch (index) {
     193             : #define CASE(Name, ...) \
     194             :   case k##Name:         \
     195             :     return true;
     196             : #define BUILTIN_LIST_API(V)                                       \
     197             :   BUILTIN_LIST(IGNORE_BUILTIN, V, IGNORE_BUILTIN, IGNORE_BUILTIN, \
     198             :                IGNORE_BUILTIN, IGNORE_BUILTIN, IGNORE_BUILTIN, IGNORE_BUILTIN)
     199             :     BUILTIN_LIST_API(CASE);
     200             : #undef BUILTIN_LIST_API
     201             : #undef CASE
     202             :     default:
     203           0 :       return false;
     204             :   }
     205             :   UNREACHABLE();
     206             : }
     207             : 
     208             : // static
     209      135428 : bool Builtins::HasCppImplementation(int index) {
     210             :   DCHECK(0 <= index && index < builtin_count);
     211      135428 :   switch (index) {
     212             : #define CASE(Name, ...) \
     213             :   case k##Name:         \
     214             :     return true;
     215             :     BUILTIN_LIST_C(CASE)
     216             : #undef CASE
     217             :     default:
     218      123651 :       return false;
     219             :   }
     220             :   UNREACHABLE();
     221             : }
     222             : 
     223             : #define DEFINE_BUILTIN_ACCESSOR(Name, ...)                                    \
     224             :   Handle<Code> Builtins::Name() {                                             \
     225             :     Code** code_address = reinterpret_cast<Code**>(builtin_address(k##Name)); \
     226             :     return Handle<Code>(code_address);                                        \
     227             :   }
     228   102124325 : BUILTIN_LIST_ALL(DEFINE_BUILTIN_ACCESSOR)
     229             : #undef DEFINE_BUILTIN_ACCESSOR
     230             : 
     231             : // static
     232     3599990 : bool Builtins::AllowDynamicFunction(Isolate* isolate, Handle<JSFunction> target,
     233             :                                     Handle<JSObject> target_global_proxy) {
     234     1800191 :   if (FLAG_allow_unsafe_function_constructor) return true;
     235             :   HandleScopeImplementer* impl = isolate->handle_scope_implementer();
     236             :   Handle<Context> responsible_context =
     237             :       impl->MicrotaskContextIsLastEnteredContext() ? impl->MicrotaskContext()
     238     1799799 :                                                    : impl->LastEnteredContext();
     239             :   // TODO(jochen): Remove this.
     240     1799799 :   if (responsible_context.is_null()) {
     241             :     return true;
     242             :   }
     243     1799799 :   if (*responsible_context == target->context()) return true;
     244         406 :   return isolate->MayAccess(responsible_context, target_global_proxy);
     245             : }
     246             : 
     247             : }  // namespace internal
     248             : }  // namespace v8

Generated by: LCOV version 1.10