Update comment and TU-local function style

Author: davidtrevelyan

compiler-rt/lib/radsan/radsan.h

@@ -14,37 +14,27 @@
 
 extern "C" {
 
-/**  Initialise radsan interceptors.
-
-  A call to this method is added to the preinit array on Linux systems.
-*/
+// Initialise radsan interceptors.
+// A call to this method is added to the preinit array on Linux systems.
 SANITIZER_INTERFACE_ATTRIBUTE void __radsan_init();
 
-/** Enter real-time context.
-
-  When in a real-time context, RADSan interceptors will error if realtime
-  violations are detected. Calls to this method are injected at the code
-  generation stage when RADSan is enabled.
-*/
+// Enter real-time context.
+// When in a real-time context, RADSan interceptors will error if realtime
+// violations are detected. Calls to this method are injected at the code
+// generation stage when RADSan is enabled.
 SANITIZER_INTERFACE_ATTRIBUTE void __radsan_realtime_enter();
 
-/** Exit the real-time context.
-
-  When not in a real-time context, RADSan interceptors will simply forward
-  intercepted method calls to the real methods.
-*/
+// Exit the real-time context.
+// When not in a real-time context, RADSan interceptors will simply forward
+// intercepted method calls to the real methods.
 SANITIZER_INTERFACE_ATTRIBUTE void __radsan_realtime_exit();
 
-/** Disable all RADSan error reporting.
-
-  Injected into the code if "nosanitize(realtime)" is on a function.
-*/
+// Disable all RADSan error reporting.
+// Injected into the code if "nosanitize(realtime)" is on a function.
 SANITIZER_INTERFACE_ATTRIBUTE void __radsan_off();
 
-/** Re-enable all RADSan error reporting.
-
-  The counterpart to `__radsan_off`.
-*/
+// Re-enable all RADSan error reporting.
+// The counterpart to `__radsan_off`.
 SANITIZER_INTERFACE_ATTRIBUTE void __radsan_on();
 
 } // extern "C"

compiler-rt/lib/radsan/radsan_context.cpp

@@ -20,29 +20,24 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-using namespace __sanitizer;
-
-namespace detail {
-
-static pthread_key_t key;
+static pthread_key_t context_key;
 static pthread_once_t key_once = PTHREAD_ONCE_INIT;
-void internalFree(void *ptr) { __sanitizer::InternalFree(ptr); }
 
-using __radsan::Context;
+static void internalFree(void *ptr) { __sanitizer::InternalFree(ptr); }
 
-Context &GetContextForThisThreadImpl() {
-  auto make_tls_key = []() {
-    CHECK_EQ(pthread_key_create(&detail::key, detail::internalFree), 0);
+static __radsan::Context &GetContextForThisThreadImpl() {
+  auto make_thread_local_context_key = []() {
+    CHECK_EQ(pthread_key_create(&context_key, internalFree), 0);
   };
 
-  pthread_once(&detail::key_once, make_tls_key);
-  Context *current_thread_context =
-      static_cast<Context *>(pthread_getspecific(detail::key));
+  pthread_once(&key_once, make_thread_local_context_key);
+  __radsan::Context *current_thread_context =
+      static_cast<__radsan::Context *>(pthread_getspecific(context_key));
   if (current_thread_context == nullptr) {
-    current_thread_context =
-        static_cast<Context *>(InternalAlloc(sizeof(Context)));
-    new (current_thread_context) Context();
-    pthread_setspecific(detail::key, current_thread_context);
+    current_thread_context = static_cast<__radsan::Context *>(
+        __sanitizer::InternalAlloc(sizeof(__radsan::Context)));
+    new (current_thread_context) __radsan::Context();
+    pthread_setspecific(context_key, current_thread_context);
   }
 
   return *current_thread_context;
@@ -62,9 +57,7 @@ Context &GetContextForThisThreadImpl() {
     Until then, and to keep the first PRs small, only the exit mode
     is available.
 */
-void InvokeViolationDetectedAction() { exit(EXIT_FAILURE); }
-
-} // namespace detail
+static void InvokeViolationDetectedAction() { exit(EXIT_FAILURE); }
 
 namespace __radsan {
 
@@ -82,7 +75,7 @@ void Context::ExpectNotRealtime(const char *intercepted_function_name) {
   if (InRealtimeContext() && !IsBypassed()) {
     BypassPush();
     PrintDiagnostics(intercepted_function_name);
-    detail::InvokeViolationDetectedAction();
+    InvokeViolationDetectedAction();
     BypassPop();
   }
 }
@@ -99,8 +92,6 @@ void Context::PrintDiagnostics(const char *intercepted_function_name) {
   __radsan::PrintStackTrace();
 }
 
-Context &GetContextForThisThread() {
-  return detail::GetContextForThisThreadImpl();
-}
+Context &GetContextForThisThread() { return GetContextForThisThreadImpl(); }
 
 } // namespace __radsan

compiler-rt/lib/radsan/radsan_stack.cpp

@@ -17,7 +17,6 @@ using namespace __sanitizer;
 
 // We must define our own implementation of this method for our runtime.
 // This one is just copied from UBSan.
-
 namespace __sanitizer {
 void BufferedStackTrace::UnwindImpl(uptr pc, uptr bp, void *context,
                                     bool request_fast, u32 max_depth) {
@@ -29,16 +28,14 @@ void BufferedStackTrace::UnwindImpl(uptr pc, uptr bp, void *context,
 }
 } // namespace __sanitizer
 
-namespace __radsan {
-void SetGlobalStackTraceFormat() {
+static void SetGlobalStackTraceFormat() {
   SetCommonFlagsDefaults();
   CommonFlags cf;
   cf.CopyFrom(*common_flags());
   cf.stack_trace_format = "DEFAULT";
   cf.external_symbolizer_path = GetEnv("RADSAN_SYMBOLIZER_PATH");
   OverrideCommonFlags(cf);
 }
-} // namespace __radsan
 
 using namespace __radsan;
 void __radsan::PrintStackTrace() {