[sanitizers] Avoid macro clash in SignalContext::WriteFlag (NFC)

[nikic]

Summary

D116208 may cause a macro clash on older versions of linux, where fs.h defines a READ macro. I'm resolving this by switching to a more typical casing style for non-macro symbols. If preferred, I can prefix them instead.

[vitalybuka]

compiler-rt/lib/sanitizer_common/sanitizer_common.h

962

I guess we use WRITE_FLAG_UNKNOWN style for C-enums.
However proposed names seems consistent with "enum class".

compiler-rt/lib/asan/asan_errors.h

if (signal.IsStackOverflow()) {
       scariness.Scare(10, "stack-overflow");
     } else if (!signal.is_memory_access) {
       scariness.Scare(10, "signal");
     } else if (signal.is_true_faulting_addr &&
                signal.addr < GetPageSizeCached()) {
       scariness.Scare(10, "null-deref");
     } else if (signal.addr == signal.pc) {
       scariness.Scare(60, "wild-jump");
-    } else if (signal.write_flag == SignalContext::WRITE) {
+    } else if (signal.write_flag == SignalContext::Write) {
       scariness.Scare(30, "wild-addr-write");
-    } else if (signal.write_flag == SignalContext::READ) {
+    } else if (signal.write_flag == SignalContext::Read) {
       scariness.Scare(20, "wild-addr-read");
     } else {
       scariness.Scare(25, "wild-addr");
     }
   }
   void Print();
 };
 

compiler-rt/lib/sanitizer_common/sanitizer_common.h

 struct SignalContext {
   void *siginfo;
   void *context;
   uptr addr;
   uptr pc;
   uptr sp;
   uptr bp;
   bool is_memory_access;
-  enum WriteFlag { UNKNOWN, READ, WRITE } write_flag;
+  enum WriteFlag { Unknown, Read, Write } write_flag;
 
   // In some cases the kernel cannot provide the true faulting address; `addr`
   // will be zero then.  This field allows to distinguish between these cases
   // and dereferences of null.
   bool is_true_faulting_addr;
 
   // VS2013 doesn't implement unrestricted unions, so we need a trivial default
   // constructor

compiler-rt/lib/sanitizer_common/sanitizer_linux.cpp

 #elif SANITIZER_NETBSD
   uptr err = ucontext->uc_mcontext.__gregs[_REG_ERR];
 #elif SANITIZER_SOLARIS && defined(__i386__)
   const int Err = 13;
   uptr err = ucontext->uc_mcontext.gregs[Err];
 #else
   uptr err = ucontext->uc_mcontext.gregs[REG_ERR];
 #endif // SANITIZER_FREEBSD
-  return err & PF_WRITE ? WRITE : READ;
+  return err & PF_WRITE ? Write : Read;
 #elif defined(__mips__)
   uint32_t *exception_source;
   uint32_t faulty_instruction;
   uint32_t op_code;
 
   exception_source = (uint32_t *)ucontext->uc_mcontext.pc;
   faulty_instruction = (uint32_t)(*exception_source);
 

compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_report.cpp

else
     Report("ERROR: %s: %s on unknown address %p (pc %p bp %p sp %p T%d)\n",
            SanitizerToolName, description, (void *)sig.addr, (void *)sig.pc,
            (void *)sig.bp, (void *)sig.sp, tid);
   Printf("%s", d.Default());
   if (sig.pc < GetPageSizeCached())
     Report("Hint: pc points to the zero page.\n");
   if (sig.is_memory_access) {
     const char *access_type =
-        sig.write_flag == SignalContext::WRITE
+        sig.write_flag == SignalContext::Write
             ? "WRITE"
-            : (sig.write_flag == SignalContext::READ ? "READ" : "UNKNOWN");
+            : (sig.write_flag == SignalContext::Read ? "READ" : "UNKNOWN");
     Report("The signal is caused by a %s memory access.\n", access_type);
     if (!sig.is_true_faulting_addr)
       Report("Hint: this fault was caused by a dereference of a high value "
              "address (see register values below).  Disassemble the provided "
              "pc to learn which register was used.\n");
     else if (sig.addr < GetPageSizeCached())
       Report("Hint: address points to the zero page.\n");
   }