[sanitizer] Remove max_len parameter from InternalScopedString

[vitalybuka]

Summary

InternalScopedString uses InternalMmapVector internally
so it can be resized dynamically as needed.

[eugenis]

Nice.
LGTM.

compiler-rt/lib/sanitizer_common/sanitizer_common.cpp

90

kMaxSummaryLength is now unused, and maybe some of the other named constants, too.

[vitalybuka]

removed unused constant

compiler-rt/lib/asan/asan_descriptions.cpp

 void DescribeThread(AsanThreadContext *context) {
   CHECK(context);
   asanThreadRegistry().CheckLocked();
   // No need to announce the main thread.
   if (context->tid == 0 || context->announced) {
     return;
   }
   context->announced = true;
-  InternalScopedString str(1024);
+  InternalScopedString str;
   str.append("Thread %s", AsanThreadIdAndName(context).c_str());
   if (context->parent_tid == kInvalidTid) {
     str.append(" created by unknown thread\n");
     Printf("%s", str.data());
     return;
   }
   str.append(" created by %s here:\n",
              AsanThreadIdAndName(context->parent_tid).c_str());
static void GetAccessToHeapChunkInformation(ChunkAccess *descr,
   descr->chunk_begin = chunk.Beg();
   descr->chunk_size = chunk.UsedSize();
   descr->user_requested_alignment = chunk.UserRequestedAlignment();
   descr->alloc_type = chunk.GetAllocType();
 }
 
 static void PrintHeapChunkAccess(uptr addr, const ChunkAccess &descr) {
   Decorator d;
-  InternalScopedString str(4096);
+  InternalScopedString str;
   str.append("%s", d.Location());
   switch (descr.access_type) {
     case kAccessTypeLeft:
       str.append("%p is located %zd bytes to the left of",
                  (void *)descr.bad_addr, descr.offset);
       break;
     case kAccessTypeRight:
       str.append("%p is located %zd bytes to the right of",
else if (addr_end <= next_var_beg &&
              next_var_beg - addr_end >= addr - var_end)
       pos_descr = "overflows";
   } else {
     if (addr_end > var.beg)
       pos_descr = "partially underflows";
     else if (addr >= prev_var_end && addr - prev_var_end >= var.beg - addr_end)
       pos_descr = "underflows";
   }
-  InternalScopedString str(1024);
+  InternalScopedString str;
   str.append("    [%zd, %zd)", var.beg, var_end);
   // Render variable name.
   str.append(" '");
   for (uptr i = 0; i < var.name_len; ++i) {
     str.append("%c", var.name_pos[i]);
   }
   str.append("'");
   if (var.line > 0) {
bool DescribeAddressIfStack(uptr addr, uptr access_size) {
   if (!GetStackAddressInformation(addr, access_size, &descr)) return false;
   descr.Print();
   return true;
 }
 
 // Global descriptions
 static void DescribeAddressRelativeToGlobal(uptr addr, uptr access_size,
                                             const __asan_global &g) {
-  InternalScopedString str(4096);
+  InternalScopedString str;
   Decorator d;
   str.append("%s", d.Location());
   if (addr < g.beg) {
     str.append("%p is located %zd bytes to the left", (void *)addr,
                g.beg - addr);
   } else if (addr + access_size > g.beg + g.size) {
     if (addr < g.beg + g.size) addr = g.beg + g.size;
     str.append("%p is located %zd bytes to the right", (void *)addr,

compiler-rt/lib/asan/asan_errors.cpp

 }
 
 void ErrorODRViolation::Print() {
   Decorator d;
   Printf("%s", d.Error());
   Report("ERROR: AddressSanitizer: %s (%p):\n", scariness.GetDescription(),
          global1.beg);
   Printf("%s", d.Default());
-  InternalScopedString g1_loc(256), g2_loc(256);
+  InternalScopedString g1_loc;
+  InternalScopedString g2_loc;
   PrintGlobalLocation(&g1_loc, global1);
   PrintGlobalLocation(&g2_loc, global2);
   Printf("  [1] size=%zd '%s' %s\n", global1.size,
          MaybeDemangleGlobalName(global1.name), g1_loc.data());
   Printf("  [2] size=%zd '%s' %s\n", global2.size,
          MaybeDemangleGlobalName(global2.name), g2_loc.data());
   if (stack_id1 && stack_id2) {
     Printf("These globals were registered at these points:\n");
     Printf("  [1]:\n");
     StackDepotGet(stack_id1).Print();
     Printf("  [2]:\n");
     StackDepotGet(stack_id2).Print();
   }
   Report(
       "HINT: if you don't care about these errors you may set "
       "ASAN_OPTIONS=detect_odr_violation=0\n");
-  InternalScopedString error_msg(256);
+  InternalScopedString error_msg;
   error_msg.append("%s: global '%s' at %s", scariness.GetDescription(),
                    MaybeDemangleGlobalName(global1.name), g1_loc.data());
   ReportErrorSummary(error_msg.data());
 }
 
 void ErrorInvalidPointerPair::Print() {
   Decorator d;
   Printf("%s", d.Error());
static void PrintShadowBytes(InternalScopedString *str, const char *before,
   str->append("\n");
 }
 
 static void PrintShadowMemoryForAddress(uptr addr) {
   if (!AddrIsInMem(addr)) return;
   uptr shadow_addr = MemToShadow(addr);
   const uptr n_bytes_per_row = 16;
   uptr aligned_shadow = shadow_addr & ~(n_bytes_per_row - 1);
-  InternalScopedString str(4096 * 8);
+  InternalScopedString str;
   str.append("Shadow bytes around the buggy address:\n");
   for (int i = -5; i <= 5; i++) {
     uptr row_shadow_addr = aligned_shadow + i * n_bytes_per_row;
     // Skip rows that would be outside the shadow range. This can happen when
     // the user address is near the bottom, top, or shadow gap of the address
     // space.
     if (!AddrIsInShadow(row_shadow_addr)) continue;
     const char *prefix = (i == 0) ? "=>" : "  ";

compiler-rt/lib/asan/asan_fake_stack.cpp

VReport(1, "T%d: FakeStack created: %p -- %p stack_size_log: %zd; "
           p + FakeStack::RequiredSize(stack_size_log), stack_size_log,
           size >> 10, flags()->uar_noreserve);
   return res;
 }
 
 void FakeStack::Destroy(int tid) {
   PoisonAll(0);
   if (Verbosity() >= 2) {
-    InternalScopedString str(kNumberOfSizeClasses * 50);
+    InternalScopedString str;
     for (uptr class_id = 0; class_id < kNumberOfSizeClasses; class_id++)
       str.append("%zd: %zd/%zd; ", class_id, hint_position_[class_id],
                  NumberOfFrames(stack_size_log(), class_id));
     Report("T%d: FakeStack destroyed: %s\n", tid, str.data());
   }
   uptr size = RequiredSize(stack_size_log_);
   FlushUnneededASanShadowMemory(reinterpret_cast<uptr>(this), size);
   UnmapOrDie(this, size);

compiler-rt/lib/hwasan/hwasan.cpp

DecorateMapping((uptr)memory_usage_buffer, kMemoryUsageBufferSize,
                   memory_usage_buffer);
 }
 
 void UpdateMemoryUsage() {
   if (!flags()->export_memory_stats)
     return;
   if (!memory_usage_buffer)
     InitMemoryUsage();
-  InternalScopedString s(kMemoryUsageBufferSize);
+  InternalScopedString s;
   HwasanFormatMemoryUsage(s);
   internal_strncpy(memory_usage_buffer, s.data(), kMemoryUsageBufferSize - 1);
   memory_usage_buffer[kMemoryUsageBufferSize - 1] = '\0';
 }
 #else
 void UpdateMemoryUsage() {}
 #endif
 

 }
 
 extern "C" void *__hwasan_extra_spill_area() {
   Thread *t = GetCurrentThread();
   return &t->vfork_spill();
 }
 
 void __hwasan_print_memory_usage() {
-  InternalScopedString s(kMemoryUsageBufferSize);
+  InternalScopedString s;
   HwasanFormatMemoryUsage(s);
   Printf("%s\n", s.data());
 }
 
 static const u8 kFallbackTag = 0xBB;
 
 u8 __hwasan_generate_tag() {
   Thread *t = GetCurrentThread();

compiler-rt/lib/hwasan/hwasan_report.cpp

for (uptr i = 0; i < frames; i++) {
     }
   }
 
   if (found_local)
     return;
 
   // We didn't find any locals. Most likely we don't have symbols, so dump
   // the information that we have for offline analysis.
-  InternalScopedString frame_desc(GetPageSizeCached() * 2);
+  InternalScopedString frame_desc;
   Printf("Previously allocated frames:\n");
   for (uptr i = 0; i < frames; i++) {
     const uptr *record_addr = &(*sa)[i];
     uptr record = *record_addr;
     if (!record)
       break;
     uptr pc_mask = (1ULL << 48) - 1;
     uptr pc = record & pc_mask;

 static void PrintTagInfoAroundAddr(tag_t *tag_ptr, uptr num_rows,
                                    void (*print_tag)(InternalScopedString &s,
                                                      tag_t *tag)) {
   const uptr row_len = 16;  // better be power of two.
   tag_t *center_row_beg = reinterpret_cast<tag_t *>(
       RoundDownTo(reinterpret_cast<uptr>(tag_ptr), row_len));
   tag_t *beg_row = center_row_beg - row_len * (num_rows / 2);
   tag_t *end_row = center_row_beg + row_len * ((num_rows + 1) / 2);
-  InternalScopedString s(GetPageSizeCached() * 8);
+  InternalScopedString s;
   for (tag_t *row = beg_row; row < end_row; row += row_len) {
     s.append("%s", row == center_row_beg ? "=>" : "  ");
     s.append("%p:", row);
     for (uptr i = 0; i < row_len; i++) {
       s.append("%s", row + i == tag_ptr ? "[" : " ");
       print_tag(s, &row[i]);
       s.append("%s", row + i == tag_ptr ? "]" : " ");
     }
void ReportTailOverwritten(StackTrace *stack, uptr tagged_addr, uptr orig_size,
   HwasanChunkView chunk = FindHeapChunkByAddress(untagged_addr);
   if (chunk.Beg()) {
     Printf("%s", d.Allocation());
     Printf("allocated here:\n");
     Printf("%s", d.Default());
     GetStackTraceFromId(chunk.GetAllocStackId()).Print();
   }
 
-  InternalScopedString s(GetPageSizeCached() * 8);
+  InternalScopedString s;
   CHECK_GT(tail_size, 0U);
   CHECK_LT(tail_size, kShadowAlignment);
   u8 *tail = reinterpret_cast<u8*>(untagged_addr + orig_size);
   s.append("Tail contains: ");
   for (uptr i = 0; i < kShadowAlignment - tail_size; i++)
     s.append(".. ");
   for (uptr i = 0; i < tail_size; i++)
     s.append("%02x ", tail[i]);

compiler-rt/lib/lsan/lsan_common.cpp

 void LeakReport::PrintSummary() {
   CHECK(leaks_.size() <= kMaxLeaksConsidered);
   uptr bytes = 0, allocations = 0;
   for (uptr i = 0; i < leaks_.size(); i++) {
       if (leaks_[i].is_suppressed) continue;
       bytes += leaks_[i].total_size;
       allocations += leaks_[i].hit_count;
   }
-  InternalScopedString summary(kMaxSummaryLength);
+  InternalScopedString summary;
   summary.append("%zu byte(s) leaked in %zu allocation(s).", bytes,
                  allocations);
   ReportErrorSummary(summary.data());
 }
 
 uptr LeakReport::ApplySuppressions() {
   LeakSuppressionContext *suppressions = GetSuppressionContext();
   uptr new_suppressions = false;

compiler-rt/lib/memprof/memprof_descriptions.cpp

 void DescribeThread(MemprofThreadContext *context) {
   CHECK(context);
   memprofThreadRegistry().CheckLocked();
   // No need to announce the main thread.
   if (context->tid == 0 || context->announced) {
     return;
   }
   context->announced = true;
-  InternalScopedString str(1024);
+  InternalScopedString str;
   str.append("Thread %s", MemprofThreadIdAndName(context).c_str());
   if (context->parent_tid == kInvalidTid) {
     str.append(" created by unknown thread\n");
     Printf("%s", str.data());
     return;
   }
   str.append(" created by %s here:\n",
              MemprofThreadIdAndName(context->parent_tid).c_str());

compiler-rt/lib/sanitizer_common/sanitizer_common.h

public:
   InternalMmapVector(const InternalMmapVector &) = delete;
   InternalMmapVector &operator=(const InternalMmapVector &) = delete;
   InternalMmapVector(InternalMmapVector &&) = delete;
   InternalMmapVector &operator=(InternalMmapVector &&) = delete;
 };
 
 class InternalScopedString {
  public:
-  explicit InternalScopedString(uptr max_length)
-      : buffer_(max_length), length_(0) {
-    buffer_[0] = '\0';
-  }
-  uptr length() const { return length_; }
+  explicit InternalScopedString() : buffer_(1) { buffer_[0] = '\0'; }
+
+  uptr length() const { return buffer_.size() - 1; }
   void clear() {
+    buffer_.resize(1);
     buffer_[0] = '\0';
-    length_ = 0;
   }
   void append(const char *format, ...);
   const char *data() const { return buffer_.data(); }
   char *data() { return buffer_.data(); }
 
  private:
   InternalMmapVector<char> buffer_;
-  uptr length_;
 };
 
 template <class T>
 struct CompareLess {
   bool operator()(const T &a, const T &b) const { return a < b; }
 };
 
 // HeapSort for arrays and InternalMmapVector.

compiler-rt/lib/sanitizer_common/sanitizer_common.cpp

if (const char *slash_pos = internal_strrchr(module, '/')) {
     return slash_pos + 1;
   }
   return module;
 }
 
 void ReportErrorSummary(const char *error_message, const char *alt_tool_name) {
   if (!common_flags()->print_summary)
     return;
-  InternalScopedString buff(kMaxSummaryLength);
+  InternalScopedString buff;
   buff.append("SUMMARY: %s: %s",
               alt_tool_name ? alt_tool_name : SanitizerToolName, error_message);
   __sanitizer_report_error_summary(buff.data());
 }
 
 // Removes the ANSI escape sequences from the input string (in-place).
 void RemoveANSIEscapeSequencesFromString(char *str) {
   if (!str)

compiler-rt/lib/sanitizer_common/sanitizer_common_libcdep.cpp

if (heap_profile &&
       __sanitizer_print_memory_profile(90, 20);
       rss_during_last_reported_profile = current_rss_mb;
     }
   }
 }
 #endif
 
 void WriteToSyslog(const char *msg) {
-  InternalScopedString msg_copy(kErrorMessageBufferSize);
+  InternalScopedString msg_copy;
   msg_copy.append("%s", msg);
   const char *p = msg_copy.data();
 
   // Print one line at a time.
   // syslog, at least on Android, has an implicit message length limit.
   while (char* q = internal_strchr(p, '\n')) {
     *q = '\0';
     WriteOneLineToSyslog(p);

compiler-rt/lib/sanitizer_common/sanitizer_linux_libcdep.cpp

if (data->first) {
     InternalMmapVector<char> module_name(kMaxPathLength);
     data->first = false;
     // First module is the binary itself.
     ReadBinaryNameCached(module_name.data(), module_name.size());
     return AddModuleSegments(module_name.data(), info, data->modules);
   }
 
   if (info->dlpi_name) {
-    InternalScopedString module_name(kMaxPathLength);
+    InternalScopedString module_name;
     module_name.append("%s", info->dlpi_name);
     return AddModuleSegments(module_name.data(), info, data->modules);
   }
 
   return 0;
 }
 
 #if SANITIZER_ANDROID && __ANDROID_API__ < 21

compiler-rt/lib/sanitizer_common/sanitizer_malloc_mac.inc

 //===-- sanitizer_malloc_mac.inc --------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains Mac-specific malloc interceptors and a custom zone
 // implementation, which together replace the system allocator.
 //
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_common/sanitizer_platform.h"
 #if !SANITIZER_MAC
 #error "This file should only be compiled on Darwin."
 #endif
 
 #include <AvailabilityMacros.h>
 #include <CoreFoundation/CFBase.h>
 #include <dlfcn.h>
 #include <malloc/malloc.h>
 #include <sys/mman.h>
 
 #include "interception/interception.h"
 #include "sanitizer_common/sanitizer_mac.h"
 

 }
 
 INTERCEPTOR(void, malloc_set_zone_name, malloc_zone_t *zone, const char *name) {
   COMMON_MALLOC_ENTER();
   // Allocate |sizeof(COMMON_MALLOC_ZONE_NAME "-") + internal_strlen(name)|
   // bytes.
   size_t buflen =
       sizeof(COMMON_MALLOC_ZONE_NAME "-") + (name ? internal_strlen(name) : 0);
-  InternalScopedString new_name(buflen);
+  InternalScopedString new_name;
   if (name && zone->introspect == sanitizer_zone.introspect) {
     new_name.append(COMMON_MALLOC_ZONE_NAME "-%s", name);
     name = new_name.data();
   }
 
   // Call the system malloc's implementation for both external and our zones,
   // since that appropriately changes VM region protections on the zone.
   REAL(malloc_set_zone_name)(zone, name);

compiler-rt/lib/sanitizer_common/sanitizer_printf.cpp

int internal_snprintf(char *buffer, uptr length, const char *format, ...) {
   va_start(args, format);
   int needed_length = VSNPrintf(buffer, length, format, args);
   va_end(args);
   return needed_length;
 }
 
 FORMAT(2, 3)
 void InternalScopedString::append(const char *format, ...) {
-  CHECK_LT(length_, buffer_.size());
+  uptr prev_len = length();
+
+  while (true) {
+    buffer_.resize(buffer_.capacity());
+
     va_list args;
     va_start(args, format);
-  VSNPrintf(buffer_.data() + length_, buffer_.size() - length_, format, args);
+    uptr sz = VSNPrintf(buffer_.data() + prev_len, buffer_.size() - prev_len,
+                        format, args);
     va_end(args);
-  length_ += internal_strlen(data() + length_);
-  CHECK_LT(length_, buffer_.size());
+    if (sz < buffer_.size() - prev_len) {
+      buffer_.resize(prev_len + sz + 1);
+      break;
+    }
+
+    buffer_.reserve(buffer_.capacity() * 2);
+  }
+  CHECK_EQ(buffer_[length()], '\0');
 }
 
 } // namespace __sanitizer

compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_libcdep.cpp

 
 namespace __sanitizer {
 
 void StackTrace::Print() const {
   if (trace == nullptr || size == 0) {
     Printf("    <empty stack>\n\n");
     return;
   }
-  InternalScopedString frame_desc(GetPageSizeCached() * 2);
-  InternalScopedString dedup_token(GetPageSizeCached());
+  InternalScopedString frame_desc;
+  InternalScopedString dedup_token;
   int dedup_frames = common_flags()->dedup_token_length;
   bool symbolize = RenderNeedsSymbolization(common_flags()->stack_trace_format);
   uptr frame_num = 0;
   for (uptr i = 0; i < size && trace[i]; i++) {
     // PCs in stack traces are actually the return addresses, that is,
     // addresses of the next instructions after the call.
     uptr pc = GetPreviousInstructionPc(trace[i]);
     SymbolizedStack *frames;
if (symbolize)
     frame = Symbolizer::GetOrInit()->SymbolizePC(pc);
   else
     frame = SymbolizedStack::New(pc);
   if (!frame) {
     internal_strncpy(out_buf, "<can't symbolize>", out_buf_size);
     out_buf[out_buf_size - 1] = 0;
     return;
   }
-  InternalScopedString frame_desc(GetPageSizeCached());
+  InternalScopedString frame_desc;
   uptr frame_num = 0;
   // Reserve one byte for the final 0.
   char *out_end = out_buf + out_buf_size - 1;
   for (SymbolizedStack *cur = frame; cur && out_buf < out_end;
        cur = cur->next) {
     frame_desc.clear();
     RenderFrame(&frame_desc, fmt, frame_num++, cur->info.address,
                 symbolize ? &cur->info : nullptr,

 
 SANITIZER_INTERFACE_ATTRIBUTE
 void __sanitizer_symbolize_global(uptr data_addr, const char *fmt,
                                   char *out_buf, uptr out_buf_size) {
   if (!out_buf_size) return;
   out_buf[0] = 0;
   DataInfo DI;
   if (!Symbolizer::GetOrInit()->SymbolizeData(data_addr, &DI)) return;
-  InternalScopedString data_desc(GetPageSizeCached());
+  InternalScopedString data_desc;
   RenderData(&data_desc, fmt, &DI, common_flags()->strip_path_prefix);
   internal_strncpy(out_buf, data_desc.data(), out_buf_size);
   out_buf[out_buf_size - 1] = 0;
 }
 
 SANITIZER_INTERFACE_ATTRIBUTE
 int __sanitizer_get_module_and_offset_for_pc(uptr pc, char *module_name,
                                              uptr module_name_len,
                                              uptr *pc_offset) {
   return __sanitizer::GetModuleAndOffsetForPc(pc, module_name, module_name_len,
                                               pc_offset);
 }
 }  // extern "C"

compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_report.cpp

 #endif
 
 namespace __sanitizer {
 
 #if !SANITIZER_GO
 void ReportErrorSummary(const char *error_type, const AddressInfo &info,
                         const char *alt_tool_name) {
   if (!common_flags()->print_summary) return;
-  InternalScopedString buff(kMaxSummaryLength);
+  InternalScopedString buff;
   buff.append("%s ", error_type);
   RenderFrame(&buff, "%L %F", 0, info.address, &info,
               common_flags()->symbolize_vs_style,
               common_flags()->strip_path_prefix);
   ReportErrorSummary(buff.data(), alt_tool_name);
 }
 #endif
 
static void PrintMemoryByte(InternalScopedString *str, const char *before,
   SanitizerCommonDecorator d;
   str->append("%s%s%x%x%s ", before, d.MemoryByte(), byte >> 4, byte & 15,
               d.Default());
 }
 
 static void MaybeDumpInstructionBytes(uptr pc) {
   if (!common_flags()->dump_instruction_bytes || (pc < GetPageSizeCached()))
     return;
-  InternalScopedString str(1024);
+  InternalScopedString str;
   str.append("First 16 instruction bytes at pc: ");
   if (IsAccessibleMemoryRange(pc, 16)) {
     for (int i = 0; i < 16; ++i) {
       PrintMemoryByte(&str, "", ((u8 *)pc)[i]);
     }
     str.append("\n");
   } else {
     str.append("unaccessible\n");

compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_win.cpp

if (!SetHandleInformation(stdin_write.get(), HANDLE_FLAG_INHERIT, 0) ||
     VReport(2, "WARNING: %s SetHandleInformation failed (error code: %d)\n",
             SanitizerToolName, path_, GetLastError());
     return false;
   }
 
   // Compute the command line. Wrap double quotes around everything.
   const char *argv[kArgVMax];
   GetArgV(path_, argv);
-  InternalScopedString command_line(kMaxPathLength * 3);
+  InternalScopedString command_line;
   for (int i = 0; argv[i]; i++) {
     const char *arg = argv[i];
     int arglen = internal_strlen(arg);
     // Check that tool command lines are simple and that complete escaping is
     // unnecessary.
     CHECK(!internal_strchr(arg, '"') && "quotes in args unsupported");
     CHECK(!internal_strstr(arg, "\\\\") &&
           "double backslashes in args unsupported");

compiler-rt/lib/sanitizer_common/tests/sanitizer_common_test.cpp

 //===-- sanitizer_common_test.cpp -----------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is a part of ThreadSanitizer/AddressSanitizer runtime.
 //
 //===----------------------------------------------------------------------===//
 #include <algorithm>
 
 #include "sanitizer_common/sanitizer_allocator_internal.h"
 #include "sanitizer_common/sanitizer_common.h"
 #include "sanitizer_common/sanitizer_file.h"
 #include "sanitizer_common/sanitizer_flags.h"
 #include "sanitizer_common/sanitizer_libc.h"
 #include "sanitizer_common/sanitizer_platform.h"
 
for (size_t i = 0; i < ARRAY_SIZE(buffs); i+=2) {
     char *buffer_copy = internal_strdup(buffs[i]);
     RemoveANSIEscapeSequencesFromString(buffer_copy);
     EXPECT_STREQ(buffer_copy, buffs[i+1]);
     InternalFree(buffer_copy);
   }
 }
 
 TEST(SanitizerCommon, InternalScopedString) {
-  InternalScopedString str(10);
+  InternalScopedString str;
   EXPECT_EQ(0U, str.length());
   EXPECT_STREQ("", str.data());
 
   str.append("foo");
   EXPECT_EQ(3U, str.length());
   EXPECT_STREQ("foo", str.data());
 
   int x = 1234;
   str.append("%d", x);
   EXPECT_EQ(7U, str.length());
   EXPECT_STREQ("foo1234", str.data());
 
   str.append("%d", x);
-  EXPECT_EQ(9U, str.length());
-  EXPECT_STREQ("foo123412", str.data());
+  EXPECT_EQ(11U, str.length());
+  EXPECT_STREQ("foo12341234", str.data());
 
   str.clear();
   EXPECT_EQ(0U, str.length());
   EXPECT_STREQ("", str.data());
+}
 
-  str.append("0123456789");
-  EXPECT_EQ(9U, str.length());
-  EXPECT_STREQ("012345678", str.data());
+TEST(SanitizerCommon, InternalScopedStringLarge) {
+  InternalScopedString str;
+  std::string expected;
+  for (int i = 0; i < 1000; ++i) {
+    std::string append(i, 'a' + i % 26);
+    expected += append;
+    str.append(append.c_str());
+    EXPECT_EQ(expected, str.data());
+  }
+}
+
+TEST(SanitizerCommon, InternalScopedStringLargeFormat) {
+  InternalScopedString str;
+  std::string expected;
+  for (int i = 0; i < 1000; ++i) {
+    std::string append(i, 'a' + i % 26);
+    expected += append;
+    str.append("%s", append.c_str());
+    EXPECT_EQ(expected, str.data());
+  }
 }
 
-#if SANITIZER_LINUX || SANITIZER_FREEBSD || \
-  SANITIZER_MAC || SANITIZER_IOS
+#if SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_MAC || SANITIZER_IOS
 TEST(SanitizerCommon, GetRandom) {
   u8 buffer_1[32], buffer_2[32];
   for (bool blocking : { false, true }) {
     EXPECT_FALSE(GetRandom(nullptr, 32, blocking));
     EXPECT_FALSE(GetRandom(buffer_1, 0, blocking));
     EXPECT_FALSE(GetRandom(buffer_1, 512, blocking));
     EXPECT_EQ(ARRAY_SIZE(buffer_1), ARRAY_SIZE(buffer_2));
     for (uptr size = 4; size <= ARRAY_SIZE(buffer_1); size += 4) {

compiler-rt/lib/sanitizer_common/tests/sanitizer_stacktrace_printer_test.cpp

 //===-- sanitizer_common_printer_test.cpp ---------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is a part of sanitizer_common test suite.
 //
 //===----------------------------------------------------------------------===//
 #include "sanitizer_common/sanitizer_stacktrace_printer.h"
 
 #include "gtest/gtest.h"
 
 namespace __sanitizer {
 
 TEST(SanitizerStacktracePrinter, RenderSourceLocation) {
-  InternalScopedString str(128);
+  InternalScopedString str;
   RenderSourceLocation(&str, "/dir/file.cc", 10, 5, false, "");
   EXPECT_STREQ("/dir/file.cc:10:5", str.data());
 
   str.clear();
   RenderSourceLocation(&str, "/dir/file.cc", 11, 0, false, "");
   EXPECT_STREQ("/dir/file.cc:11", str.data());
 
   str.clear();
TEST(SanitizerStacktracePrinter, RenderSourceLocation) {
   EXPECT_STREQ("/dir/file.cc", str.data());
 
   str.clear();
   RenderSourceLocation(&str, "/dir/file.cc", 10, 5, true, "/dir/");
   EXPECT_STREQ("file.cc(10,5)", str.data());
 }
 
 TEST(SanitizerStacktracePrinter, RenderModuleLocation) {
-  InternalScopedString str(128);
+  InternalScopedString str;
   RenderModuleLocation(&str, "/dir/exe", 0x123, kModuleArchUnknown, "");
   EXPECT_STREQ("(/dir/exe+0x123)", str.data());
 
   // Check that we strip file prefix if necessary.
   str.clear();
   RenderModuleLocation(&str, "/dir/exe", 0x123, kModuleArchUnknown, "/dir/");
   EXPECT_STREQ("(exe+0x123)", str.data());
 
TEST(SanitizerStacktracePrinter, RenderFrame) {
   info.address = 0x400000;
   info.module = internal_strdup("/path/to/my/module");
   info.module_offset = 0x200;
   info.function = internal_strdup("function_foo");
   info.function_offset = 0x100;
   info.file = internal_strdup("/path/to/my/source");
   info.line = 10;
   info.column = 5;
-  InternalScopedString str(256);
+  InternalScopedString str;
 
   // Dump all the AddressInfo fields.
   RenderFrame(&str,
               "%% Frame:%n PC:%p Module:%m ModuleOffset:%o "
               "Function:%f FunctionOffset:%q Source:%s Line:%l "
               "Column:%c",
               frame_no, info.address, &info, false, "/path/to/", "function_");
   EXPECT_STREQ("% Frame:42 PC:0x400000 Module:my/module ModuleOffset:0x200 "

compiler-rt/lib/tsan/rtl/tsan_report.cpp

 
 void PrintStack(const ReportStack *ent) {
   if (ent == 0 || ent->frames == 0) {
     Printf("    [failed to restore the stack]\n\n");
     return;
   }
   SymbolizedStack *frame = ent->frames;
   for (int i = 0; frame && frame->info.address; frame = frame->next, i++) {
-    InternalScopedString res(2 * GetPageSizeCached());
+    InternalScopedString res;
     RenderFrame(&res, common_flags()->stack_trace_format, i,
                 frame->info.address, &frame->info,
                 common_flags()->symbolize_vs_style,
                 common_flags()->strip_path_prefix, kInterposedFunctionPrefix);
     Printf("%s\n", res.data());
   }
   Printf("\n");
 }

compiler-rt/lib/tsan/rtl/tsan_rtl.cpp

static void *BackgroundThread(void *arg) {
 
   fd_t mprof_fd = kInvalidFd;
   if (flags()->profile_memory && flags()->profile_memory[0]) {
     if (internal_strcmp(flags()->profile_memory, "stdout") == 0) {
       mprof_fd = 1;
     } else if (internal_strcmp(flags()->profile_memory, "stderr") == 0) {
       mprof_fd = 2;
     } else {
-      InternalScopedString filename(kMaxPathLength);
+      InternalScopedString filename;
       filename.append("%s.%d", flags()->profile_memory, (int)internal_getpid());
       fd_t fd = OpenFile(filename.data(), WrOnly);
       if (fd == kInvalidFd) {
         Printf("ThreadSanitizer: failed to open memory profile file '%s'\n",
                filename.data());
       } else {
         mprof_fd = fd;
       }

compiler-rt/lib/ubsan/ubsan_diag.cpp

static void PrintMemorySnippet(const Decorator &Decor, MemoryLocation Loc,
   Max = addNoOverflow(Min, BytesToShow);
 
   if (!IsAccessibleMemoryRange(Min, Max - Min)) {
     Printf("<memory cannot be printed>\n");
     return;
   }
 
   // Emit data.
-  InternalScopedString Buffer(1024);
+  InternalScopedString Buffer;
   for (uptr P = Min; P != Max; ++P) {
     unsigned char C = *reinterpret_cast<const unsigned char*>(P);
     Buffer.append("%s%02x", (P % 8 == 0) ? "  " : " ", C);
   }
   Buffer.append("\n");
 
   // Emit highlights.
   Buffer.append(Decor.Highlight());
static void PrintMemorySnippet(const Decorator &Decor, MemoryLocation Loc,
   //
   // This needs an external symbolizer, or (preferably) ASan instrumentation.
 }
 
 Diag::~Diag() {
   // All diagnostics should be printed under report mutex.
   ScopedReport::CheckLocked();
   Decorator Decor;
-  InternalScopedString Buffer(1024);
+  InternalScopedString Buffer;
 
   // Prepare a report that a monitor process can inspect.
   if (Level == DL_Error) {
     RenderText(&Buffer, Message, Args);
     UndefinedBehaviorReport UBR{ConvertTypeToString(ET), Loc, Buffer};
     Buffer.clear();
   }
 

compiler-rt/lib/ubsan/ubsan_monitor.cpp

 
 #include "ubsan_monitor.h"
 
 using namespace __ubsan;
 
 UndefinedBehaviorReport::UndefinedBehaviorReport(const char *IssueKind,
                                                  Location &Loc,
                                                  InternalScopedString &Msg)
-    : IssueKind(IssueKind), Loc(Loc), Buffer(Msg.length() + 1) {
+    : IssueKind(IssueKind), Loc(Loc) {
   // We have the common sanitizer reporting lock, so it's safe to register a
   // new UB report.
   RegisterUndefinedBehaviorReport(this);
 
   // Make a copy of the diagnostic.
   Buffer.append("%s", Msg.data());
 
   // Let the monitor know that a report is available.