LCOV - code coverage report
Current view: top level - src/builtins - builtins-handler-gen.cc (source / functions) Hit Total Coverage
Test: app.info Lines: 68 68 100.0 %
Date: 2017-04-26 Functions: 28 28 100.0 %

          Line data    Source code
       1             : // Copyright 2016 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-utils-gen.h"
       6             : #include "src/builtins/builtins.h"
       7             : #include "src/code-stub-assembler.h"
       8             : #include "src/ic/handler-compiler.h"
       9             : #include "src/ic/ic.h"
      10             : #include "src/ic/keyed-store-generic.h"
      11             : #include "src/objects-inl.h"
      12             : 
      13             : namespace v8 {
      14             : namespace internal {
      15             : 
      16         129 : TF_BUILTIN(KeyedLoadIC_IndexedString, CodeStubAssembler) {
      17             :   Node* receiver = Parameter(Descriptor::kReceiver);
      18             :   Node* index = Parameter(Descriptor::kName);
      19             :   Node* slot = Parameter(Descriptor::kSlot);
      20             :   Node* vector = Parameter(Descriptor::kVector);
      21             :   Node* context = Parameter(Descriptor::kContext);
      22             : 
      23             :   Label miss(this);
      24             : 
      25          43 :   Node* index_intptr = TryToIntptr(index, &miss);
      26          43 :   Node* length = SmiUntag(LoadStringLength(receiver));
      27          43 :   GotoIf(UintPtrGreaterThanOrEqual(index_intptr, length), &miss);
      28             : 
      29          43 :   Node* code = StringCharCodeAt(receiver, index_intptr, INTPTR_PARAMETERS);
      30          43 :   Node* result = StringFromCharCode(code);
      31          43 :   Return(result);
      32             : 
      33          43 :   BIND(&miss);
      34             :   TailCallRuntime(Runtime::kKeyedLoadIC_Miss, context, receiver, index, slot,
      35          43 :                   vector);
      36          43 : }
      37             : 
      38         129 : TF_BUILTIN(KeyedLoadIC_Miss, CodeStubAssembler) {
      39             :   Node* receiver = Parameter(Descriptor::kReceiver);
      40             :   Node* name = Parameter(Descriptor::kName);
      41             :   Node* slot = Parameter(Descriptor::kSlot);
      42             :   Node* vector = Parameter(Descriptor::kVector);
      43             :   Node* context = Parameter(Descriptor::kContext);
      44             : 
      45             :   TailCallRuntime(Runtime::kKeyedLoadIC_Miss, context, receiver, name, slot,
      46          43 :                   vector);
      47          43 : }
      48             : 
      49         129 : TF_BUILTIN(KeyedLoadIC_Slow, CodeStubAssembler) {
      50             :   Node* receiver = Parameter(Descriptor::kReceiver);
      51             :   Node* name = Parameter(Descriptor::kName);
      52             :   Node* context = Parameter(Descriptor::kContext);
      53             : 
      54          43 :   TailCallRuntime(Runtime::kKeyedGetProperty, context, receiver, name);
      55          43 : }
      56             : 
      57          43 : void Builtins::Generate_KeyedStoreIC_Megamorphic(
      58             :     compiler::CodeAssemblerState* state) {
      59          43 :   KeyedStoreGenericGenerator::Generate(state, SLOPPY);
      60          43 : }
      61             : 
      62          43 : void Builtins::Generate_KeyedStoreIC_Megamorphic_Strict(
      63             :     compiler::CodeAssemblerState* state) {
      64          43 :   KeyedStoreGenericGenerator::Generate(state, STRICT);
      65          43 : }
      66             : 
      67          43 : void Builtins::Generate_StoreIC_Uninitialized(
      68             :     compiler::CodeAssemblerState* state) {
      69          43 :   StoreICUninitializedGenerator::Generate(state, SLOPPY);
      70          43 : }
      71             : 
      72          43 : void Builtins::Generate_StoreICStrict_Uninitialized(
      73             :     compiler::CodeAssemblerState* state) {
      74          43 :   StoreICUninitializedGenerator::Generate(state, STRICT);
      75          43 : }
      76             : 
      77         129 : TF_BUILTIN(KeyedStoreIC_Miss, CodeStubAssembler) {
      78             :   Node* receiver = Parameter(Descriptor::kReceiver);
      79             :   Node* name = Parameter(Descriptor::kName);
      80             :   Node* value = Parameter(Descriptor::kValue);
      81             :   Node* slot = Parameter(Descriptor::kSlot);
      82             :   Node* vector = Parameter(Descriptor::kVector);
      83             :   Node* context = Parameter(Descriptor::kContext);
      84             : 
      85             :   TailCallRuntime(Runtime::kKeyedStoreIC_Miss, context, value, slot, vector,
      86          43 :                   receiver, name);
      87          43 : }
      88             : 
      89         129 : TF_BUILTIN(KeyedStoreIC_Slow, CodeStubAssembler) {
      90             :   Node* receiver = Parameter(Descriptor::kReceiver);
      91             :   Node* name = Parameter(Descriptor::kName);
      92             :   Node* value = Parameter(Descriptor::kValue);
      93             :   Node* slot = Parameter(Descriptor::kSlot);
      94             :   Node* vector = Parameter(Descriptor::kVector);
      95             :   Node* context = Parameter(Descriptor::kContext);
      96             : 
      97             :   // The slow case calls into the runtime to complete the store without causing
      98             :   // an IC miss that would otherwise cause a transition to the generic stub.
      99             :   TailCallRuntime(Runtime::kKeyedStoreIC_Slow, context, value, slot, vector,
     100          43 :                   receiver, name);
     101          43 : }
     102             : 
     103         129 : TF_BUILTIN(LoadGlobalIC_Miss, CodeStubAssembler) {
     104             :   Node* name = Parameter(Descriptor::kName);
     105             :   Node* slot = Parameter(Descriptor::kSlot);
     106             :   Node* vector = Parameter(Descriptor::kVector);
     107             :   Node* context = Parameter(Descriptor::kContext);
     108             : 
     109          43 :   TailCallRuntime(Runtime::kLoadGlobalIC_Miss, context, name, slot, vector);
     110          43 : }
     111             : 
     112         129 : TF_BUILTIN(LoadGlobalIC_Slow, CodeStubAssembler) {
     113             :   Node* name = Parameter(Descriptor::kName);
     114             :   Node* slot = Parameter(Descriptor::kSlot);
     115             :   Node* vector = Parameter(Descriptor::kVector);
     116             :   Node* context = Parameter(Descriptor::kContext);
     117             : 
     118          43 :   TailCallRuntime(Runtime::kLoadGlobalIC_Slow, context, name, slot, vector);
     119          43 : }
     120             : 
     121          43 : void Builtins::Generate_LoadIC_Getter_ForDeopt(MacroAssembler* masm) {
     122          43 :   NamedLoadHandlerCompiler::GenerateLoadViaGetterForDeopt(masm);
     123          43 : }
     124             : 
     125         129 : TF_BUILTIN(LoadIC_FunctionPrototype, CodeStubAssembler) {
     126             :   Node* receiver = Parameter(Descriptor::kReceiver);
     127             :   Node* name = Parameter(Descriptor::kName);
     128             :   Node* slot = Parameter(Descriptor::kSlot);
     129             :   Node* vector = Parameter(Descriptor::kVector);
     130             :   Node* context = Parameter(Descriptor::kContext);
     131             : 
     132             :   Label miss(this);
     133             : 
     134             :   Node* proto_or_map =
     135          43 :       LoadObjectField(receiver, JSFunction::kPrototypeOrInitialMapOffset);
     136          43 :   GotoIf(IsTheHole(proto_or_map), &miss);
     137             : 
     138          86 :   VARIABLE(var_result, MachineRepresentation::kTagged, proto_or_map);
     139          43 :   Label done(this, &var_result);
     140          43 :   GotoIfNot(IsMap(proto_or_map), &done);
     141             : 
     142          43 :   var_result.Bind(LoadMapPrototype(proto_or_map));
     143          43 :   Goto(&done);
     144             : 
     145          43 :   BIND(&done);
     146          43 :   Return(var_result.value());
     147             : 
     148          43 :   BIND(&miss);
     149          86 :   TailCallRuntime(Runtime::kLoadIC_Miss, context, receiver, name, slot, vector);
     150          43 : }
     151             : 
     152         129 : TF_BUILTIN(LoadIC_Miss, CodeStubAssembler) {
     153             :   Node* receiver = Parameter(Descriptor::kReceiver);
     154             :   Node* name = Parameter(Descriptor::kName);
     155             :   Node* slot = Parameter(Descriptor::kSlot);
     156             :   Node* vector = Parameter(Descriptor::kVector);
     157             :   Node* context = Parameter(Descriptor::kContext);
     158             : 
     159          43 :   TailCallRuntime(Runtime::kLoadIC_Miss, context, receiver, name, slot, vector);
     160          43 : }
     161             : 
     162         129 : TF_BUILTIN(LoadIC_Slow, CodeStubAssembler) {
     163             :   Node* receiver = Parameter(Descriptor::kReceiver);
     164             :   Node* name = Parameter(Descriptor::kName);
     165             :   Node* context = Parameter(Descriptor::kContext);
     166             : 
     167          43 :   TailCallRuntime(Runtime::kGetProperty, context, receiver, name);
     168          43 : }
     169             : 
     170         129 : TF_BUILTIN(StoreIC_Miss, CodeStubAssembler) {
     171             :   Node* receiver = Parameter(Descriptor::kReceiver);
     172             :   Node* name = Parameter(Descriptor::kName);
     173             :   Node* value = Parameter(Descriptor::kValue);
     174             :   Node* slot = Parameter(Descriptor::kSlot);
     175             :   Node* vector = Parameter(Descriptor::kVector);
     176             :   Node* context = Parameter(Descriptor::kContext);
     177             : 
     178             :   TailCallRuntime(Runtime::kStoreIC_Miss, context, value, slot, vector,
     179          43 :                   receiver, name);
     180          43 : }
     181             : 
     182          43 : void Builtins::Generate_StoreIC_Setter_ForDeopt(MacroAssembler* masm) {
     183          43 :   NamedStoreHandlerCompiler::GenerateStoreViaSetterForDeopt(masm);
     184          43 : }
     185             : 
     186             : }  // namespace internal
     187             : }  // namespace v8

Generated by: LCOV version 1.10