reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

Declarations

  190 void Printf(const char *format, ...);

References

   55     Printf("%s", str.data());
   60   Printf("%s", str.data());
  153   Printf("%s", str.data());
  184     Printf(
  266   Printf("%s", str.data());
  299   Printf("%s", str.data());
  322   Printf("Address %p is located in the %s area.\n", addr, ShadowNames[kind]);
  331       Printf("  registered at:\n");
  359   Printf("%s", d.Location());
  360   Printf("Address %p is located in stack of thread %s", addr,
  364     Printf("%s\n", d.Default());
  367   Printf(" at offset %zu in frame%s\n", offset, d.Default());
  376   Printf("%s", d.Default());
  383     Printf(
  392   Printf("  This frame has %zu object(s):\n", n_objects);
  401   Printf(
  405     Printf("      (longjmp, SEH and C++ exceptions *are* supported)\n");
  407     Printf("      (longjmp and C++ exceptions *are* supported)\n");
  423     Printf("%sfreed by thread %s here:%s\n", d.Allocation(),
  427     Printf("%spreviously allocated by thread %s here:%s\n", d.Allocation(),
  430     Printf("%sallocated by thread %s here:%s\n", d.Allocation(),
  497   Printf(

  229         Printf("Address %p is a wild pointer.\n", data.addr);

   48   Printf("%s", d.Error());
   53   Printf("%s", d.Default());
   64   Printf("%s", d.Error());
   69   Printf("%s  object passed to delete has wrong type:\n", d.Default());
   71     Printf(
   86     Printf(
  105   Printf("%s", d.Error());
  110   Printf("%s", d.Default());
  126   Printf("%s", d.Error());
  130   Printf("%s", d.Default());
  144   Printf("%s", d.Error());
  149   Printf("%s", d.Default());
  157   Printf("%s", d.Error());
  162   Printf("%s", d.Default());
  170   Printf("%s", d.Error());
  175   Printf("%s", d.Default());
  183   Printf("%s", d.Error());
  188   Printf("%s", d.Default());
  196   Printf("%s", d.Error());
  202   Printf("%s", d.Default());
  210   Printf("%s", d.Error());
  215   Printf("%s", d.Default());
  223   Printf("%s", d.Error());
  235   Printf("%s", d.Default());
  243   Printf("%s", d.Error());
  249   Printf("%s", d.Default());
  257   Printf("%s", d.Error());
  263   Printf("%s", d.Default());
  271   Printf("%s", d.Error());
  275   Printf("%s", d.Default());
  283   Printf("%s", d.Error());
  287   Printf("%s", d.Default());
  297   Printf("%s", d.Error());
  304   Printf("%s", d.Default());
  314   Printf("%s", d.Error());
  317   Printf("%s", d.Default());
  342   Printf("%s", d.Error());
  345   Printf("%s", d.Default());
  349   Printf("  [1] size=%zd '%s' %s\n", global1.size,
  351   Printf("  [2] size=%zd '%s' %s\n", global2.size,
  354     Printf("These globals were registered at these points:\n");
  355     Printf("  [1]:\n");
  357     Printf("  [2]:\n");
  371   Printf("%s", d.Error());
  374   Printf("%s", d.Default());
  487   Printf("HINT: if you don't care about these errors you may set "
  570   Printf("%s", str.data());
  575   Printf("%s", d.Error());
  579   Printf("%s", d.Default());
  581   Printf("%s%s of size %zu at %p thread %s%s\n", d.Access(),

  372     Printf("=== ID %d; %p %p\n", stack_id, &globals[0], &globals[n - 1]);
  429     Printf("DynInitPoison module: %s\n", module_name);

   57     Printf("Live Heap Allocations: %zd bytes in %zd chunks; quarantined: "
   68       Printf("%zd byte(s) (%zd%%) in %zd allocation(s)\n", a.total_size,

   74     Printf("__asan_%spoison_intra_object_redzone [%p,%p) %zd\n",
  111   VPrintf(3, "Trying to poison memory region [%p, %p)\n", (void *)beg_addr,
  151   VPrintf(3, "Trying to unpoison memory region [%p, %p)\n", (void *)beg_addr,
  359   VPrintf(2, "contiguous_container: %p %p %p %p\n", beg_p, end_p, old_mid_p,

   70       Printf("malloc_zone_from_ptr(%p) = %p, which is %s\n",
   73       Printf("malloc_zone_from_ptr(%p) = %p, which doesn't have a name\n",
   77     Printf("malloc_zone_from_ptr(%p) = 0\n", ptr);
  131     Printf(
  434   Printf("mz_realloc(%p) -- attempting to realloc unallocated memory.\n"

  307   Printf("AddressSanitizer exit stats:\n");
  312     Printf("asan_mapping.h:%zd -- %zd\n", i, AsanMappingProfile[i]);
  330     Printf("|| `[%p, %p]` || HighMem    ||\n",
  332     Printf("|| `[%p, %p]` || HighShadow ||\n",
  336     Printf("|| `[%p, %p]` || ShadowGap3 ||\n",
  338     Printf("|| `[%p, %p]` || MidMem     ||\n",
  340     Printf("|| `[%p, %p]` || ShadowGap2 ||\n",
  342     Printf("|| `[%p, %p]` || MidShadow  ||\n",
  345   Printf("|| `[%p, %p]` || ShadowGap  ||\n",
  348     Printf("|| `[%p, %p]` || LowShadow  ||\n",
  350     Printf("|| `[%p, %p]` || LowMem     ||\n",
  353   Printf("MemToShadow(shadow): %p %p",
  357     Printf(" %p %p",
  362     Printf(" %p %p",
  366   Printf("\n");
  367   Printf("redzone=%zu\n", (uptr)flags()->redzone);
  368   Printf("max_redzone=%zu\n", (uptr)flags()->max_redzone);
  369   Printf("quarantine_size_mb=%zuM\n", (uptr)flags()->quarantine_size_mb);
  370   Printf("thread_local_quarantine_size_kb=%zuK\n",
  372   Printf("malloc_context_size=%zu\n",
  375   Printf("SHADOW_SCALE: %d\n", (int)SHADOW_SCALE);
  376   Printf("SHADOW_GRANULARITY: %d\n", (int)SHADOW_GRANULARITY);
  377   Printf("SHADOW_OFFSET: 0x%zx\n", (uptr)SHADOW_OFFSET);

   51       Printf("SCARINESS: %d (%s)\n", score, descr);

   51       Printf(

   34   Printf("%s", prefix);
   37     Printf("%zu:%zu; ", i, array[i]);
   39   Printf("\n");
   43   Printf("Stats: %zuM malloced (%zuM for red zones) by %zu calls\n",
   45   Printf("Stats: %zuM realloced by %zu calls\n", realloced>>20, reallocs);
   46   Printf("Stats: %zuM freed by %zu calls\n", freed>>20, frees);
   47   Printf("Stats: %zuM really freed by %zu calls\n",
   49   Printf("Stats: %zuM (%zuM-%zuM) mmaped; %zu maps, %zu unmaps\n",
   54   Printf("Stats: malloc large: %zu\n", malloc_large);
  128   Printf("Stats: StackDepot: %zd ids; %zdM allocated\n",

   76     __sanitizer::Printf("GWP-ASan ERROR: MaxSimultaneousAllocations must be > "
   82     __sanitizer::Printf(
   87   o->Printf = __sanitizer::Printf;

  318     Printf("FATAL: HWAddressSanitizer cannot mmap the shadow memory.\n");
  403   VPrintf(1, "HWAddressSanitizer init done\n");
  425   Printf("HWASan shadow map for %zx .. %zx (pointer tag %x)\n", ptr_raw,
  428     Printf("  %zx: %x\n", ShadowToMem(s), *(tag_t *)s);
  592   Printf("%s\n", s.data());

  112   Printf("|| [%p, %p] || %.*s ||\n", (void *)start, (void *)end, 10, name);
  164     Printf(
  175     Printf(

   44     Printf("[alloc] %u %zu\n", h, orig_size);

  174           Printf("Potentially referenced stack objects:\n");
  177         Printf("  %s in %s %s:%d\n", local.name, local.function_name,
  190   Printf("Previously allocated frames:\n");
  206     Printf("%s", frame_desc.data());
  235     Printf("%s[%p,%p) is a %s %s heap chunk; "
  269       Printf("%s", d.Location());
  270       Printf("%p is located %zd bytes to the %s of %zd-byte region [%p,%p)\n",
  276       Printf("%s", d.Allocation());
  277       Printf("allocated here:\n");
  278       Printf("%s", d.Default());
  291           Printf(
  300           Printf("%p is located to the %s of a global variable in (%s+0x%x)\n",
  313       Printf("%s", d.Location());
  314       Printf("%p is located %zd bytes inside of %zd-byte region [%p,%p)\n",
  318       Printf("%s", d.Allocation());
  319       Printf("freed by thread T%zd here:\n", t->unique_id());
  320       Printf("%s", d.Default());
  323       Printf("%s", d.Allocation());
  324       Printf("previously allocated here:\n", t);
  325       Printf("%s", d.Default());
  330       Printf("hwasan_dev_note_heap_rb_distance: %zd %zd\n", D,
  339       Printf("%s", d.Location());
  340       Printf("Address %p is located in stack of thread T%zd\n", untagged_addr,
  342       Printf("%s", d.Default());
  358     Printf("HWAddressSanitizer can not describe address in more detail.\n");
  381   Printf("%s", s.data());
  385   Printf(
  392   Printf(
  405   Printf(
  420   Printf("%s", d.Error());
  425   Printf("%s", d.Access());
  426   Printf("tags: %02x/%02x (ptr/mem)\n", ptr_tag, mem_tag);
  427   Printf("%s", d.Default());
  444   Printf("%s", d.Error());
  448   Printf("\n%s", d.Default());
  452     Printf("%s", d.Allocation());
  453     Printf("allocated here:\n");
  454     Printf("%s", d.Default());
  488   Printf("%s", s.data());
  504   Printf("%s", d.Error());
  522   Printf("%s", d.Access());
  523   Printf("%s of size %zu at %p tags: %02x/%02x (ptr/mem) in thread T%zd\n",
  527     Printf("Invalid access starting at offset [%zu, %zu)\n", offset,
  529   Printf("%s", d.Default());
  548   Printf("Registers where the failure occurred (pc %p):\n", pc);
  554   Printf("    x0  %016llx  x1  %016llx  x2  %016llx  x3  %016llx\n",
  556   Printf("    x4  %016llx  x5  %016llx  x6  %016llx  x7  %016llx\n",
  558   Printf("    x8  %016llx  x9  %016llx  x10 %016llx  x11 %016llx\n",
  560   Printf("    x12 %016llx  x13 %016llx  x14 %016llx  x15 %016llx\n",
  562   Printf("    x16 %016llx  x17 %016llx  x18 %016llx  x19 %016llx\n",
  564   Printf("    x20 %016llx  x21 %016llx  x22 %016llx  x23 %016llx\n",
  566   Printf("    x24 %016llx  x25 %016llx  x26 %016llx  x27 %016llx\n",
  568   Printf("    x28 %016llx  x29 %016llx  x30 %016llx\n",

   70       Printf("sizeof(Thread): %zd sizeof(HeapRB): %zd sizeof(StackRB): %zd\n",
   96   Printf("%sT%zd %p stack: [%p,%p) sz: %zd tls: [%p,%p)\n", Prefix,

   64   Printf("stack history size too large: %d\n", flags()->stack_history_size);

  515   Printf("%s\n", line);
  516   Printf("Suppressions used:\n");
  517   Printf("  count      bytes template\n");
  519     Printf("%7zu %10zu %s\n", static_cast<uptr>(atomic_load_relaxed(
  521   Printf("%s\n\n", line);
  588     Printf("\n"
  591     Printf("%s", d.Error());
  593     Printf("%s", d.Default());
  700   Printf("\n");
  702     Printf("Too many leaks! Only the first %zu leaks encountered will be "
  708     Printf("The %zu top leak(s):\n", num_leaks_to_report);
  719     Printf("Omitting %zu more leak(s).\n", remaining);
  725   Printf("%s", d.Leak());
  726   Printf("%s leak of %zu byte(s) in %zu object(s) allocated from:\n",
  729   Printf("%s", d.Default());
  734     Printf("Objects leaked above:\n");
  736     Printf("\n");
  744       Printf("%p (%zu bytes)\n", leaked_objects_[j].addr,

  192       Printf("MSAN_OPTIONS=exit_code is deprecated! "
  203     Printf(
  213     Printf(
  243     Printf(
  364     Printf("Exiting\n");
  375   Printf("Exiting\n");
  421     VPrintf(1, "Unlimited stack, doing reexec\n");
  430     VPrintf(1, "msan_track_origins\n");
  432     Printf("FATAL: MemorySanitizer can not mmap the shadow memory.\n");
  433     Printf("FATAL: Make sure to compile with -fPIE and to link with -pie.\n");
  434     Printf("FATAL: Disabling ASLR is known to cause this error.\n");
  435     Printf("FATAL: If running under GDB, try "
  457   VPrintf(1, "MemorySanitizer init done\n");
  482     Printf("Not a valid application address: %p\n", x);
  491     Printf("Not a valid application address: %p\n", x);
  497     Printf("%x%x ", s[i] >> 4, s[i] & 0xf);
  498   Printf("\n");
  522     Printf("Exiting\n");
  582       Printf("First time: idx=%d id=%d %s %p \n", idx, id, descr + 4, pc);
  585     Printf("__msan_set_alloca_origin: descr=%s id=%x\n", descr + 4, id);

   41     VPrintf(1, "%s : %p - %p\n", descr, beg, end);
   49       Printf("FATAL: Memory range %p - %p is not available.\n", beg, end);
   69       Printf("FATAL: Cannot protect memory range %p - %p (%s).\n", beg, end,
  110   VPrintf(1, "__msan_init %p\n", &__msan_init);
  112     VPrintf(1, "%s: %zx - %zx\n", kMemoryLayout[i].name, kMemoryLayout[i].start,
  118     Printf("FATAL: Code %p is out of application range. Non-PIE build?\n",

   43   Printf("%s", d.Origin());
   44   Printf(
   60   VPrintf(1, "  raw origin id: %d\n", id);
   66     Printf("  %sUninitialized value was stored to memory at%s\n", d.Origin(),
   78         Printf("  %sUninitialized value was created by a heap allocation%s\n",
   82         Printf("  %sUninitialized value was created by a heap deallocation%s\n",
   86         Printf("  %sMemory was marked as uninitialized%s\n", d.Origin(),
   90         Printf("  %sUninitialized value was created%s\n", d.Origin(),
  104   Printf("%s", d.Warning());
  106   Printf("%s", d.Default());
  117   Printf("WARNING: Expected use of uninitialized value not found\n");
  128     Printf("Unique heap origins: %zu\n", stack_depot_stats->n_uniq_ids);
  129     Printf("Stack depot allocated bytes: %zu\n", stack_depot_stats->allocated);
  132     Printf("Unique origin histories: %zu\n",
  134     Printf("History depot allocated bytes: %zu\n",
  144     Printf("%s", d.Warning());
  145     Printf("MemorySanitizer: %d warnings reported.\n", msan_report_count);
  146     Printf("%s", d.Default());
  203   Printf("%s", d.Warning());
  204   Printf("Shadow map of [%p, %p), %zu bytes:\n", start, end, end - start);
  205   Printf("%s", d.Default());
  210       Printf("%p:", s);
  214       Printf(" ");
  219       Printf("..");
  223       Printf("%x%x", v >> 4, v & 0xf);
  237         Printf("  |");
  240           Printf("%c", c);
  241           if (i != 3) Printf(" ");
  243         Printf("|");
  245       Printf("\n");
  252   Printf("\n");
  256     Printf("Origin %c (origin_id %x):\n", OriginSet::asChar(i), o);
  264   Printf("%s", d.Warning());
  265   Printf("%sUninitialized bytes in %s%s%s at offset %zu inside [%p, %zu)%s\n",

  238     Printf(
  270     Printf("Stats: SizeClassAllocator64: %zdM mapped (%zdM rss) in "
  681       Printf("%s: Out of memory. ", SanitizerToolName);
  682       Printf("The process has exhausted %zuMB for size class %zu.\n",

   27     Printf("%s", d.Error());
   30     Printf("%s", d.Default());

  176       Printf("%s: bad pointer %p\n", SanitizerToolName, p);
  256     Printf("Stats: LargeMmapAllocator: allocated %zd times, "
  263       Printf("%zd:%zd; ", i, c);
  265     Printf("\n");

  189         Printf("\n");
  196       Printf("c%02zd => s: %zd diff: +%zd %02zd%% l %zd "
  202     Printf("Total cached: %zd\n", total_cached);

  280   Printf("\nCommand: ");
  282     Printf("%s ", argv[i]);
  283   Printf("\n\n");
  331   Printf("%s\n", error_summary);

 1828     VPrintf(2, "Decoding unknown ioctl 0x%x\n", request);
 1830       Printf("WARNING: failed decoding unknown ioctl 0x%x\n", request);
 6114   VPrintf(1, "%s ignores mlock/mlockall/munlock/munlockall\n",

  487       Printf("Duplicate or unsorted ioctl request id %x >= %x (%s vs %s)\n",

   47         Printf("%s: RSS: %zdMb\n", SanitizerToolName, current_rss_mb);
   55           Printf("%s: StackDepot: %zd ids; %zdM allocated\n",
   86       Printf("\n\nHEAP PROFILE at RSS %zdMb\n", current_rss_mb);

   54   Printf("SanitizerCoverage: %s: %zd PCs written\n", file_path, len);
   76       Printf("ERROR: unknown pc 0x%x (may happen if dlclose is used)\n", pc);

  359           Printf("  %zx => %zx\n", from, to);

  125     Printf("WARNING: too long mutex cycle found\n");

   37     Printf("WARNING: found %d unrecognized flag(s):\n", n_unknown_flags_);
   39       Printf("    %s\n", unknown_flags_[i]);
   59   Printf("Available flags for %s:\n", SanitizerToolName);
   61     Printf("\t%s\n\t\t- %s\n", flags_[i].name, flags_[i].desc);
   65   Printf("%s: ERROR: %s\n", SanitizerToolName, err);
   83       Printf("%s: ERROR: expected '=' in %s\n", SanitizerToolName,
  125   VPrintf(1, "%s: %s\n", env_name, env ? env : "<empty>");
  153     Printf("Failed to read options from '%s': error %d\n", path, err);

   58   Printf("ERROR: Invalid value for bool option: '%s'\n", value);
   74   Printf("ERROR: Invalid value for signal handler option: '%s'\n", value);
   89   if (!ok) Printf("ERROR: Invalid value for int option: '%s'\n", value);
   98   if (!ok) Printf("ERROR: Invalid value for uptr option: '%s'\n", value);
  107   if (!ok) Printf("ERROR: Invalid value for s64 option: '%s'\n", value);

  840   Printf("execve failed, errno %d\n", rverrno);

  209     Printf("could not map writable file (%d, %lld, %zu): %zd, errno: %d\n",
  249     Printf("\t%p-%p\t%s\n", (void *)segment.start, (void *)segment.end,

  415         VPrintf(1, "Sanitizer: increasing stacksize %zu->%zu\n", stacksize,
  420       Printf("Sanitizer: pre-allocated stack size is insufficient: "
  422       Printf("Sanitizer: pthread_create is likely to fail.\n");

  135     Printf("Quarantine limits: global: %zdMb; thread local: %zdKb\n",
  293     Printf("Global quarantine stats: batches: %zd; bytes: %zd (user: %zd); "

   23     Printf("    <empty stack>\n\n");
   41       Printf("%s\n", frame_desc.data());
   52   Printf("\n");
   54     Printf("DEDUP_TOKEN: %s\n", dedup_token.data());

  259   Printf("Tracer caught signal %d: addr=0x%zx pc=0x%zx sp=0x%zx\n", signum,

   76   VPrintf(1, "%s: reading suppressions file at %s\n",
   83     Printf("%s: failed to read suppressions file '%s'\n", SanitizerToolName,
  140         Printf("%s: failed to parse suppressions\n", SanitizerToolName);

  113   Printf("%s", d.Warning());
  115   Printf("%s", d.Default());
  174   Printf("%s", d.Warning());
  179   Printf("%s", d.Default());
  192   Printf("%s", d.Warning());
  202   Printf("%s", d.Default());
  226   Printf("%s can not provide additional info.\n", SanitizerToolName);

  657         Printf("Scudo INFO: soft RSS limit exhausted (%zdMb vs %zdMb)\n",

  173     Printf("Stats: LargeMmapAllocator: allocated %zd times (%zd K), "

  287   VPrintf(1, "guessed data_start=%p data_end=%p\n",  g_data_start, g_data_end);

   42   Printf("==============================\n");
   43   Printf("WARNING: lock-order-inversion (potential deadlock)\n");
   45     Printf("Thread %d locks mutex %llu while holding mutex %llu:\n",
   49       Printf("Mutex %llu was acquired here:\n",
   54   Printf("==============================\n");

  105         Printf("ThreadSanitizer: %s overflow (%zu*%zu). Dying.\n",
  109       VPrintf(2, "ThreadSanitizer: growing %s: %zu out of %zu*%zu\n",

  113     Printf("ThreadSanitizer: incorrect value for history_size"
  119     Printf("ThreadSanitizer: incorrect value for io_sync"

  530   Printf("ThreadSanitizer: can't find longjmp buf\n");
  910       Printf("ThreadSanitizer: failed to set thread key\n");
  940       Printf("ThreadSanitizer: failed to set thread key\n");
  972       VPrintf(1, "ThreadSanitizer: starting new threads after multi-threaded "
 1979     VPrintf(1, "ThreadSanitizer: ignoring signal %d\n", sig);
 2782     Printf("ThreadSanitizer: failed to setup atexit callback\n");
 2788     Printf("ThreadSanitizer: failed to create thread key\n");
 2832       Printf("barrier_init: count is too large (%d)\n", count);

  194     Printf("ThreadSanitizer: Matched %d \"benign\" races (pid=%d):\n",
  197       Printf("%d %s:%d %s\n",
  203     Printf("ThreadSanitizer: Annotated %d \"benign\" races, %d unique"
  207       Printf("%d %s:%d %s\n",
  215   Printf("==================\n");
  216   Printf("WARNING: ThreadSanitizer: missed expected data race\n");
  217   Printf("  %s addr=%zx %s:%d\n",
  219   Printf("==================\n");

   39       Printf(kShadowMemoryMappingWarning, SanitizerToolName, addr, addr + size,
   41       Printf(kShadowMemoryMappingHint, "MADV_DONTDUMP", "use_madv_dontdump");
   50     Printf("FATAL: ThreadSanitizer can not mmap the shadow memory\n");
   51     Printf("FATAL: Make sure to compile with -fPIE and to link with -pie.\n");
  104     Printf("FATAL: ThreadSanitizer can not mmap the shadow memory\n");
  105     Printf("FATAL: Make sure to compile with -fPIE and to link with -pie.\n");
  121     Printf("FATAL: ThreadSanitizer can not protect [%zx,%zx]\n", beg, end);
  122     Printf("FATAL: Make sure you are not using unlimited stack\n");
  138     Printf("FATAL: ThreadSanitizer: unexpected memory mapping %p-%p\n",

  125     Printf("    [failed to restore the stack]\n\n");
  134     Printf("%s\n", res.data());
  136   Printf("\n");
  142       Printf(" (mutexes:");
  144     Printf(" %s M%llu", m.write ? "write" : "read", m.id);
  145     Printf(i == mset.Size() - 1 ? ")" : ",");
  164   Printf("%s", d.Access());
  166     Printf("  %s of size %d at %p by %s",
  173     Printf("  %s access of %s at %p by %s",
  178   Printf(":\n");
  179   Printf("%s", d.Default());
  187   Printf("%s", d.Location());
  191       Printf("  Location is global '%s' of size %zu at %p (%s+%p)\n\n",
  195       Printf("  Location is global '%s' at %p (%s+%p)\n\n", global.name,
  202       Printf("  Location is heap block of size %zu at %p allocated by %s:\n",
  206       Printf("  Location is %s of size %zu at %p allocated by %s:\n",
  212     Printf("  Location is stack of %s.\n\n", thread_name(thrbuf, loc->tid));
  214     Printf("  Location is TLS of %s.\n\n", thread_name(thrbuf, loc->tid));
  216     Printf("  Location is file descriptor %d created by %s at:\n",
  220   Printf("%s", d.Default());
  227   Printf("%sM%zd%s%s", d.Mutex(), rm->id, d.Default(), after);
  233   Printf("%sM%zd (%p)%s%s", d.Mutex(), rm->id, rm->addr, d.Default(), after);
  239     Printf("%s", d.Mutex());
  240     Printf("  Mutex M%llu is already destroyed.\n\n", rm->id);
  241     Printf("%s", d.Default());
  243     Printf("%s", d.Mutex());
  244     Printf("  Mutex M%llu (%p) created at:\n", rm->id, rm->addr);
  245     Printf("%s", d.Default());
  254   Printf("%s", d.ThreadDescription());
  255   Printf("  Thread T%d", rt->id);
  257     Printf(" '%s'", rt->name);
  261     Printf(" (tid=%zu, %s) is a GCD worker thread\n", rt->os_id, thread_status);
  262     Printf("\n");
  263     Printf("%s", d.Default());
  266   Printf(" (tid=%zu, %s) created by %s", rt->os_id, thread_status,
  269     Printf(" at:");
  270   Printf("\n");
  271   Printf("%s", d.Default());
  277   Printf("%s", d.Sleep());
  278   Printf("  As if synchronized via sleep:\n");
  279   Printf("%s", d.Default());
  318   Printf("==================\n");
  320   Printf("%s", d.Warning());
  321   Printf("WARNING: ThreadSanitizer: %s (pid=%d)\n", rep_typ_str,
  323   Printf("%s", d.Default());
  327     Printf("  Cycle in lock order graph: ");
  335       Printf("  Mutex ");
  339       Printf("%s", d.ThreadDescription());
  340       Printf("%s:\n", thread_name(thrbuf, rep->unique_tids[i]));
  341       Printf("%s", d.Default());
  344         Printf("  Mutex ");
  351           Printf("    Hint: use TSAN_OPTIONS=second_deadlock_stack=1 "
  358         Printf("  and:\n");
  381     Printf("  And %d more similar thread leaks.\n\n", rep->count - 1);
  390   Printf("==================\n");

  167         Printf("ThreadSanitizer: failed to open memory profile file '%s'\n",
  186         VPrintf(1, "ThreadSanitizer: periodic memory flush\n");
  195       VPrintf(1, "ThreadSanitizer: memory flush check"
  199         VPrintf(1, "ThreadSanitizer: flushing memory due to RSS\n");
  202         VPrintf(1, "ThreadSanitizer: memory flushed RSS=%llu\n", (u64)rss>>20);
  286   VPrintf(2, "mapped meta shadow for (%p-%p) at (%p-%p)\n",
  296     Printf("FATAL: ThreadSanitizer can not mmap thread trace (%p/%p)\n",
  309     VPrintf(3, "checking shadow region %p-%p\n", beg, end);
  318         VPrintf(3, "  checking pointer %p: shadow=%p meta=%p\n", p, s, m);
  401   VPrintf(1, "***** Running under ThreadSanitizer v2 (pid %d) *****\n",
  418     Printf("ThreadSanitizer is suspended at startup (pid %d)."
  464     Printf("ThreadSanitizer: reported %d warnings\n", ctx->nreported);
  472     Printf("ThreadSanitizer: missed %d expected races\n",
  510   VPrintf(1, "ThreadSanitizer: forked new process with pid %d,"

   44   Printf("FATAL: ThreadSanitizer CHECK failed: "
  455           VPrintf(2,
  468           VPrintf(2, "ThreadSanitizer: suppressing report as doubled (addr)\n");

  180     Printf("ThreadSanitizer: main thread finished with ignores enabled\n");
  182     Printf("ThreadSanitizer: thread T%d %s finished with ignores enabled,"
  186   Printf("  One of the following ignores was not ended"
  189     Printf("  Ignore was enabled at:\n");

   99     VPrintf(2, "ThreadSanitizer: matched suppression '%s'\n", (*sp)->templ);
  137       VPrintf(2, "ThreadSanitizer: matched suppression '%s'\n", s->templ);
  154   Printf("ThreadSanitizer: Matched %d suppressions (pid=%d):\n", hit_count,
  157     Printf("%d %s:%s\n", atomic_load_relaxed(&matched[i]->hit_count),

  276     Printf("<memory cannot be printed>\n");
  332   Printf("%s", Buffer.data());
  376   Printf("%s", Buffer.data());