Line data    Source code

       1             : // Copyright 2015 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/profiler/strings-storage.h"
       6             : 
       7             : #include <memory>
       8             : 
       9             : #include "src/allocation.h"
      10             : #include "src/objects-inl.h"
      11             : 
      12             : namespace v8 {
      13             : namespace internal {
      14             : 
      15     4399259 : bool StringsStorage::StringsMatch(void* key1, void* key2) {
      16     4399259 :   return strcmp(reinterpret_cast<char*>(key1), reinterpret_cast<char*>(key2)) ==
      17     4399259 :          0;
      18             : }
      19             : 
      20      128790 : StringsStorage::StringsStorage() : names_(StringsMatch) {}
      21             : 
      22      128752 : StringsStorage::~StringsStorage() {
      23     5943536 :   for (base::HashMap::Entry* p = names_.Start(); p != nullptr;
      24             :        p = names_.Next(p)) {
      25     2939580 :     DeleteArray(reinterpret_cast<const char*>(p->value));
      26             :   }
      27       64376 : }
      28             : 
      29       26339 : const char* StringsStorage::GetCopy(const char* src) {
      30       26339 :   int len = static_cast<int>(strlen(src));
      31       26339 :   base::HashMap::Entry* entry = GetEntry(src, len);
      32       26339 :   if (entry->value == nullptr) {
      33       52550 :     Vector<char> dst = Vector<char>::New(len + 1);
      34       26275 :     StrNCpy(dst, src, len);
      35       26275 :     dst[len] = '\0';
      36       26275 :     entry->key = dst.start();
      37       26275 :     entry->value = entry->key;
      38             :   }
      39       26339 :   return reinterpret_cast<const char*>(entry->value);
      40             : }
      41             : 
      42     3684341 : const char* StringsStorage::GetFormatted(const char* format, ...) {
      43             :   va_list args;
      44     3684341 :   va_start(args, format);
      45     3684341 :   const char* result = GetVFormatted(format, args);
      46     3684341 :   va_end(args);
      47     3684341 :   return result;
      48             : }
      49             : 
      50     7303999 : const char* StringsStorage::AddOrDisposeString(char* str, int len) {
      51     7303999 :   base::HashMap::Entry* entry = GetEntry(str, len);
      52     7303999 :   if (entry->value == nullptr) {
      53             :     // New entry added.
      54     2913305 :     entry->key = str;
      55     2913305 :     entry->value = str;
      56             :   } else {
      57             :     DeleteArray(str);
      58             :   }
      59     7303999 :   return reinterpret_cast<const char*>(entry->value);
      60             : }
      61             : 
      62     3684341 : const char* StringsStorage::GetVFormatted(const char* format, va_list args) {
      63     3684341 :   Vector<char> str = Vector<char>::New(1024);
      64     3684341 :   int len = VSNPrintF(str, format, args);
      65     3684341 :   if (len == -1) {
      66             :     DeleteArray(str.start());
      67           0 :     return GetCopy(format);
      68             :   }
      69     3684341 :   return AddOrDisposeString(str.start(), len);
      70             : }
      71             : 
      72     3631240 : const char* StringsStorage::GetName(Name name) {
      73     3631240 :   if (name->IsString()) {
      74     3602976 :     String str = String::cast(name);
      75     3602976 :     int length = Min(FLAG_heap_snapshot_string_limit, str->length());
      76     3602976 :     int actual_length = 0;
      77             :     std::unique_ptr<char[]> data = str->ToCString(
      78     3602976 :         DISALLOW_NULLS, ROBUST_STRING_TRAVERSAL, 0, length, &actual_length);
      79     7205952 :     return AddOrDisposeString(data.release(), actual_length);
      80       28264 :   } else if (name->IsSymbol()) {
      81             :     return "<symbol>";
      82             :   }
      83           0 :   return "";
      84             : }
      85             : 
      86     1849910 : const char* StringsStorage::GetName(int index) {
      87     1849910 :   return GetFormatted("%d", index);
      88             : }
      89             : 
      90       18228 : const char* StringsStorage::GetConsName(const char* prefix, Name name) {
      91       18228 :   if (name->IsString()) {
      92       16682 :     String str = String::cast(name);
      93       16682 :     int length = Min(FLAG_heap_snapshot_string_limit, str->length());
      94       16682 :     int actual_length = 0;
      95             :     std::unique_ptr<char[]> data = str->ToCString(
      96       16682 :         DISALLOW_NULLS, ROBUST_STRING_TRAVERSAL, 0, length, &actual_length);
      97             : 
      98       16682 :     int cons_length = actual_length + static_cast<int>(strlen(prefix)) + 1;
      99       16682 :     char* cons_result = NewArray<char>(cons_length);
     100             :     snprintf(cons_result, cons_length, "%s%s", prefix, data.get());
     101             : 
     102       16682 :     return AddOrDisposeString(cons_result, cons_length);
     103        1546 :   } else if (name->IsSymbol()) {
     104             :     return "<symbol>";
     105             :   }
     106           0 :   return "";
     107             : }
     108             : 
     109     7330338 : base::HashMap::Entry* StringsStorage::GetEntry(const char* str, int len) {
     110     7330338 :   uint32_t hash = StringHasher::HashSequentialString(str, len, kZeroHashSeed);
     111    14660676 :   return names_.LookupOrInsert(const_cast<char*>(str), hash);
     112             : }
     113             : 
     114             : }  // namespace internal
     115      122036 : }  // namespace v8