[tsan] Separate the constants in libignore and bump the maximum for instrumented libraries

[kubamracek]

Summary

We're having some use cases where we have more than 128 (the current maximum) instrumented dynamic libraries loaded into a single process. Let's bump the limit to 1024, and separate the constants.

[dvyukov]

LGTM with a nit

lib/sanitizer_common/sanitizer_libignore.cc

83

Probably better to switch to ARRAY_SIZE(ignored_code_ranges_) at this point.

112

Ditto.

lib/sanitizer_common/sanitizer_libignore.h

struct LibCodeRange {
     uptr begin;
     uptr end;
   };
 
   inline bool IsInRange(uptr pc, const LibCodeRange &range) const {
     return (pc >= range.begin && pc < range.end);
   }
 
-  static const uptr kMaxLibs = 128;
+  static const uptr kMaxIgnoredRanges = 128;
+  static const uptr kMaxInstrumentedRanges = 1024;
+  static const uptr kMaxLibs = 1024;
 
   // Hot part:
   atomic_uintptr_t ignored_ranges_count_;
-  LibCodeRange ignored_code_ranges_[kMaxLibs];
+  LibCodeRange ignored_code_ranges_[kMaxIgnoredRanges];
 
   atomic_uintptr_t instrumented_ranges_count_;
-  LibCodeRange instrumented_code_ranges_[kMaxLibs];
+  LibCodeRange instrumented_code_ranges_[kMaxInstrumentedRanges];
 
   // Cold part:
   BlockingMutex mutex_;
   uptr count_;
   Lib libs_[kMaxLibs];
   bool track_instrumented_libs_;
 
   // Disallow copying of LibIgnore objects.

lib/sanitizer_common/sanitizer_libignore.cc

for (const auto &mod : modules) {
         VReport(1,
                 "Matched called_from_lib suppression '%s' against library"
                 " '%s'\n",
                 lib->templ, mod.full_name());
         lib->loaded = true;
         lib->name = internal_strdup(mod.full_name());
         const uptr idx =
             atomic_load(&ignored_ranges_count_, memory_order_relaxed);
-        CHECK_LT(idx, kMaxLibs);
+        CHECK_LT(idx, kMaxIgnoredRanges);
         ignored_code_ranges_[idx].begin = range.beg;
         ignored_code_ranges_[idx].end = range.end;
         atomic_store(&ignored_ranges_count_, idx + 1, memory_order_release);
         break;
       }
     }
     if (lib->loaded && !loaded) {
       Report("%s: library '%s' that was matched against called_from_lib"
for (const auto &mod : modules) {
         if (!range.executable)
           continue;
         if (IsPcInstrumented(range.beg) && IsPcInstrumented(range.end - 1))
           continue;
         VReport(1, "Adding instrumented range %p-%p from library '%s'\n",
                 range.beg, range.end, mod.full_name());
         const uptr idx =
             atomic_load(&instrumented_ranges_count_, memory_order_relaxed);
-        CHECK_LT(idx, kMaxLibs);
+        CHECK_LT(idx, kMaxInstrumentedRanges);
         instrumented_code_ranges_[idx].begin = range.beg;
         instrumented_code_ranges_[idx].end = range.end;
         atomic_store(&instrumented_ranges_count_, idx + 1,
                      memory_order_release);
       }
     }
   }
 }