Replace InternalScopedBuffer<char> with InternalScopedString where applicable.

[samsonov]

Summary

No functionality change.

[kcc]

LGTM

[samsonov]

Closed by commit rL223164 (authored by @samsonov).

compiler-rt/trunk/lib/asan/asan_malloc_mac.cc

INTERCEPTOR(int, malloc_make_nonpurgeable, void *ptr) {
   // malloc_make_purgeable().
   return 0;
 }
 
 INTERCEPTOR(void, malloc_set_zone_name, malloc_zone_t *zone, const char *name) {
   ENSURE_ASAN_INITED();
   // Allocate |strlen("asan-") + 1 + internal_strlen(name)| bytes.
   size_t buflen = 6 + (name ? internal_strlen(name) : 0);
-  InternalScopedBuffer<char> new_name(buflen);
+  InternalScopedString new_name(buflen);
   if (name && zone->introspect == asan_zone.introspect) {
-    internal_snprintf(new_name.data(), buflen, "asan-%s", name);
+    new_name.append("asan-%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/trunk/lib/lsan/lsan_common.cc

 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;
   }
-  InternalScopedBuffer<char> summary(kMaxSummaryLength);
-  internal_snprintf(summary.data(), summary.size(),
-                    "%zu byte(s) leaked in %zu allocation(s).", bytes,
-                    allocations);
+  InternalScopedString summary(kMaxSummaryLength);
+  summary.append("%zu byte(s) leaked in %zu allocation(s).", bytes,
   ReportErrorSummary(summary.data());
 }
 
 void LeakReport::ApplySuppressions() {
   for (uptr i = 0; i < leaks_.size(); i++) {
     Suppression *s = GetSuppressionForStack(leaks_[i].stack_trace_id);
     if (s) {
       s->weight += leaks_[i].total_size;

compiler-rt/trunk/lib/sanitizer_common/sanitizer_common.cc

const char *StripModuleName(const char *module) {
   if (const char *slash_pos = internal_strrchr(module, '/'))
     return slash_pos + 1;
   return module;
 }
 
 void ReportErrorSummary(const char *error_message) {
   if (!common_flags()->print_summary)
     return;
-  InternalScopedBuffer<char> buff(kMaxSummaryLength);
-  internal_snprintf(buff.data(), buff.size(),
-                    "SUMMARY: %s: %s", SanitizerToolName, error_message);
+  InternalScopedString buff(kMaxSummaryLength);
+  buff.append("SUMMARY: %s: %s", SanitizerToolName, error_message);
   __sanitizer_report_error_summary(buff.data());
 }
 
 void ReportErrorSummary(const char *error_type, const char *file,
                         int line, const char *function) {
   if (!common_flags()->print_summary)
     return;
-  InternalScopedBuffer<char> buff(kMaxSummaryLength);
-  internal_snprintf(
-      buff.data(), buff.size(), "%s %s:%d %s", error_type,
-      file ? StripPathPrefix(file, common_flags()->strip_path_prefix) : "??",
+  InternalScopedString buff(kMaxSummaryLength);
+  buff.append("%s %s:%d %s", error_type,
+              file ? StripPathPrefix(file, common_flags()->strip_path_prefix)
+                   : "??",
               line, function ? function : "??");
   ReportErrorSummary(buff.data());
 }
 
 LoadedModule::LoadedModule(const char *module_name, uptr base_address) {
   full_name_ = internal_strdup(module_name);
   base_address_ = base_address;
   n_ranges_ = 0;
 }

compiler-rt/trunk/lib/sanitizer_common/sanitizer_coverage_libcdep.cc

static void CovWritePacked(int pid, const char *module, const void *blob,
   }
 }
 
 // If packed = false: <name>.<pid>.<sancov> (name = module name).
 // If packed = true and name == 0: <pid>.<sancov>.<packed>.
 // If packed = true and name != 0: <name>.<sancov>.<packed> (name is
 // user-supplied).
 static int CovOpenFile(bool packed, const char* name) {
-  InternalScopedBuffer<char> path(kMaxPathLength);
+  InternalScopedString path(kMaxPathLength);
   if (!packed) {
     CHECK(name);
-    internal_snprintf((char *)path.data(), path.size(), "%s/%s.%zd.sancov",
-                      common_flags()->coverage_dir, name, internal_getpid());
+    path.append("%s/%s.%zd.sancov", common_flags()->coverage_dir, name,
+                internal_getpid());
   } else {
     if (!name)
-      internal_snprintf((char *)path.data(), path.size(),
-                        "%s/%zd.sancov.packed", common_flags()->coverage_dir,
-                        internal_getpid());
+      path.append("%s/%zd.sancov.packed", common_flags()->coverage_dir,
     else
-      internal_snprintf((char *)path.data(), path.size(), "%s/%s.sancov.packed",
-                        common_flags()->coverage_dir, name);
+      path.append("%s/%s.sancov.packed", common_flags()->coverage_dir, name);
   }
   uptr fd = OpenFile(path.data(), true);
   if (internal_iserror(fd)) {
     Report(" SanitizerCoverage: failed to open %s for writing\n", path.data());
     return -1;
   }
   return fd;
 }
if (atomic_fetch_add(&dump_once_guard, 1, memory_order_relaxed))
     return;
   uptr size = coverage_data.size();
   InternalMmapVector<u32> offsets(size);
   uptr *vb = coverage_data.data();
   uptr *ve = vb + size;
   SortArray(vb, size);
   MemoryMappingLayout proc_maps(/*cache_enabled*/true);
   uptr mb, me, off, prot;
-  InternalScopedBuffer<char> module(kMaxPathLength);
-  InternalScopedBuffer<char> path(kMaxPathLength);
+  InternalScopedString module(kMaxPathLength);
+  InternalScopedString path(kMaxPathLength);
   for (int i = 0;
        proc_maps.Next(&mb, &me, &off, module.data(), module.size(), &prot);
        i++) {
     if ((prot & MemoryMappingLayout::kProtectionExecute) == 0)
       continue;
     while (vb < ve && *vb < mb) vb++;
     if (vb >= ve) break;
     if (*vb < me) {
if (*vb < me) {
       if (cov_sandboxed) {
         if (cov_fd >= 0) {
           CovWritePacked(internal_getpid(), module_name, offsets.data(),
                          offsets.size() * sizeof(u32));
           VReport(1, " CovDump: %zd PCs written to packed file\n", vb - old_vb);
         }
       } else {
         // One file per module per process.
-        internal_snprintf((char *)path.data(), path.size(), "%s/%s.%zd.sancov",
-                          common_flags()->coverage_dir, module_name,
-                          internal_getpid());
+        path.clear();
+        path.append("%s/%s.%zd.sancov", common_flags()->coverage_dir,
+                    module_name, internal_getpid());
         int fd = CovOpenFile(false /* packed */, module_name);
         if (fd > 0) {
           internal_write(fd, offsets.data(), offsets.size() * sizeof(u32));
           internal_close(fd);
           VReport(1, " CovDump: %s: %zd PCs written\n", path.data(),
                   vb - old_vb);
         }
       }

compiler-rt/trunk/lib/sanitizer_common/sanitizer_coverage_mapping_libcdep.cc

void CovUpdateMapping(uptr caller_pc) {
   if (!common_flags()->coverage || !common_flags()->coverage_direct) return;
 
   SpinMutexLock l(&mapping_mu);
 
   if (!cached_mapping.NeedsUpdate(caller_pc))
     return;
 
   InternalScopedString text(kMaxTextSize);
-  InternalScopedBuffer<char> modules_data(kMaxNumberOfModules *
-                                          sizeof(LoadedModule));
-  LoadedModule *modules = (LoadedModule *)modules_data.data();
-  CHECK(modules);
-  int n_modules = GetListOfModules(modules, kMaxNumberOfModules,
+  InternalScopedBuffer<LoadedModule> modules(kMaxNumberOfModules);
+  CHECK(modules.data());
+  int n_modules = GetListOfModules(modules.data(), kMaxNumberOfModules,
                                    /* filter */ 0);
 
   text.append("%d\n", sizeof(uptr) * 8);
   for (int i = 0; i < n_modules; ++i) {
     const char *module_name = StripModuleName(modules[i].full_name());
     for (unsigned j = 0; j < modules[i].n_ranges(); ++j) {
       if (modules[i].address_range_executable(j)) {
         uptr start = modules[i].address_range_start(j);

compiler-rt/trunk/lib/sanitizer_common/sanitizer_libignore.cc

for (uptr i = 0; i < n; i++) {
     lib->name = 0;
     lib->loaded = false;
   }
 }
 
 void LibIgnore::OnLibraryLoaded(const char *name) {
   BlockingMutexLock lock(&mutex_);
   // Try to match suppressions with symlink target.
-  InternalScopedBuffer<char> buf(kMaxPathLength);
+  InternalScopedString buf(kMaxPathLength);
   if (name != 0 && internal_readlink(name, buf.data(), buf.size() - 1) > 0 &&
-      buf.data()[0]) {
+      buf[0]) {
     for (uptr i = 0; i < count_; i++) {
       Lib *lib = &libs_[i];
       if (!lib->loaded && lib->real_name == 0 &&
           TemplateMatch(lib->templ, name))
         lib->real_name = internal_strdup(buf.data());
     }
   }
 
   // Scan suppressions list and find newly loaded and unloaded libraries.
   MemoryMappingLayout proc_maps(/*cache_enabled*/false);
-  InternalScopedBuffer<char> module(kMaxPathLength);
+  InternalScopedString module(kMaxPathLength);
   for (uptr i = 0; i < count_; i++) {
     Lib *lib = &libs_[i];
     bool loaded = false;
     proc_maps.Reset();
     uptr b, e, off, prot;
     while (proc_maps.Next(&b, &e, &off, module.data(), module.size(), &prot)) {
       if ((prot & MemoryMappingLayout::kProtectionExecute) == 0)
         continue;

compiler-rt/trunk/lib/sanitizer_common/sanitizer_linux_libcdep.cc

struct DlIteratePhdrData {
   uptr max_n;
   string_predicate_t filter;
 };
 
 static int dl_iterate_phdr_cb(dl_phdr_info *info, size_t size, void *arg) {
   DlIteratePhdrData *data = (DlIteratePhdrData*)arg;
   if (data->current_n == data->max_n)
     return 0;
-  InternalScopedBuffer<char> module_name(kMaxPathLength);
-  module_name.data()[0] = '\0';
+  InternalScopedString module_name(kMaxPathLength);
   if (data->first) {
     data->first = false;
     // First module is the binary itself.
     ReadBinaryName(module_name.data(), module_name.size());
   } else if (info->dlpi_name) {
-    internal_strncpy(module_name.data(), info->dlpi_name, module_name.size());
+    module_name.append("%s", info->dlpi_name);
   }
-  if (module_name.data()[0] == '\0')
+  if (module_name[0] == '\0')
     return 0;
   if (data->filter && !data->filter(module_name.data()))
     return 0;
   void *mem = &data->modules[data->current_n];
   LoadedModule *cur_module = new(mem) LoadedModule(module_name.data(),
                                                    info->dlpi_addr);
   data->current_n++;
   for (int i = 0; i < info->dlpi_phnum; i++) {

compiler-rt/trunk/lib/sanitizer_common/sanitizer_posix.cc

 
 void MaybeOpenReportFile() {
   if (!log_to_file) return;
   uptr pid = internal_getpid();
   // If in tracer, use the parent's file.
   if (pid == stoptheworld_tracer_pid)
     pid = stoptheworld_tracer_ppid;
   if (report_fd_pid == pid) return;
-  InternalScopedBuffer<char> report_path_full(kMaxPathLength);
-  internal_snprintf(report_path_full.data(), report_path_full.size(),
-                    "%s.%zu", report_path_prefix, pid);
+  InternalScopedString report_path_full(kMaxPathLength);
+  report_path_full.append("%s.%zu", report_path_prefix, pid);
   uptr openrv = OpenFile(report_path_full.data(), true);
   if (internal_iserror(openrv)) {
     report_fd = kStderrFd;
     log_to_file = false;
     Report("ERROR: Can't open file: %s\n", report_path_full.data());
     Die();
   }
   if (report_fd != kInvalidFd) {

compiler-rt/trunk/lib/sanitizer_common/sanitizer_procmaps_common.cc

void MemoryMappingLayout::LoadFromCache() {
   }
 }
 
 uptr MemoryMappingLayout::DumpListOfModules(LoadedModule *modules,
                                             uptr max_modules,
                                             string_predicate_t filter) {
   Reset();
   uptr cur_beg, cur_end, cur_offset, prot;
-  InternalScopedBuffer<char> module_name(kMaxPathLength);
+  InternalScopedString module_name(kMaxPathLength);
   uptr n_modules = 0;
   for (uptr i = 0; n_modules < max_modules &&
                        Next(&cur_beg, &cur_end, &cur_offset, module_name.data(),
                             module_name.size(), &prot);
        i++) {
     const char *cur_name = module_name.data();
     if (cur_name[0] == '\0')
       continue;

compiler-rt/trunk/lib/sanitizer_common/sanitizer_procmaps_mac.cc

#endif
   return false;
 }
 
 uptr MemoryMappingLayout::DumpListOfModules(LoadedModule *modules,
                                             uptr max_modules,
                                             string_predicate_t filter) {
   Reset();
   uptr cur_beg, cur_end, prot;
-  InternalScopedBuffer<char> module_name(kMaxPathLength);
+  InternalScopedString module_name(kMaxPathLength);
   uptr n_modules = 0;
   for (uptr i = 0; n_modules < max_modules &&
                        Next(&cur_beg, &cur_end, 0, module_name.data(),
                             module_name.size(), &prot);
        i++) {
     const char *cur_name = module_name.data();
     if (cur_name[0] == '\0')
       continue;

compiler-rt/trunk/lib/tsan/rtl/tsan_rtl.cc

#endif
 
   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 {
-      InternalScopedBuffer<char> filename(4096);
-      internal_snprintf(filename.data(), filename.size(), "%s.%d",
-          flags()->profile_memory, (int)internal_getpid());
+      InternalScopedString filename(kMaxPathLength);
+      filename.append("%s.%d", flags()->profile_memory, (int)internal_getpid());
       uptr openrv = OpenFile(filename.data(), true);
       if (internal_iserror(openrv)) {
         Printf("ThreadSanitizer: failed to open memory profile file '%s'\n",
             &filename[0]);
       } else {
         mprof_fd = openrv;
       }
     }