[XRay] Guard local variables with `static` and struct with unnamed namespaces

[MaskRay]

Summary

This is for coding standard conformance, and for fixing an ODR violation
issue: __xray::ThreadLocalData is defined twice and differently in
xray_fdr_logging.cc and xray_basic_logging.cc

[MaskRay]

Guard another two structs

[dberris]

LGTM -- thanks! Is there a way for us to catch these with tests?

[MaskRay]

In D52639#1248743, @dberris wrote:

LGTM -- thanks! Is there a way for us to catch these with tests?

I'm not sure if ODRHash or other tools can catch this... This may not matter too much for a trivial type like this.. If it were virtual or had constructors, the linker would error.

lib/xray/xray_basic_logging.cc

 #include "xray_defs.h"
 #include "xray_flags.h"
 #include "xray_interface_internal.h"
 #include "xray_tsc.h"
 #include "xray_utils.h"
 
 namespace __xray {
 
-SpinMutex LogMutex;
+static SpinMutex LogMutex;
 
+namespace {
 // We use elements of this type to record the entry TSC of every function ID we
 // see as we're tracing a particular thread's execution.
 struct alignas(16) StackEntry {
   int32_t FuncId;
   uint16_t Type;
   uint8_t CPU;
   uint8_t Padding;
   uint64_t TSC;
 };
 
 static_assert(sizeof(StackEntry) == 16, "Wrong size for StackEntry");
 
 struct alignas(64) ThreadLocalData {
   void *InMemoryBuffer = nullptr;
   size_t BufferSize = 0;
   size_t BufferOffset = 0;
   void *ShadowStack = nullptr;
   size_t StackSize = 0;
   size_t StackEntries = 0;
   int Fd = -1;
 };
+} // namespace
 
 static pthread_key_t PThreadKey;
 
 static atomic_uint8_t BasicInitialized{0};
 
 struct BasicLoggingOptions {
   int DurationFilterMicros = 0;
   size_t MaxStackDepth = 0;

lib/xray/xray_fdr_logging.cc

 #include "xray_fdr_log_writer.h"
 #include "xray_flags.h"
 #include "xray_recursion_guard.h"
 #include "xray_tsc.h"
 #include "xray_utils.h"
 
 namespace __xray {
 
-atomic_sint32_t LoggingStatus = {XRayLogInitStatus::XRAY_LOG_UNINITIALIZED};
+static atomic_sint32_t LoggingStatus = {
+    XRayLogInitStatus::XRAY_LOG_UNINITIALIZED};
 
+namespace {
 // Group together thread-local-data in a struct, then hide it behind a function
 // call so that it can be initialized on first use instead of as a global. We
 // force the alignment to 64-bytes for x86 cache line alignment, as this
 // structure is used in the hot path of implementation.
 struct alignas(64) ThreadLocalData {
   BufferQueue::Buffer Buffer{};
   char *RecordPtr = nullptr;
   // The number of FunctionEntry records immediately preceding RecordPtr.
struct alignas(64) ThreadLocalData {
   uint64_t LastTSC = 0;
   uint64_t LastFunctionEntryTSC = 0;
 
   // Make sure a thread that's ever called handleArg0 has a thread-local
   // live reference to the buffer queue for this particular instance of
   // FDRLogging, and that we're going to clean it up when the thread exits.
   BufferQueue *BQ = nullptr;
 };
+} // namespace
 
 static_assert(std::is_trivially_destructible<ThreadLocalData>::value,
               "ThreadLocalData must be trivially destructible");
 
 static constexpr auto MetadataRecSize = sizeof(MetadataRecord);
 static constexpr auto FunctionRecSize = sizeof(FunctionRecord);
 
 // Use a global pthread key to identify thread-local data for logging.