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/ast/compile-time-value.h"
       6             : 
       7             : #include "src/ast/ast.h"
       8             : #include "src/factory.h"
       9             : #include "src/handles-inl.h"
      10             : #include "src/isolate.h"
      11             : #include "src/objects-inl.h"
      12             : 
      13             : namespace v8 {
      14             : namespace internal {
      15             : 
      16    19163085 : bool CompileTimeValue::IsCompileTimeValue(Expression* expression) {
      17    38326170 :   if (expression->IsLiteral()) return true;
      18     1685909 :   MaterializedLiteral* literal = expression->AsMaterializedLiteral();
      19     1685909 :   if (literal == nullptr) return false;
      20      216549 :   return literal->IsSimple();
      21             : }
      22             : 
      23       41259 : Handle<FixedArray> CompileTimeValue::GetValue(Isolate* isolate,
      24             :                                               Expression* expression) {
      25             :   Factory* factory = isolate->factory();
      26             :   DCHECK(IsCompileTimeValue(expression));
      27       41259 :   Handle<FixedArray> result = factory->NewFixedArray(2, TENURED);
      28       41259 :   if (expression->IsObjectLiteral()) {
      29       25439 :     ObjectLiteral* object_literal = expression->AsObjectLiteral();
      30             :     DCHECK(object_literal->is_simple());
      31             :     int literalTypeFlag = object_literal->EncodeLiteralType();
      32             :     DCHECK_NE(kArrayLiteralFlag, literalTypeFlag);
      33             :     result->set(kLiteralTypeSlot, Smi::FromInt(literalTypeFlag));
      34       25439 :     result->set(kElementsSlot, *object_literal->constant_properties());
      35             :   } else {
      36       15820 :     ArrayLiteral* array_literal = expression->AsArrayLiteral();
      37             :     DCHECK(array_literal->is_simple());
      38             :     result->set(kLiteralTypeSlot, Smi::FromInt(kArrayLiteralFlag));
      39       15820 :     result->set(kElementsSlot, *array_literal->constant_elements());
      40             :   }
      41       41259 :   return result;
      42             : }
      43             : 
      44       61744 : int CompileTimeValue::GetLiteralTypeFlags(Handle<FixedArray> value) {
      45       61744 :   return Smi::ToInt(value->get(kLiteralTypeSlot));
      46             : }
      47             : 
      48       61744 : Handle<HeapObject> CompileTimeValue::GetElements(Handle<FixedArray> value) {
      49       61744 :   return Handle<HeapObject>(HeapObject::cast(value->get(kElementsSlot)));
      50             : }
      51             : 
      52             : }  // namespace internal
      53             : }  // namespace v8