Line data    Source code

       1             : // Copyright 2010 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/parsing/preparse-data.h"
       6             : #include "src/base/hashmap.h"
       7             : #include "src/base/logging.h"
       8             : #include "src/globals.h"
       9             : #include "src/objects-inl.h"
      10             : #include "src/parsing/parser.h"
      11             : #include "src/parsing/preparse-data-format.h"
      12             : 
      13             : namespace v8 {
      14             : namespace internal {
      15             : 
      16         170 : void ParserLogger::LogFunction(int start, int end, int num_parameters,
      17             :                                LanguageMode language_mode,
      18             :                                bool uses_super_property,
      19             :                                int num_inner_functions) {
      20         170 :   function_store_.Add(start);
      21         170 :   function_store_.Add(end);
      22         170 :   function_store_.Add(num_parameters);
      23             :   function_store_.Add(
      24         170 :       FunctionEntry::EncodeFlags(language_mode, uses_super_property));
      25         170 :   function_store_.Add(num_inner_functions);
      26         170 : }
      27             : 
      28     1678483 : ParserLogger::ParserLogger() {
      29             :   preamble_[PreparseDataConstants::kMagicOffset] =
      30             :       PreparseDataConstants::kMagicNumber;
      31             :   preamble_[PreparseDataConstants::kVersionOffset] =
      32     1678483 :       PreparseDataConstants::kCurrentVersion;
      33     1678483 :   preamble_[PreparseDataConstants::kFunctionsSizeOffset] = 0;
      34     1678483 :   preamble_[PreparseDataConstants::kSizeOffset] = 0;
      35             :   DCHECK_EQ(4, PreparseDataConstants::kHeaderSize);
      36             : #ifdef DEBUG
      37             :   prev_start_ = -1;
      38             : #endif
      39     1678483 : }
      40             : 
      41         120 : ScriptData* ParserLogger::GetScriptData() {
      42         120 :   int function_size = function_store_.size();
      43         120 :   int total_size = PreparseDataConstants::kHeaderSize + function_size;
      44         120 :   unsigned* data = NewArray<unsigned>(total_size);
      45         120 :   preamble_[PreparseDataConstants::kFunctionsSizeOffset] = function_size;
      46         120 :   MemCopy(data, preamble_, sizeof(preamble_));
      47         120 :   if (function_size > 0) {
      48             :     function_store_.WriteTo(Vector<unsigned>(
      49         200 :         data + PreparseDataConstants::kHeaderSize, function_size));
      50             :   }
      51             :   DCHECK(IsAligned(reinterpret_cast<intptr_t>(data), kPointerAlignment));
      52             :   ScriptData* result = new ScriptData(reinterpret_cast<byte*>(data),
      53         120 :                                       total_size * sizeof(unsigned));
      54             :   result->AcquireDataOwnership();
      55         120 :   return result;
      56             : }
      57             : 
      58           0 : PreParseData::FunctionData PreParseData::GetFunctionData(int start) const {
      59             :   auto it = functions_.find(start);
      60           0 :   if (it != functions_.end()) {
      61           0 :     return it->second;
      62             :   }
      63           0 :   return FunctionData();
      64             : }
      65             : 
      66           0 : void PreParseData::AddFunctionData(int start, FunctionData&& data) {
      67             :   DCHECK(data.is_valid());
      68           0 :   functions_[start] = std::move(data);
      69           0 : }
      70             : 
      71           0 : void PreParseData::AddFunctionData(int start, const FunctionData& data) {
      72             :   DCHECK(data.is_valid());
      73           0 :   functions_[start] = data;
      74           0 : }
      75             : 
      76           0 : size_t PreParseData::size() const { return functions_.size(); }
      77             : 
      78           0 : PreParseData::const_iterator PreParseData::begin() const {
      79           0 :   return functions_.begin();
      80             : }
      81             : 
      82           0 : PreParseData::const_iterator PreParseData::end() const {
      83           0 :   return functions_.end();
      84             : }
      85             : 
      86             : }  // namespace internal
      87             : }  // namespace v8.