[asan] Ensure that the minimum redzone is at least SHADOW_GRANULARITY

[waltl]

Summary

This is required by the Asan run-time.

[vitalybuka]

compiler-rt/lib/asan/asan_activation.cc

117 ↗

(On Diff #121051)

disabled.max_redzone = disabled.min_redzone

compiler-rt/lib/asan/asan_flags.cc

73 ↗

(On Diff #121051)

This should be around line 147, // Flag validation:

[waltl]

Address CR comments

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

 //
 // ASan activation/deactivation logic.
 //===----------------------------------------------------------------------===//
 
 #include "asan_activation.h"
 #include "asan_allocator.h"
 #include "asan_flags.h"
 #include "asan_internal.h"
+#include "asan_mapping.h"
 #include "asan_poisoning.h"
 #include "asan_stack.h"
+#include "sanitizer_common/sanitizer_common.h"
 #include "sanitizer_common/sanitizer_flags.h"
 
 namespace __asan {
 
 static struct AsanDeactivatedFlags {
   AllocatorOptions allocator_options;
   int malloc_context_size;
   bool poison_heap;
void AsanDeactivate() {
 
   // Deactivate the runtime.
   SetCanPoisonMemory(false);
   SetMallocContextSize(1);
 
   AllocatorOptions disabled = asan_deactivated_flags.allocator_options;
   disabled.quarantine_size_mb = 0;
   disabled.thread_local_quarantine_size_kb = 0;
-  disabled.min_redzone = 16;  // Redzone must be at least 16 bytes long.
-  disabled.max_redzone = 16;
+  // Redzone must be at least Max(16, granularity) bytes long.
+  disabled.min_redzone = Max(16, (int)SHADOW_GRANULARITY);
+  disabled.max_redzone = disabled.min_redzone;
   disabled.alloc_dealloc_mismatch = false;
   disabled.may_return_null = true;
   ReInitializeAllocator(disabled);
 
   asan_is_deactivated = true;
 }
 
 void AsanActivate() {

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

#endif
   }
 
   // Flag validation:
   if (!CAN_SANITIZE_LEAKS && common_flags()->detect_leaks) {
     Report("%s: detect_leaks is not supported on this platform.\n",
            SanitizerToolName);
     Die();
   }
+  // Ensure that redzone is at least SHADOW_GRANULARITY.
+  if (f->redzone < (int)SHADOW_GRANULARITY)
+    f->redzone = SHADOW_GRANULARITY;
   // Make "strict_init_order" imply "check_initialization_order".
   // TODO(samsonov): Use a single runtime flag for an init-order checker.
   if (f->strict_init_order) {
     f->check_initialization_order = true;
   }
   CHECK_LE((uptr)common_flags()->malloc_context_size, kStackTraceMax);
   CHECK_LE(f->min_uar_stack_size_log, f->max_uar_stack_size_log);
   CHECK_GE(f->redzone, 16);