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