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

          Line data    Source code
       1             : // Copyright 2017 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             : 
       9             : namespace v8 {
      10             : namespace internal {
      11             : 
      12             : // -----------------------------------------------------------------------------
      13             : // ES6 section 19.1 Object Objects
      14             : 
      15             : typedef compiler::Node Node;
      16             : 
      17             : class ObjectBuiltinsAssembler : public CodeStubAssembler {
      18             :  public:
      19             :   explicit ObjectBuiltinsAssembler(compiler::CodeAssemblerState* state)
      20         344 :       : CodeStubAssembler(state) {}
      21             : 
      22             :  protected:
      23             :   void IsString(Node* object, Label* if_string, Label* if_notstring);
      24             :   void ReturnToStringFormat(Node* context, Node* string);
      25             : };
      26             : 
      27          43 : void ObjectBuiltinsAssembler::IsString(Node* object, Label* if_string,
      28             :                                        Label* if_notstring) {
      29          43 :   Label if_notsmi(this);
      30          43 :   Branch(TaggedIsSmi(object), if_notstring, &if_notsmi);
      31             : 
      32          43 :   BIND(&if_notsmi);
      33             :   {
      34          43 :     Node* instance_type = LoadInstanceType(object);
      35             : 
      36          43 :     Branch(IsStringInstanceType(instance_type), if_string, if_notstring);
      37          43 :   }
      38          43 : }
      39             : 
      40          86 : void ObjectBuiltinsAssembler::ReturnToStringFormat(Node* context,
      41             :                                                    Node* string) {
      42         172 :   Node* lhs = HeapConstant(factory()->NewStringFromStaticChars("[object "));
      43         172 :   Node* rhs = HeapConstant(factory()->NewStringFromStaticChars("]"));
      44             : 
      45             :   Callable callable =
      46          86 :       CodeFactory::StringAdd(isolate(), STRING_ADD_CHECK_NONE, NOT_TENURED);
      47             : 
      48             :   Return(CallStub(callable, context, CallStub(callable, context, lhs, string),
      49          86 :                   rhs));
      50          86 : }
      51             : 
      52         172 : TF_BUILTIN(ObjectHasOwnProperty, ObjectBuiltinsAssembler) {
      53             :   Node* object = Parameter(Descriptor::kReceiver);
      54             :   Node* key = Parameter(Descriptor::kKey);
      55             :   Node* context = Parameter(Descriptor::kContext);
      56             : 
      57          43 :   Label call_runtime(this), return_true(this), return_false(this);
      58             : 
      59             :   // Smi receivers do not have own properties.
      60          43 :   Label if_objectisnotsmi(this);
      61          43 :   Branch(TaggedIsSmi(object), &return_false, &if_objectisnotsmi);
      62          43 :   BIND(&if_objectisnotsmi);
      63             : 
      64          43 :   Node* map = LoadMap(object);
      65          43 :   Node* instance_type = LoadMapInstanceType(map);
      66             : 
      67             :   {
      68          43 :     VARIABLE(var_index, MachineType::PointerRepresentation());
      69          86 :     VARIABLE(var_unique, MachineRepresentation::kTagged);
      70             : 
      71          43 :     Label if_index(this), if_unique_name(this), if_notunique_name(this);
      72             :     TryToName(key, &if_index, &var_index, &if_unique_name, &var_unique,
      73          43 :               &call_runtime, &if_notunique_name);
      74             : 
      75          43 :     BIND(&if_unique_name);
      76             :     TryHasOwnProperty(object, map, instance_type, var_unique.value(),
      77          43 :                       &return_true, &return_false, &call_runtime);
      78             : 
      79          43 :     BIND(&if_index);
      80             :     {
      81             :       // Handle negative keys in the runtime.
      82             :       GotoIf(IntPtrLessThan(var_index.value(), IntPtrConstant(0)),
      83          43 :              &call_runtime);
      84             :       TryLookupElement(object, map, instance_type, var_index.value(),
      85             :                        &return_true, &return_false, &return_false,
      86          43 :                        &call_runtime);
      87             :     }
      88             : 
      89          43 :     BIND(&if_notunique_name);
      90             :     {
      91             :       // If the string was not found in the string table, then no object can
      92             :       // have a property with that name, so return |false|.
      93             :       TryInternalizeString(key, &if_index, &var_index, &if_unique_name,
      94          43 :                            &var_unique, &return_false, &call_runtime);
      95          43 :     }
      96             :   }
      97          43 :   BIND(&return_true);
      98          43 :   Return(BooleanConstant(true));
      99             : 
     100          43 :   BIND(&return_false);
     101          43 :   Return(BooleanConstant(false));
     102             : 
     103          43 :   BIND(&call_runtime);
     104          86 :   Return(CallRuntime(Runtime::kObjectHasOwnProperty, context, object, key));
     105          43 : }
     106             : 
     107             : // ES6 #sec-object.prototype.tostring
     108         215 : TF_BUILTIN(ObjectProtoToString, ObjectBuiltinsAssembler) {
     109          43 :   Label return_undefined(this, Label::kDeferred),
     110          43 :       return_null(this, Label::kDeferred),
     111          43 :       return_arguments(this, Label::kDeferred), return_array(this),
     112          43 :       return_api(this, Label::kDeferred), return_object(this),
     113          43 :       return_regexp(this), return_function(this), return_error(this),
     114          43 :       return_date(this), return_jsvalue(this),
     115          43 :       return_jsproxy(this, Label::kDeferred);
     116             : 
     117          43 :   Label if_isproxy(this, Label::kDeferred);
     118             : 
     119          43 :   Label checkstringtag(this);
     120          43 :   Label if_tostringtag(this), if_notostringtag(this);
     121             : 
     122             :   Node* receiver = Parameter(Descriptor::kReceiver);
     123             :   Node* context = Parameter(Descriptor::kContext);
     124             : 
     125          43 :   GotoIf(WordEqual(receiver, UndefinedConstant()), &return_undefined);
     126             : 
     127          43 :   GotoIf(WordEqual(receiver, NullConstant()), &return_null);
     128             : 
     129          43 :   Callable to_object = CodeFactory::ToObject(isolate());
     130          43 :   receiver = CallStub(to_object, context, receiver);
     131             : 
     132          43 :   Node* receiver_instance_type = LoadInstanceType(receiver);
     133             : 
     134             :   // for proxies, check IsArray before getting @@toStringTag
     135          86 :   VARIABLE(var_proxy_is_array, MachineRepresentation::kTagged);
     136          43 :   var_proxy_is_array.Bind(BooleanConstant(false));
     137             : 
     138             :   Branch(Word32Equal(receiver_instance_type, Int32Constant(JS_PROXY_TYPE)),
     139          43 :          &if_isproxy, &checkstringtag);
     140             : 
     141          43 :   BIND(&if_isproxy);
     142             :   {
     143             :     // This can throw
     144             :     var_proxy_is_array.Bind(
     145          43 :         CallRuntime(Runtime::kArrayIsArray, context, receiver));
     146          43 :     Goto(&checkstringtag);
     147             :   }
     148             : 
     149          43 :   BIND(&checkstringtag);
     150             :   {
     151             :     Node* to_string_tag_symbol =
     152          86 :         HeapConstant(isolate()->factory()->to_string_tag_symbol());
     153             : 
     154          43 :     GetPropertyStub stub(isolate());
     155             :     Callable get_property =
     156          43 :         Callable(stub.GetCode(), stub.GetCallInterfaceDescriptor());
     157             :     Node* to_string_tag_value =
     158          43 :         CallStub(get_property, context, receiver, to_string_tag_symbol);
     159             : 
     160          43 :     IsString(to_string_tag_value, &if_tostringtag, &if_notostringtag);
     161             : 
     162          43 :     BIND(&if_tostringtag);
     163          43 :     ReturnToStringFormat(context, to_string_tag_value);
     164             :   }
     165          43 :   BIND(&if_notostringtag);
     166             :   {
     167             :     size_t const kNumCases = 11;
     168             :     Label* case_labels[kNumCases];
     169             :     int32_t case_values[kNumCases];
     170          43 :     case_labels[0] = &return_api;
     171          43 :     case_values[0] = JS_API_OBJECT_TYPE;
     172          43 :     case_labels[1] = &return_api;
     173          43 :     case_values[1] = JS_SPECIAL_API_OBJECT_TYPE;
     174          43 :     case_labels[2] = &return_arguments;
     175          43 :     case_values[2] = JS_ARGUMENTS_TYPE;
     176          43 :     case_labels[3] = &return_array;
     177          43 :     case_values[3] = JS_ARRAY_TYPE;
     178          43 :     case_labels[4] = &return_function;
     179          43 :     case_values[4] = JS_BOUND_FUNCTION_TYPE;
     180          43 :     case_labels[5] = &return_function;
     181          43 :     case_values[5] = JS_FUNCTION_TYPE;
     182          43 :     case_labels[6] = &return_error;
     183          43 :     case_values[6] = JS_ERROR_TYPE;
     184          43 :     case_labels[7] = &return_date;
     185          43 :     case_values[7] = JS_DATE_TYPE;
     186          43 :     case_labels[8] = &return_regexp;
     187          43 :     case_values[8] = JS_REGEXP_TYPE;
     188          43 :     case_labels[9] = &return_jsvalue;
     189          43 :     case_values[9] = JS_VALUE_TYPE;
     190          43 :     case_labels[10] = &return_jsproxy;
     191          43 :     case_values[10] = JS_PROXY_TYPE;
     192             : 
     193             :     Switch(receiver_instance_type, &return_object, case_values, case_labels,
     194          43 :            arraysize(case_values));
     195             : 
     196          43 :     BIND(&return_undefined);
     197          86 :     Return(HeapConstant(isolate()->factory()->undefined_to_string()));
     198             : 
     199          43 :     BIND(&return_null);
     200          86 :     Return(HeapConstant(isolate()->factory()->null_to_string()));
     201             : 
     202          43 :     BIND(&return_arguments);
     203          86 :     Return(HeapConstant(isolate()->factory()->arguments_to_string()));
     204             : 
     205          43 :     BIND(&return_array);
     206          86 :     Return(HeapConstant(isolate()->factory()->array_to_string()));
     207             : 
     208          43 :     BIND(&return_function);
     209          86 :     Return(HeapConstant(isolate()->factory()->function_to_string()));
     210             : 
     211          43 :     BIND(&return_error);
     212          86 :     Return(HeapConstant(isolate()->factory()->error_to_string()));
     213             : 
     214          43 :     BIND(&return_date);
     215          86 :     Return(HeapConstant(isolate()->factory()->date_to_string()));
     216             : 
     217          43 :     BIND(&return_regexp);
     218          86 :     Return(HeapConstant(isolate()->factory()->regexp_to_string()));
     219             : 
     220          43 :     BIND(&return_api);
     221             :     {
     222          43 :       Node* class_name = CallRuntime(Runtime::kClassOf, context, receiver);
     223          43 :       ReturnToStringFormat(context, class_name);
     224             :     }
     225             : 
     226          43 :     BIND(&return_jsvalue);
     227             :     {
     228          43 :       Label return_boolean(this), return_number(this), return_string(this);
     229             : 
     230          43 :       Node* value = LoadJSValueValue(receiver);
     231          43 :       GotoIf(TaggedIsSmi(value), &return_number);
     232          43 :       Node* instance_type = LoadInstanceType(value);
     233             : 
     234          43 :       GotoIf(IsStringInstanceType(instance_type), &return_string);
     235             :       GotoIf(Word32Equal(instance_type, Int32Constant(HEAP_NUMBER_TYPE)),
     236          43 :              &return_number);
     237             :       GotoIf(Word32Equal(instance_type, Int32Constant(ODDBALL_TYPE)),
     238          43 :              &return_boolean);
     239             : 
     240             :       CSA_ASSERT(this, Word32Equal(instance_type, Int32Constant(SYMBOL_TYPE)));
     241          43 :       Goto(&return_object);
     242             : 
     243          43 :       BIND(&return_string);
     244          86 :       Return(HeapConstant(isolate()->factory()->string_to_string()));
     245             : 
     246          43 :       BIND(&return_number);
     247          86 :       Return(HeapConstant(isolate()->factory()->number_to_string()));
     248             : 
     249          43 :       BIND(&return_boolean);
     250         129 :       Return(HeapConstant(isolate()->factory()->boolean_to_string()));
     251             :     }
     252             : 
     253          43 :     BIND(&return_jsproxy);
     254             :     {
     255             :       GotoIf(WordEqual(var_proxy_is_array.value(), BooleanConstant(true)),
     256          43 :              &return_array);
     257             : 
     258          43 :       Node* map = LoadMap(receiver);
     259             : 
     260             :       // Return object if the proxy {receiver} is not callable.
     261          43 :       Branch(IsCallableMap(map), &return_function, &return_object);
     262             :     }
     263             : 
     264             :     // Default
     265          43 :     BIND(&return_object);
     266          86 :     Return(HeapConstant(isolate()->factory()->object_to_string()));
     267          43 :   }
     268          43 : }
     269             : 
     270             : // ES6 #sec-object.prototype.valueof
     271         129 : TF_BUILTIN(ObjectPrototypeValueOf, CodeStubAssembler) {
     272             :   Node* receiver = Parameter(Descriptor::kReceiver);
     273             :   Node* context = Parameter(Descriptor::kContext);
     274             : 
     275          43 :   Callable to_object = CodeFactory::ToObject(isolate());
     276          43 :   receiver = CallStub(to_object, context, receiver);
     277             : 
     278          43 :   Return(receiver);
     279          43 : }
     280             : 
     281             : // ES #sec-object.create
     282         172 : TF_BUILTIN(ObjectCreate, ObjectBuiltinsAssembler) {
     283             :   Node* prototype = Parameter(Descriptor::kPrototype);
     284             :   Node* properties = Parameter(Descriptor::kProperties);
     285             :   Node* context = Parameter(Descriptor::kContext);
     286             : 
     287          43 :   Label call_runtime(this, Label::kDeferred), prototype_valid(this),
     288          43 :       no_properties(this);
     289             :   {
     290          43 :     Comment("Argument 1 check: prototype");
     291          43 :     GotoIf(WordEqual(prototype, NullConstant()), &prototype_valid);
     292          43 :     BranchIfJSReceiver(prototype, &prototype_valid, &call_runtime);
     293             :   }
     294             : 
     295          43 :   BIND(&prototype_valid);
     296             :   {
     297          43 :     Comment("Argument 2 check: properties");
     298             :     // Check that we have a simple object
     299          43 :     GotoIf(TaggedIsSmi(properties), &call_runtime);
     300             :     // Undefined implies no properties.
     301          43 :     GotoIf(WordEqual(properties, UndefinedConstant()), &no_properties);
     302          43 :     Node* properties_map = LoadMap(properties);
     303          43 :     GotoIf(IsSpecialReceiverMap(properties_map), &call_runtime);
     304             :     // Stay on the fast path only if there are no elements.
     305             :     GotoIfNot(WordEqual(LoadElements(properties),
     306             :                         LoadRoot(Heap::kEmptyFixedArrayRootIndex)),
     307          43 :               &call_runtime);
     308             :     // Handle dictionary objects or fast objects with properties in runtime.
     309          43 :     Node* bit_field3 = LoadMapBitField3(properties_map);
     310          43 :     GotoIf(IsSetWord32<Map::DictionaryMap>(bit_field3), &call_runtime);
     311             :     Branch(IsSetWord32<Map::NumberOfOwnDescriptorsBits>(bit_field3),
     312          43 :            &call_runtime, &no_properties);
     313             :   }
     314             : 
     315             :   // Create a new object with the given prototype.
     316          43 :   BIND(&no_properties);
     317             :   {
     318          43 :     VARIABLE(map, MachineRepresentation::kTagged);
     319          86 :     VARIABLE(properties, MachineRepresentation::kTagged);
     320          43 :     Label non_null_proto(this), instantiate_map(this), good(this);
     321             : 
     322          43 :     Branch(WordEqual(prototype, NullConstant()), &good, &non_null_proto);
     323             : 
     324          43 :     BIND(&good);
     325             :     {
     326             :       map.Bind(LoadContextElement(
     327          43 :           context, Context::SLOW_OBJECT_WITH_NULL_PROTOTYPE_MAP));
     328          43 :       properties.Bind(AllocateNameDictionary(NameDictionary::kInitialCapacity));
     329          43 :       Goto(&instantiate_map);
     330             :     }
     331             : 
     332          43 :     BIND(&non_null_proto);
     333             :     {
     334          43 :       properties.Bind(EmptyFixedArrayConstant());
     335             :       Node* object_function =
     336          43 :           LoadContextElement(context, Context::OBJECT_FUNCTION_INDEX);
     337             :       Node* object_function_map = LoadObjectField(
     338          43 :           object_function, JSFunction::kPrototypeOrInitialMapOffset);
     339          43 :       map.Bind(object_function_map);
     340             :       GotoIf(WordEqual(prototype, LoadMapPrototype(map.value())),
     341          43 :              &instantiate_map);
     342             :       // Try loading the prototype info.
     343             :       Node* prototype_info =
     344          43 :           LoadMapPrototypeInfo(LoadMap(prototype), &call_runtime);
     345          43 :       Comment("Load ObjectCreateMap from PrototypeInfo");
     346             :       Node* weak_cell =
     347          43 :           LoadObjectField(prototype_info, PrototypeInfo::kObjectCreateMap);
     348          43 :       GotoIf(WordEqual(weak_cell, UndefinedConstant()), &call_runtime);
     349          43 :       map.Bind(LoadWeakCellValue(weak_cell, &call_runtime));
     350          43 :       Goto(&instantiate_map);
     351             :     }
     352             : 
     353          43 :     BIND(&instantiate_map);
     354             :     {
     355          43 :       Node* instance = AllocateJSObjectFromMap(map.value(), properties.value());
     356          43 :       Return(instance);
     357          43 :     }
     358             :   }
     359             : 
     360          43 :   BIND(&call_runtime);
     361             :   {
     362          43 :     Return(CallRuntime(Runtime::kObjectCreate, context, prototype, properties));
     363          43 :   }
     364          43 : }
     365             : 
     366         172 : TF_BUILTIN(CreateIterResultObject, ObjectBuiltinsAssembler) {
     367             :   Node* const value = Parameter(Descriptor::kValue);
     368             :   Node* const done = Parameter(Descriptor::kDone);
     369             :   Node* const context = Parameter(Descriptor::kContext);
     370             : 
     371          43 :   Node* const native_context = LoadNativeContext(context);
     372             :   Node* const map =
     373          43 :       LoadContextElement(native_context, Context::ITERATOR_RESULT_MAP_INDEX);
     374             : 
     375          43 :   Node* const result = AllocateJSObjectFromMap(map);
     376             : 
     377          43 :   StoreObjectFieldNoWriteBarrier(result, JSIteratorResult::kValueOffset, value);
     378          43 :   StoreObjectFieldNoWriteBarrier(result, JSIteratorResult::kDoneOffset, done);
     379             : 
     380          43 :   Return(result);
     381          43 : }
     382             : 
     383         172 : TF_BUILTIN(HasProperty, ObjectBuiltinsAssembler) {
     384             :   Node* key = Parameter(Descriptor::kKey);
     385             :   Node* object = Parameter(Descriptor::kObject);
     386             :   Node* context = Parameter(Descriptor::kContext);
     387             : 
     388          43 :   Return(HasProperty(object, key, context, Runtime::kHasProperty));
     389          43 : }
     390             : 
     391         172 : TF_BUILTIN(InstanceOf, ObjectBuiltinsAssembler) {
     392             :   Node* object = Parameter(Descriptor::kLeft);
     393             :   Node* callable = Parameter(Descriptor::kRight);
     394             :   Node* context = Parameter(Descriptor::kContext);
     395             : 
     396          43 :   Return(InstanceOf(object, callable, context));
     397          43 : }
     398             : 
     399             : // ES6 section 7.3.19 OrdinaryHasInstance ( C, O )
     400         172 : TF_BUILTIN(OrdinaryHasInstance, ObjectBuiltinsAssembler) {
     401             :   Node* constructor = Parameter(Descriptor::kLeft);
     402             :   Node* object = Parameter(Descriptor::kRight);
     403             :   Node* context = Parameter(Descriptor::kContext);
     404             : 
     405          43 :   Return(OrdinaryHasInstance(context, constructor, object));
     406          43 : }
     407             : 
     408         172 : TF_BUILTIN(GetSuperConstructor, ObjectBuiltinsAssembler) {
     409             :   Node* object = Parameter(Descriptor::kObject);
     410             :   Node* context = Parameter(Descriptor::kContext);
     411             : 
     412          43 :   Return(GetSuperConstructor(object, context));
     413          43 : }
     414             : 
     415             : }  // namespace internal
     416             : }  // namespace v8

Generated by: LCOV version 1.10