[libarcher] Place classes in anonymous namespace

[nikic]

Summary

Place various classes/structs into anonymous namespaces and mark variables as static. As far as I understand, these are all implementation details and not intended to be exported -- only a small number of tsan hooks are supposed to be.

[protze.joachim]

lgtm

openmp/tools/archer/ompt-tsan.cpp

 #define KMP_FALLTHROUGH() __attribute__((__fallthrough__))
 #else
 #define KMP_FALLTHROUGH() ((void)0)
 #endif
 
 static int runOnTsan;
 static int hasReductionCallback;
 
+namespace {
 class ArcherFlags {
 public:
 #if (LLVM_VERSION) >= 40
   int flush_shadow{0};
 #endif
   int print_max_rss{0};
   int verbose{0};
   int enabled{1};
if (env) {
         // warning
         if (sscanf(token.c_str(), "ignore_noninstrumented_modules=%d",
                    &ignore_noninstrumented_modules))
           continue;
       }
     }
   }
 };
+} // namespace
 
 #if (LLVM_VERSION) >= 40
 extern "C" {
 int __attribute__((weak)) __archer_get_omp_status();
 void __attribute__((weak)) __tsan_flush_memory() {}
 }
 #endif
-ArcherFlags *archer_flags;
+static ArcherFlags *archer_flags;
 
 #ifndef TsanHappensBefore
 // Thread Sanitizer is a tool that finds races in code.
 // See http://code.google.com/p/data-race-test/wiki/DynamicAnnotations .
 // tsan detects these exact functions by name.
 extern "C" {
 #if (defined __APPLE__ && defined __MACH__)
 static void (*AnnotateHappensAfter)(const char *, int, const volatile void *);
static uint64_t my_next_id() {
   uint64_t ret = __sync_fetch_and_add(&ID, 1);
   return ret;
 }
 
 static int pagesize{0};
 
 // Data structure to provide a threadsafe pool of reusable objects.
 // DataPool<Type of objects>
+namespace {
 template <typename T> struct DataPool final {
   static __thread DataPool<T> *ThreadDataPool;
   std::mutex DPMutex{};
 
   // store unused objects
   std::vector<T *> DataPointer{};
   std::vector<T *> RemoteDataPointer{};
 
#endif
   }
 
   static TaskData *New(ParallelData *team, int taskType) {
     return DataPoolEntry<TaskData>::New()->Init(team, taskType);
   }
 
   TaskData(DataPool<TaskData> *dp) : DataPoolEntry<TaskData>(dp) {}
 };
+} // namespace
 
 static inline TaskData *ToTaskData(ompt_data_t *task_data) {
   return reinterpret_cast<TaskData *>(task_data->ptr);
 }
 
 /// Store a mutex for each wait_id to resolve race condition with callbacks.
-std::unordered_map<ompt_wait_id_t, std::mutex> Locks;
-std::mutex LocksMutex;
+static std::unordered_map<ompt_wait_id_t, std::mutex> Locks;
+static std::mutex LocksMutex;
 
 static void ompt_tsan_thread_begin(ompt_thread_t thread_type,
                                    ompt_data_t *thread_data) {
   ParallelDataPool::ThreadDataPool = new ParallelDataPool;
   TsanNewMemory(ParallelDataPool::ThreadDataPool,
                 sizeof(ParallelDataPool::ThreadDataPool));
   TaskgroupPool::ThreadDataPool = new TaskgroupPool;
   TsanNewMemory(TaskgroupPool::ThreadDataPool,