compilation-cache-inl.h 3.17 KB
Newer Older
1 2 3 4 5 6 7 8 9
// Copyright 2017 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef V8_OBJECTS_COMPILATION_CACHE_INL_H_
#define V8_OBJECTS_COMPILATION_CACHE_INL_H_

#include "src/objects/compilation-cache.h"

10 11 12
#include "src/objects/name-inl.h"
#include "src/objects/script-inl.h"
#include "src/objects/shared-function-info.h"
13
#include "src/objects/smi.h"
14 15
#include "src/objects/string.h"

16 17 18 19 20 21
// Has to be the last include (doesn't have include guards):
#include "src/objects/object-macros.h"

namespace v8 {
namespace internal {

22 23 24 25 26 27
CompilationCacheTable::CompilationCacheTable(Address ptr)
    : HashTable<CompilationCacheTable, CompilationCacheShape>(ptr) {
  SLOW_DCHECK(IsCompilationCacheTable());
}

NEVER_READ_ONLY_SPACE_IMPL(CompilationCacheTable)
28
CAST_ACCESSOR(CompilationCacheTable)
29

30
uint32_t CompilationCacheShape::RegExpHash(String string, Smi flags) {
31 32 33
  return string->Hash() + flags->value();
}

34
uint32_t CompilationCacheShape::StringSharedHash(String source,
35
                                                 SharedFunctionInfo shared,
36 37 38 39 40 41 42 43 44
                                                 LanguageMode language_mode,
                                                 int position) {
  uint32_t hash = source->Hash();
  if (shared->HasSourceCode()) {
    // Instead of using the SharedFunctionInfo pointer in the hash
    // code computation, we use a combination of the hash of the
    // script source code and the start position of the calling scope.
    // We do this to ensure that the cache entries can survive garbage
    // collection.
45
    Script script(Script::cast(shared->script()));
46
    hash ^= String::cast(script->source())->Hash();
47
    STATIC_ASSERT(LanguageModeSize == 2);
48 49 50 51 52 53
    if (is_strict(language_mode)) hash ^= 0x8000;
    hash += position;
  }
  return hash;
}

54 55
uint32_t CompilationCacheShape::HashForObject(ReadOnlyRoots roots,
                                              Object object) {
56 57
  if (object->IsNumber()) return static_cast<uint32_t>(object->Number());

58
  FixedArray val = FixedArray::cast(object);
59
  if (val->map() == roots.fixed_cow_array_map()) {
60
    DCHECK_EQ(4, val->length());
61
    SharedFunctionInfo shared = SharedFunctionInfo::cast(val->get(0));
62
    String source = String::cast(val->get(1));
jgruber's avatar
jgruber committed
63
    int language_unchecked = Smi::ToInt(val->get(2));
64 65
    DCHECK(is_valid_language_mode(language_unchecked));
    LanguageMode language_mode = static_cast<LanguageMode>(language_unchecked);
jgruber's avatar
jgruber committed
66
    int position = Smi::ToInt(val->get(3));
67 68 69 70 71 72 73
    return StringSharedHash(source, shared, language_mode, position);
  }
  DCHECK_LT(2, val->length());
  return RegExpHash(String::cast(val->get(JSRegExp::kSourceIndex)),
                    Smi::cast(val->get(JSRegExp::kFlagsIndex)));
}

74
InfoCellPair::InfoCellPair(SharedFunctionInfo shared,
75
                           FeedbackCell feedback_cell)
76 77 78 79 80
    : is_compiled_scope_(!shared.is_null() ? shared->is_compiled_scope()
                                           : IsCompiledScope()),
      shared_(shared),
      feedback_cell_(feedback_cell) {}

81 82 83 84 85 86
}  // namespace internal
}  // namespace v8

#include "src/objects/object-macros-undef.h"

#endif  // V8_OBJECTS_COMPILATION_CACHE_INL_H_