[ASan] Make asan report decoration more efficient

[amontanez]

Summary

ASan's report decoration doesn't maintain any state regarding terminal color output. When printing shadow bytes, one printed byte involves two color changes, even if subsequent bytes are the same color. This patch ensures a decorator only changes the terminal output color when printing a byte of a different color. This significantly reduces the number of characters in the output when printing shadow bytes without changing how the output looks.

[vitalybuka]

No tests need update?

[vitalybuka]

compiler-rt/lib/asan/asan_descriptions.h

48

what was changed here?
Did you use arc tool?

60

lets keep same name

const char *Default() {
  last_byte = 0;
  return __sanitizer::SanitizerCommonDecorator::Default();
}

122

u8 last_byte = 0;

122

maybe instead of last byte just track "const char * last_decoration"?

[amontanez]

• Fixed diff issues.
• Tracking last decoration as opposed to last byte.
• Changed Reset() to be Default().

[amontanez]

In D54733#1303660, @vitalybuka wrote:

No tests need update?

I don't think text decoration was tested in any way. Adding an integration test would be reasonable, I'll look into that.

[vitalybuka]

Removing from my "Ready To Review" list assuming you are working on test.

compiler-rt/lib/asan/asan_descriptions.h

  private:
   void Init(u32 tid, const char *tname);
 
   char name[128];
 };
 
 class Decorator : public __sanitizer::SanitizerCommonDecorator {
  public:
-  Decorator() : SanitizerCommonDecorator() {}
+  Decorator() : SanitizerCommonDecorator() {
+    last_decoration = __sanitizer::SanitizerCommonDecorator::Default();
+  }
+
+  const char *Default() {
+    last_decoration = __sanitizer::SanitizerCommonDecorator::Default();
+    return last_decoration;
+  }
+
   const char *Access() { return Blue(); }
   const char *Location() { return Green(); }
   const char *Allocation() { return Magenta(); }
 
   const char *ShadowByte(u8 byte) {
+    const char *new_decoration;
     switch (byte) {
       case kAsanHeapLeftRedzoneMagic:
       case kAsanArrayCookieMagic:
-        return Red();
+        new_decoration = Red();
+        break;
       case kAsanHeapFreeMagic:
-        return Magenta();
+        new_decoration = Magenta();
+        break;
       case kAsanStackLeftRedzoneMagic:
       case kAsanStackMidRedzoneMagic:
       case kAsanStackRightRedzoneMagic:
-        return Red();
+        new_decoration = Red();
+        break;
       case kAsanStackAfterReturnMagic:
-        return Magenta();
+        new_decoration = Magenta();
+        break;
       case kAsanInitializationOrderMagic:
-        return Cyan();
+        new_decoration = Cyan();
+        break;
       case kAsanUserPoisonedMemoryMagic:
       case kAsanContiguousContainerOOBMagic:
       case kAsanAllocaLeftMagic:
       case kAsanAllocaRightMagic:
-        return Blue();
+        new_decoration = Blue();
+        break;
       case kAsanStackUseAfterScopeMagic:
-        return Magenta();
+        new_decoration = Magenta();
+        break;
       case kAsanGlobalRedzoneMagic:
-        return Red();
+        new_decoration = Red();
+        break;
       case kAsanInternalHeapMagic:
-        return Yellow();
+        new_decoration = Yellow();
+        break;
       case kAsanIntraObjectRedzone:
-        return Yellow();
+        new_decoration = Yellow();
+        break;
       default:
-        return Default();
+        new_decoration = Default();
     }
+
+    // Optimization: Don't return a decoration if it hasn't changed.
+    if (last_decoration == new_decoration)
+      return "";
+
+    last_decoration = new_decoration;
+    return new_decoration;
   }
+
+ private:
+  const char *last_decoration;
 };
 
 enum ShadowKind : u8 {
   kShadowKindLow,
   kShadowKindGap,
   kShadowKindHigh,
 };
 static const char *const ShadowNames[] = {"low shadow", "shadow gap",
                                           "high shadow"};
 
 struct ShadowAddressDescription {
   uptr addr;
   ShadowKind kind;
   u8 shadow_byte;
 
   void Print() const;
 };
 
 bool GetShadowAddressInformation(uptr addr, ShadowAddressDescription *descr);

compiler-rt/lib/asan/asan_descriptions.cc

