1 // Copyright 2014 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/string-stream.h"
6
7 #include "src/handles-inl.h"
8 #include "src/prototype.h"
9
10 namespace v8 {
11 namespace internal {
12
13 static const int kMentionedObjectCacheMaxSize = 256;
14
allocate(unsigned bytes)15 char* HeapStringAllocator::allocate(unsigned bytes) {
16 space_ = NewArray<char>(bytes);
17 return space_;
18 }
19
20
allocate(unsigned bytes)21 char* FixedStringAllocator::allocate(unsigned bytes) {
22 CHECK_LE(bytes, length_);
23 return buffer_;
24 }
25
26
grow(unsigned * old)27 char* FixedStringAllocator::grow(unsigned* old) {
28 *old = length_;
29 return buffer_;
30 }
31
32
Put(char c)33 bool StringStream::Put(char c) {
34 if (full()) return false;
35 DCHECK(length_ < capacity_);
36 // Since the trailing '\0' is not accounted for in length_ fullness is
37 // indicated by a difference of 1 between length_ and capacity_. Thus when
38 // reaching a difference of 2 we need to grow the buffer.
39 if (length_ == capacity_ - 2) {
40 unsigned new_capacity = capacity_;
41 char* new_buffer = allocator_->grow(&new_capacity);
42 if (new_capacity > capacity_) {
43 capacity_ = new_capacity;
44 buffer_ = new_buffer;
45 } else {
46 // Reached the end of the available buffer.
47 DCHECK(capacity_ >= 5);
48 length_ = capacity_ - 1; // Indicate fullness of the stream.
49 buffer_[length_ - 4] = '.';
50 buffer_[length_ - 3] = '.';
51 buffer_[length_ - 2] = '.';
52 buffer_[length_ - 1] = '\n';
53 buffer_[length_] = '\0';
54 return false;
55 }
56 }
57 buffer_[length_] = c;
58 buffer_[length_ + 1] = '\0';
59 length_++;
60 return true;
61 }
62
63
64 // A control character is one that configures a format element. For
65 // instance, in %.5s, .5 are control characters.
IsControlChar(char c)66 static bool IsControlChar(char c) {
67 switch (c) {
68 case '0': case '1': case '2': case '3': case '4': case '5':
69 case '6': case '7': case '8': case '9': case '.': case '-':
70 return true;
71 default:
72 return false;
73 }
74 }
75
76
Add(Vector<const char> format,Vector<FmtElm> elms)77 void StringStream::Add(Vector<const char> format, Vector<FmtElm> elms) {
78 // If we already ran out of space then return immediately.
79 if (full()) return;
80 int offset = 0;
81 int elm = 0;
82 while (offset < format.length()) {
83 if (format[offset] != '%' || elm == elms.length()) {
84 Put(format[offset]);
85 offset++;
86 continue;
87 }
88 // Read this formatting directive into a temporary buffer
89 EmbeddedVector<char, 24> temp;
90 int format_length = 0;
91 // Skip over the whole control character sequence until the
92 // format element type
93 temp[format_length++] = format[offset++];
94 while (offset < format.length() && IsControlChar(format[offset]))
95 temp[format_length++] = format[offset++];
96 if (offset >= format.length())
97 return;
98 char type = format[offset];
99 temp[format_length++] = type;
100 temp[format_length] = '\0';
101 offset++;
102 FmtElm current = elms[elm++];
103 switch (type) {
104 case 's': {
105 DCHECK_EQ(FmtElm::C_STR, current.type_);
106 const char* value = current.data_.u_c_str_;
107 Add(value);
108 break;
109 }
110 case 'w': {
111 DCHECK_EQ(FmtElm::LC_STR, current.type_);
112 Vector<const uc16> value = *current.data_.u_lc_str_;
113 for (int i = 0; i < value.length(); i++)
114 Put(static_cast<char>(value[i]));
115 break;
116 }
117 case 'o': {
118 DCHECK_EQ(FmtElm::OBJ, current.type_);
119 Object* obj = current.data_.u_obj_;
120 PrintObject(obj);
121 break;
122 }
123 case 'k': {
124 DCHECK_EQ(FmtElm::INT, current.type_);
125 int value = current.data_.u_int_;
126 if (0x20 <= value && value <= 0x7F) {
127 Put(value);
128 } else if (value <= 0xff) {
129 Add("\\x%02x", value);
130 } else {
131 Add("\\u%04x", value);
132 }
133 break;
134 }
135 case 'i': case 'd': case 'u': case 'x': case 'c': case 'X': {
136 int value = current.data_.u_int_;
137 EmbeddedVector<char, 24> formatted;
138 int length = SNPrintF(formatted, temp.start(), value);
139 Add(Vector<const char>(formatted.start(), length));
140 break;
141 }
142 case 'f': case 'g': case 'G': case 'e': case 'E': {
143 double value = current.data_.u_double_;
144 int inf = std::isinf(value);
145 if (inf == -1) {
146 Add("-inf");
147 } else if (inf == 1) {
148 Add("inf");
149 } else if (std::isnan(value)) {
150 Add("nan");
151 } else {
152 EmbeddedVector<char, 28> formatted;
153 SNPrintF(formatted, temp.start(), value);
154 Add(formatted.start());
155 }
156 break;
157 }
158 case 'p': {
159 void* value = current.data_.u_pointer_;
160 EmbeddedVector<char, 20> formatted;
161 SNPrintF(formatted, temp.start(), value);
162 Add(formatted.start());
163 break;
164 }
165 default:
166 UNREACHABLE();
167 break;
168 }
169 }
170
171 // Verify that the buffer is 0-terminated
172 DCHECK(buffer_[length_] == '\0');
173 }
174
175
PrintObject(Object * o)176 void StringStream::PrintObject(Object* o) {
177 o->ShortPrint(this);
178 if (o->IsString()) {
179 if (String::cast(o)->length() <= String::kMaxShortPrintLength) {
180 return;
181 }
182 } else if (o->IsNumber() || o->IsOddball()) {
183 return;
184 }
185 if (o->IsHeapObject() && object_print_mode_ == kPrintObjectVerbose) {
186 HeapObject* ho = HeapObject::cast(o);
187 DebugObjectCache* debug_object_cache = ho->GetIsolate()->
188 string_stream_debug_object_cache();
189 for (int i = 0; i < debug_object_cache->length(); i++) {
190 if ((*debug_object_cache)[i] == o) {
191 Add("#%d#", i);
192 return;
193 }
194 }
195 if (debug_object_cache->length() < kMentionedObjectCacheMaxSize) {
196 Add("#%d#", debug_object_cache->length());
197 debug_object_cache->Add(HeapObject::cast(o));
198 } else {
199 Add("@%p", o);
200 }
201 }
202 }
203
204
Add(const char * format)205 void StringStream::Add(const char* format) {
206 Add(CStrVector(format));
207 }
208
209
Add(Vector<const char> format)210 void StringStream::Add(Vector<const char> format) {
211 Add(format, Vector<FmtElm>::empty());
212 }
213
214
Add(const char * format,FmtElm arg0)215 void StringStream::Add(const char* format, FmtElm arg0) {
216 const char argc = 1;
217 FmtElm argv[argc] = { arg0 };
218 Add(CStrVector(format), Vector<FmtElm>(argv, argc));
219 }
220
221
Add(const char * format,FmtElm arg0,FmtElm arg1)222 void StringStream::Add(const char* format, FmtElm arg0, FmtElm arg1) {
223 const char argc = 2;
224 FmtElm argv[argc] = { arg0, arg1 };
225 Add(CStrVector(format), Vector<FmtElm>(argv, argc));
226 }
227
228
Add(const char * format,FmtElm arg0,FmtElm arg1,FmtElm arg2)229 void StringStream::Add(const char* format, FmtElm arg0, FmtElm arg1,
230 FmtElm arg2) {
231 const char argc = 3;
232 FmtElm argv[argc] = { arg0, arg1, arg2 };
233 Add(CStrVector(format), Vector<FmtElm>(argv, argc));
234 }
235
236
Add(const char * format,FmtElm arg0,FmtElm arg1,FmtElm arg2,FmtElm arg3)237 void StringStream::Add(const char* format, FmtElm arg0, FmtElm arg1,
238 FmtElm arg2, FmtElm arg3) {
239 const char argc = 4;
240 FmtElm argv[argc] = { arg0, arg1, arg2, arg3 };
241 Add(CStrVector(format), Vector<FmtElm>(argv, argc));
242 }
243
244
Add(const char * format,FmtElm arg0,FmtElm arg1,FmtElm arg2,FmtElm arg3,FmtElm arg4)245 void StringStream::Add(const char* format, FmtElm arg0, FmtElm arg1,
246 FmtElm arg2, FmtElm arg3, FmtElm arg4) {
247 const char argc = 5;
248 FmtElm argv[argc] = { arg0, arg1, arg2, arg3, arg4 };
249 Add(CStrVector(format), Vector<FmtElm>(argv, argc));
250 }
251
252
ToCString() const253 base::SmartArrayPointer<const char> StringStream::ToCString() const {
254 char* str = NewArray<char>(length_ + 1);
255 MemCopy(str, buffer_, length_);
256 str[length_] = '\0';
257 return base::SmartArrayPointer<const char>(str);
258 }
259
260
Log(Isolate * isolate)261 void StringStream::Log(Isolate* isolate) {
262 LOG(isolate, StringEvent("StackDump", buffer_));
263 }
264
265
OutputToFile(FILE * out)266 void StringStream::OutputToFile(FILE* out) {
267 // Dump the output to stdout, but make sure to break it up into
268 // manageable chunks to avoid losing parts of the output in the OS
269 // printing code. This is a problem on Windows in particular; see
270 // the VPrint() function implementations in platform-win32.cc.
271 unsigned position = 0;
272 for (unsigned next; (next = position + 2048) < length_; position = next) {
273 char save = buffer_[next];
274 buffer_[next] = '\0';
275 internal::PrintF(out, "%s", &buffer_[position]);
276 buffer_[next] = save;
277 }
278 internal::PrintF(out, "%s", &buffer_[position]);
279 }
280
281
ToString(Isolate * isolate)282 Handle<String> StringStream::ToString(Isolate* isolate) {
283 return isolate->factory()->NewStringFromUtf8(
284 Vector<const char>(buffer_, length_)).ToHandleChecked();
285 }
286
287
ClearMentionedObjectCache(Isolate * isolate)288 void StringStream::ClearMentionedObjectCache(Isolate* isolate) {
289 isolate->set_string_stream_current_security_token(NULL);
290 if (isolate->string_stream_debug_object_cache() == NULL) {
291 isolate->set_string_stream_debug_object_cache(new DebugObjectCache(0));
292 }
293 isolate->string_stream_debug_object_cache()->Clear();
294 }
295
296
297 #ifdef DEBUG
IsMentionedObjectCacheClear(Isolate * isolate)298 bool StringStream::IsMentionedObjectCacheClear(Isolate* isolate) {
299 return object_print_mode_ == kPrintObjectConcise ||
300 isolate->string_stream_debug_object_cache()->length() == 0;
301 }
302 #endif
303
304
Put(String * str)305 bool StringStream::Put(String* str) {
306 return Put(str, 0, str->length());
307 }
308
309
Put(String * str,int start,int end)310 bool StringStream::Put(String* str, int start, int end) {
311 StringCharacterStream stream(str, start);
312 for (int i = start; i < end && stream.HasMore(); i++) {
313 uint16_t c = stream.GetNext();
314 if (c >= 127 || c < 32) {
315 c = '?';
316 }
317 if (!Put(static_cast<char>(c))) {
318 return false; // Output was truncated.
319 }
320 }
321 return true;
322 }
323
324
PrintName(Object * name)325 void StringStream::PrintName(Object* name) {
326 if (name->IsString()) {
327 String* str = String::cast(name);
328 if (str->length() > 0) {
329 Put(str);
330 } else {
331 Add("/* anonymous */");
332 }
333 } else {
334 Add("%o", name);
335 }
336 }
337
338
PrintUsingMap(JSObject * js_object)339 void StringStream::PrintUsingMap(JSObject* js_object) {
340 Map* map = js_object->map();
341 if (!js_object->GetHeap()->Contains(map) ||
342 !map->IsHeapObject() ||
343 !map->IsMap()) {
344 Add("<Invalid map>\n");
345 return;
346 }
347 int real_size = map->NumberOfOwnDescriptors();
348 DescriptorArray* descs = map->instance_descriptors();
349 for (int i = 0; i < real_size; i++) {
350 PropertyDetails details = descs->GetDetails(i);
351 if (details.type() == DATA) {
352 Object* key = descs->GetKey(i);
353 if (key->IsString() || key->IsNumber()) {
354 int len = 3;
355 if (key->IsString()) {
356 len = String::cast(key)->length();
357 }
358 for (; len < 18; len++)
359 Put(' ');
360 if (key->IsString()) {
361 Put(String::cast(key));
362 } else {
363 key->ShortPrint();
364 }
365 Add(": ");
366 FieldIndex index = FieldIndex::ForDescriptor(map, i);
367 if (js_object->IsUnboxedDoubleField(index)) {
368 double value = js_object->RawFastDoublePropertyAt(index);
369 Add("<unboxed double> %.16g\n", FmtElm(value));
370 } else {
371 Object* value = js_object->RawFastPropertyAt(index);
372 Add("%o\n", value);
373 }
374 }
375 }
376 }
377 }
378
379
PrintFixedArray(FixedArray * array,unsigned int limit)380 void StringStream::PrintFixedArray(FixedArray* array, unsigned int limit) {
381 Heap* heap = array->GetHeap();
382 for (unsigned int i = 0; i < 10 && i < limit; i++) {
383 Object* element = array->get(i);
384 if (element != heap->the_hole_value()) {
385 for (int len = 1; len < 18; len++)
386 Put(' ');
387 Add("%d: %o\n", i, array->get(i));
388 }
389 }
390 if (limit >= 10) {
391 Add(" ...\n");
392 }
393 }
394
395
PrintByteArray(ByteArray * byte_array)396 void StringStream::PrintByteArray(ByteArray* byte_array) {
397 unsigned int limit = byte_array->length();
398 for (unsigned int i = 0; i < 10 && i < limit; i++) {
399 byte b = byte_array->get(i);
400 Add(" %d: %3d 0x%02x", i, b, b);
401 if (b >= ' ' && b <= '~') {
402 Add(" '%c'", b);
403 } else if (b == '\n') {
404 Add(" '\n'");
405 } else if (b == '\r') {
406 Add(" '\r'");
407 } else if (b >= 1 && b <= 26) {
408 Add(" ^%c", b + 'A' - 1);
409 }
410 Add("\n");
411 }
412 if (limit >= 10) {
413 Add(" ...\n");
414 }
415 }
416
417
PrintMentionedObjectCache(Isolate * isolate)418 void StringStream::PrintMentionedObjectCache(Isolate* isolate) {
419 if (object_print_mode_ == kPrintObjectConcise) return;
420 DebugObjectCache* debug_object_cache =
421 isolate->string_stream_debug_object_cache();
422 Add("==== Key ============================================\n\n");
423 for (int i = 0; i < debug_object_cache->length(); i++) {
424 HeapObject* printee = (*debug_object_cache)[i];
425 Add(" #%d# %p: ", i, printee);
426 printee->ShortPrint(this);
427 Add("\n");
428 if (printee->IsJSObject()) {
429 if (printee->IsJSValue()) {
430 Add(" value(): %o\n", JSValue::cast(printee)->value());
431 }
432 PrintUsingMap(JSObject::cast(printee));
433 if (printee->IsJSArray()) {
434 JSArray* array = JSArray::cast(printee);
435 if (array->HasFastObjectElements()) {
436 unsigned int limit = FixedArray::cast(array->elements())->length();
437 unsigned int length =
438 static_cast<uint32_t>(JSArray::cast(array)->length()->Number());
439 if (length < limit) limit = length;
440 PrintFixedArray(FixedArray::cast(array->elements()), limit);
441 }
442 }
443 } else if (printee->IsByteArray()) {
444 PrintByteArray(ByteArray::cast(printee));
445 } else if (printee->IsFixedArray()) {
446 unsigned int limit = FixedArray::cast(printee)->length();
447 PrintFixedArray(FixedArray::cast(printee), limit);
448 }
449 }
450 }
451
452
PrintSecurityTokenIfChanged(Object * f)453 void StringStream::PrintSecurityTokenIfChanged(Object* f) {
454 if (!f->IsHeapObject()) return;
455 HeapObject* obj = HeapObject::cast(f);
456 Isolate* isolate = obj->GetIsolate();
457 Heap* heap = isolate->heap();
458 if (!heap->Contains(obj)) return;
459 Map* map = obj->map();
460 if (!map->IsHeapObject() ||
461 !heap->Contains(map) ||
462 !map->IsMap() ||
463 !f->IsJSFunction()) {
464 return;
465 }
466
467 JSFunction* fun = JSFunction::cast(f);
468 Object* perhaps_context = fun->context();
469 if (perhaps_context->IsHeapObject() &&
470 heap->Contains(HeapObject::cast(perhaps_context)) &&
471 perhaps_context->IsContext()) {
472 Context* context = fun->context();
473 if (!heap->Contains(context)) {
474 Add("(Function context is outside heap)\n");
475 return;
476 }
477 Object* token = context->native_context()->security_token();
478 if (token != isolate->string_stream_current_security_token()) {
479 Add("Security context: %o\n", token);
480 isolate->set_string_stream_current_security_token(token);
481 }
482 } else {
483 Add("(Function context is corrupt)\n");
484 }
485 }
486
487
PrintFunction(Object * f,Object * receiver,Code ** code)488 void StringStream::PrintFunction(Object* f, Object* receiver, Code** code) {
489 if (!f->IsHeapObject()) {
490 Add("/* warning: 'function' was not a heap object */ ");
491 return;
492 }
493 Heap* heap = HeapObject::cast(f)->GetHeap();
494 if (!heap->Contains(HeapObject::cast(f))) {
495 Add("/* warning: 'function' was not on the heap */ ");
496 return;
497 }
498 if (!heap->Contains(HeapObject::cast(f)->map())) {
499 Add("/* warning: function's map was not on the heap */ ");
500 return;
501 }
502 if (!HeapObject::cast(f)->map()->IsMap()) {
503 Add("/* warning: function's map was not a valid map */ ");
504 return;
505 }
506 if (f->IsJSFunction()) {
507 JSFunction* fun = JSFunction::cast(f);
508 // Common case: on-stack function present and resolved.
509 PrintPrototype(fun, receiver);
510 *code = fun->code();
511 } else if (f->IsInternalizedString()) {
512 // Unresolved and megamorphic calls: Instead of the function
513 // we have the function name on the stack.
514 PrintName(f);
515 Add("/* unresolved */ ");
516 } else {
517 // Unless this is the frame of a built-in function, we should always have
518 // the callee function or name on the stack. If we don't, we have a
519 // problem or a change of the stack frame layout.
520 Add("%o", f);
521 Add("/* warning: no JSFunction object or function name found */ ");
522 }
523 }
524
525
PrintPrototype(JSFunction * fun,Object * receiver)526 void StringStream::PrintPrototype(JSFunction* fun, Object* receiver) {
527 Object* name = fun->shared()->name();
528 bool print_name = false;
529 Isolate* isolate = fun->GetIsolate();
530 for (PrototypeIterator iter(isolate, receiver,
531 PrototypeIterator::START_AT_RECEIVER);
532 !iter.IsAtEnd(); iter.Advance()) {
533 if (iter.GetCurrent()->IsJSObject()) {
534 Object* key = iter.GetCurrent<JSObject>()->SlowReverseLookup(fun);
535 if (key != isolate->heap()->undefined_value()) {
536 if (!name->IsString() ||
537 !key->IsString() ||
538 !String::cast(name)->Equals(String::cast(key))) {
539 print_name = true;
540 }
541 if (name->IsString() && String::cast(name)->length() == 0) {
542 print_name = false;
543 }
544 name = key;
545 }
546 } else {
547 print_name = true;
548 }
549 }
550 PrintName(name);
551 // Also known as - if the name in the function doesn't match the name under
552 // which it was looked up.
553 if (print_name) {
554 Add("(aka ");
555 PrintName(fun->shared()->name());
556 Put(')');
557 }
558 }
559
560
grow(unsigned * bytes)561 char* HeapStringAllocator::grow(unsigned* bytes) {
562 unsigned new_bytes = *bytes * 2;
563 // Check for overflow.
564 if (new_bytes <= *bytes) {
565 return space_;
566 }
567 char* new_space = NewArray<char>(new_bytes);
568 if (new_space == NULL) {
569 return space_;
570 }
571 MemCopy(new_space, space_, *bytes);
572 *bytes = new_bytes;
573 DeleteArray(space_);
574 space_ = new_space;
575 return new_space;
576 }
577
578
579 } // namespace internal
580 } // namespace v8
581