case kAccessTypeInside:
       str.append("%p is located %zd bytes inside of", (void *)descr.bad_addr,
                  descr.offset);
       break;
     case kAccessTypeUnknown:
       str.append(
           "%p is located somewhere around (this is AddressSanitizer bug!)",
           (void *)descr.bad_addr);
   }
-  str.append(" %zu-byte region [%p,%p)\n", descr.chunk_size,
+  str.append(" %zu-byte region [%p,%p)%s\n", descr.chunk_size,
              (void *)descr.chunk_begin,
-             (void *)(descr.chunk_begin + descr.chunk_size));
-  str.append("%s", d.Default());
+             (void *)(descr.chunk_begin + descr.chunk_size),
+             d.Default());
   Printf("%s", str.data());
 }
 
 bool GetHeapAddressInformation(uptr addr, uptr access_size,
                                HeapAddressDescription *descr) {
   AsanChunkView chunk = FindHeapChunkByAddress(addr);
   if (!chunk.IsValid()) {
     return false;

compiler-rt/lib/asan/asan_errors.cc

 static void PrintContainerOverflowHint() {
   Printf("HINT: if you don't care about these errors you may set "
          "ASAN_OPTIONS=detect_container_overflow=0.\n"
          "If you suspect a false positive see also: "
          "https://github.com/google/sanitizers/wiki/"
          "AddressSanitizerContainerOverflow.\n");
 }
 
-static void PrintShadowByte(InternalScopedString *str, const char *before,
-    u8 byte, const char *after = "\n") {
-  PrintMemoryByte(str, before, byte, /*in_shadow*/true, after);
+static void PrintShadowByte(InternalScopedString *str, Decorator *d,
+    const char *before, u8 byte, const char *after = "\n") {
+  PrintMemoryByte(str, d, before, byte, after);
+}
+
+static void PrintLegendEntry(InternalScopedString *str, Decorator *d,
+                             const char *text, u8 byte) {
+  PrintShadowByte(str, d, text, byte, "");
+  str->append(d->Default());
+  str->append("\n");
 }
 
 static void PrintLegend(InternalScopedString *str) {
+  Decorator d;
   str->append(
       "Shadow byte legend (one shadow byte represents %d "
       "application bytes):\n",
       (int)SHADOW_GRANULARITY);
-  PrintShadowByte(str, "  Addressable:           ", 0);
+  PrintShadowByte(str, &d, "  Addressable:           ", 0);
   str->append("  Partially addressable: ");
-  for (u8 i = 1; i < SHADOW_GRANULARITY; i++) PrintShadowByte(str, "", i, " ");
+  for (u8 i = 1; i < SHADOW_GRANULARITY; i++)
+    PrintShadowByte(str, &d, "", i, " ");
   str->append("\n");
-  PrintShadowByte(str, "  Heap left redzone:       ",
+  str->append("\n");
+  PrintLegendEntry(str, &d, "  Heap left redzone:       ",
                    kAsanHeapLeftRedzoneMagic);
-  PrintShadowByte(str, "  Freed heap region:       ", kAsanHeapFreeMagic);
-  PrintShadowByte(str, "  Stack left redzone:      ",
+  PrintLegendEntry(str, &d, "  Freed heap region:       ",
+                   kAsanHeapFreeMagic);
+  PrintLegendEntry(str, &d, "  Stack left redzone:      ",
                    kAsanStackLeftRedzoneMagic);
-  PrintShadowByte(str, "  Stack mid redzone:       ",
+  PrintLegendEntry(str, &d, "  Stack mid redzone:       ",
                    kAsanStackMidRedzoneMagic);
-  PrintShadowByte(str, "  Stack right redzone:     ",
+  PrintLegendEntry(str, &d, "  Stack right redzone:     ",
                    kAsanStackRightRedzoneMagic);
-  PrintShadowByte(str, "  Stack after return:      ",
+  PrintLegendEntry(str, &d, "  Stack after return:      ",
                    kAsanStackAfterReturnMagic);
-  PrintShadowByte(str, "  Stack use after scope:   ",
+  PrintLegendEntry(str, &d, "  Stack use after scope:   ",
                    kAsanStackUseAfterScopeMagic);
-  PrintShadowByte(str, "  Global redzone:          ", kAsanGlobalRedzoneMagic);
-  PrintShadowByte(str, "  Global init order:       ",
+  PrintLegendEntry(str, &d, "  Global redzone:          ",
+                   kAsanGlobalRedzoneMagic);
+  PrintLegendEntry(str, &d, "  Global init order:       ",
                    kAsanInitializationOrderMagic);
-  PrintShadowByte(str, "  Poisoned by user:        ",
+  PrintLegendEntry(str, &d, "  Poisoned by user:        ",
                    kAsanUserPoisonedMemoryMagic);
-  PrintShadowByte(str, "  Container overflow:      ",
+  PrintLegendEntry(str, &d, "  Container overflow:      ",
                    kAsanContiguousContainerOOBMagic);
-  PrintShadowByte(str, "  Array cookie:            ",
+  PrintLegendEntry(str, &d, "  Array cookie:            ",
                    kAsanArrayCookieMagic);
-  PrintShadowByte(str, "  Intra object redzone:    ",
+  PrintLegendEntry(str, &d, "  Intra object redzone:    ",
                    kAsanIntraObjectRedzone);
-  PrintShadowByte(str, "  ASan internal:           ", kAsanInternalHeapMagic);
-  PrintShadowByte(str, "  Left alloca redzone:     ", kAsanAllocaLeftMagic);
-  PrintShadowByte(str, "  Right alloca redzone:    ", kAsanAllocaRightMagic);
-  PrintShadowByte(str, "  Shadow gap:              ", kAsanShadowGap);
+  PrintLegendEntry(str, &d, "  ASan internal:           ",
+                   kAsanInternalHeapMagic);
+  PrintLegendEntry(str, &d, "  Left alloca redzone:     ",
+                   kAsanAllocaLeftMagic);
+  PrintLegendEntry(str, &d, "  Right alloca redzone:    ",
+                   kAsanAllocaRightMagic);
+  PrintLegendEntry(str, &d, "  Shadow gap:              ",
+                   kAsanShadowGap);
 }
 
-static void PrintShadowBytes(InternalScopedString *str, const char *before,
-                             u8 *bytes, u8 *guilty, uptr n) {
-  Decorator d;
+static void PrintShadowBytes(InternalScopedString *str, Decorator *d,
+    const char *before, u8 *bytes, u8 *guilty, uptr n) {
   if (before) str->append("%s%p:", before, bytes);
   for (uptr i = 0; i < n; i++) {
     u8 *p = bytes + i;
-    const char *before =
-        p == guilty ? "[" : (p - 1 == guilty && i != 0) ? "" : " ";
-    const char *after = p == guilty ? "]" : "";
-    PrintShadowByte(str, before, *p, after);
+    const char *before;
+    const char *after;
+    if (p == guilty) {
+      str->append(d->Default());
+      before = "[";
+      PrintShadowByte(str, d, before, *p, "");
+      str->append(d->Default());
+      str->append("]");
+    } else {
+      before = (p - 1 == guilty && i != 0) ? "" : " ";
+      after = "";
+     PrintShadowByte(str, d, before, *p, after);
     }
+  }
+
+  str->append(d->Default());
   str->append("\n");
 }
 
-static void PrintShadowMemoryForAddress(uptr addr) {
+static void PrintShadowMemoryForAddress(uptr addr, Decorator *d) {
   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);
   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) ? "=>" : "  ";
-    PrintShadowBytes(&str, prefix, (u8 *)row_shadow_addr, (u8 *)shadow_addr,
+    PrintShadowBytes(&str, d, prefix, (u8 *)row_shadow_addr, (u8 *)shadow_addr,
                      n_bytes_per_row);
   }
   if (flags()->print_legend) PrintLegend(&str);
   Printf("%s", str.data());
 }
 
 void ErrorGeneric::Print() {
   Decorator d;
   Printf("%s", d.Error());
   uptr addr = addr_description.Address();
-  Report("ERROR: AddressSanitizer: %s on address %p at pc %p bp %p sp %p\n",
-         bug_descr, (void *)addr, pc, bp, sp);
+  Report("ERROR: AddressSanitizer: %s on address %p at pc %p bp %p sp %p%s\n",
+         bug_descr, (void *)addr, pc, bp, sp, d.Default());
   Printf("%s", d.Default());
 
   Printf("%s%s of size %zu at %p thread %s%s\n", d.Access(),
          access_size ? (is_write ? "WRITE" : "READ") : "ACCESS", access_size,
          (void *)addr, AsanThreadIdAndName(tid).c_str(), d.Default());
 
   scariness.Print();
   GET_STACK_TRACE_FATAL(pc, bp);
   stack.Print();
 
   // Pass bug_descr because we have a special case for
   // initialization-order-fiasco
   addr_description.Print(bug_descr);
   if (shadow_val == kAsanContiguousContainerOOBMagic)
     PrintContainerOverflowHint();
   ReportErrorSummary(bug_descr, &stack);
-  PrintShadowMemoryForAddress(addr);
+  PrintShadowMemoryForAddress(addr, &d);
 }
 
 }  // namespace __asan

compiler-rt/lib/asan/asan_report.h

 //
 // ASan-private header for error reporting functions.
 //===----------------------------------------------------------------------===//
 
 #ifndef ASAN_REPORT_H
 #define ASAN_REPORT_H
 
 #include "asan_allocator.h"
+#include "asan_descriptions.h"
 #include "asan_internal.h"
 #include "asan_thread.h"
 
 namespace __asan {
 
 struct StackVarDescr {
   uptr beg;
   uptr size;
   const char *name_pos;
   uptr name_len;
   uptr line;
 };
 
 // Returns the number of globals close to the provided address and copies
 // them to "globals" array.
 int GetGlobalsForAddress(uptr addr, __asan_global *globals, u32 *reg_sites,
                          int max_globals);
 
 const char *MaybeDemangleGlobalName(const char *name);
 void PrintGlobalNameIfASCII(InternalScopedString *str, const __asan_global &g);
 void PrintGlobalLocation(InternalScopedString *str, const __asan_global &g);
 
-void PrintMemoryByte(InternalScopedString *str, const char *before, u8 byte,
-                     bool in_shadow, const char *after = "\n");
+void PrintMemoryByte(InternalScopedString *str, Decorator *d,
+                     const char *before, u8 byte, const char *after);
 
 // The following functions prints address description depending
 // on the memory type (shadow/heap/stack/global).
 bool ParseFrameDescription(const char *frame_descr,
                            InternalMmapVector<StackVarDescr> *vars);
 
 // Different kinds of error reports.
 void ReportGenericError(uptr pc, uptr bp, uptr sp, uptr addr, bool is_write,

compiler-rt/lib/asan/asan_report.cc

internal_strncpy(error_message_buffer + error_message_buffer_pos,
                    buffer, remaining);
   error_message_buffer[kErrorMessageBufferSize - 1] = '\0';
   // FIXME: reallocate the buffer instead of truncating the message.
   error_message_buffer_pos += Min(remaining, length);
 }
 
 // ---------------------- Helper functions ----------------------- {{{1
 
-void PrintMemoryByte(InternalScopedString *str, const char *before, u8 byte,
-                     bool in_shadow, const char *after) {
-  Decorator d;
-  str->append("%s%s%x%x%s%s", before,
-              in_shadow ? d.ShadowByte(byte) : d.MemoryByte(), byte >> 4,
-              byte & 15, d.Default(), after);
+void PrintMemoryByte(InternalScopedString *str, Decorator *d,
+                     const char *before, u8 byte, const char *after) {
+  str->append("%s%s%x%x%s", before, d->ShadowByte(byte), byte >> 4, byte & 15,
+              after);
 }
 
 static void PrintZoneForPointer(uptr ptr, uptr zone_ptr,
                                 const char *zone_name) {
   if (zone_ptr) {
     if (zone_name) {
       Printf("malloc_zone_from_ptr(%p) = %p, which is %s\n",
                  ptr, zone_ptr, zone_name);

compiler-rt/lib/sanitizer_common/sanitizer_report_decorator.h

 
 namespace __sanitizer {
 class SanitizerCommonDecorator {
   // FIXME: This is not portable. It assumes the special strings are printed to
   // stdout, which is not the case on Windows (see SetConsoleTextAttribute()).
  public:
   SanitizerCommonDecorator() : ansi_(ColorizeReports()) {}
   const char *Bold() const { return ansi_ ? "\033[1m" : ""; }
-  const char *Default() const { return ansi_ ? "\033[1m\033[0m"  : ""; }
+  const char *Default() const { return ansi_ ? "\033[0m"  : ""; }
   const char *Warning() const { return Red(); }
   const char *Error() const { return Red(); }
   const char *MemoryByte() const { return Magenta(); }
 
  protected:
   const char *Black()   const { return ansi_ ? "\033[1m\033[30m" : ""; }
   const char *Red()     const { return ansi_ ? "\033[1m\033[31m" : ""; }
   const char *Green()   const { return ansi_ ? "\033[1m\033[32m" : ""; }