[XRay][compiler-rt][NFC] Turn ProudCase functions to humbleCase functions

[dberris]

Summary

As pointed out in casual reading of the XRay codebase, that we had
some interesting named functions that didn't quite follow the LLVM coding
conventions.

[dblaikie]

Looks reasonable. Feel free to commit stuff like this without prior review in areas you already own/work on extensively.

compiler-rt/trunk/lib/xray/tests/unit/fdr_logging_test.cc

 };
 
 TEST(FDRLoggingTest, Simple) {
   FDRLoggingOptions Options;
   Options.ReportErrors = true;
   char TmpFilename[] = "fdr-logging-test.XXXXXX";
   Options.Fd = mkstemp(TmpFilename);
   ASSERT_NE(Options.Fd, -1);
-  ASSERT_EQ(FDRLogging_init(kBufferSize, kBufferMax, &Options,
+  ASSERT_EQ(fdrLoggingInit(kBufferSize, kBufferMax, &Options,
                             sizeof(FDRLoggingOptions)),
             XRayLogInitStatus::XRAY_LOG_INITIALIZED);
-  FDRLogging_handleArg0(1, XRayEntryType::ENTRY);
-  FDRLogging_handleArg0(1, XRayEntryType::EXIT);
-  ASSERT_EQ(FDRLogging_finalize(), XRayLogInitStatus::XRAY_LOG_FINALIZED);
-  ASSERT_EQ(FDRLogging_flush(), XRayLogFlushStatus::XRAY_LOG_FLUSHED);
-  ASSERT_EQ(FDRLogging_reset(), XRayLogInitStatus::XRAY_LOG_UNINITIALIZED);
+  fdrLoggingHandleArg0(1, XRayEntryType::ENTRY);
+  fdrLoggingHandleArg0(1, XRayEntryType::EXIT);
+  ASSERT_EQ(fdrLoggingFinalize(), XRayLogInitStatus::XRAY_LOG_FINALIZED);
+  ASSERT_EQ(fdrLoggingFlush(), XRayLogFlushStatus::XRAY_LOG_FLUSHED);
+  ASSERT_EQ(fdrLoggingReset(), XRayLogInitStatus::XRAY_LOG_UNINITIALIZED);
 
   // To do this properly, we have to close the file descriptor then re-open the
   // file for reading this time.
   ASSERT_EQ(close(Options.Fd), 0);
   int Fd = open(TmpFilename, O_RDONLY);
   ASSERT_NE(-1, Fd);
   ScopedFileCloserAndDeleter Guard(Fd, TmpFilename);
   auto Size = lseek(Fd, 0, SEEK_END);
TEST(FDRLoggingTest, Simple) {
   ASSERT_EQ(MDR.RecordKind, MetadataRecord::RecordKinds::NewBuffer);
 }
 
 TEST(FDRLoggingTest, Multiple) {
   FDRLoggingOptions Options;
   char TmpFilename[] = "fdr-logging-test.XXXXXX";
   Options.Fd = mkstemp(TmpFilename);
   ASSERT_NE(Options.Fd, -1);
-  ASSERT_EQ(FDRLogging_init(kBufferSize, kBufferMax, &Options,
+  ASSERT_EQ(fdrLoggingInit(kBufferSize, kBufferMax, &Options,
                             sizeof(FDRLoggingOptions)),
             XRayLogInitStatus::XRAY_LOG_INITIALIZED);
   for (uint64_t I = 0; I < 100; ++I) {
-    FDRLogging_handleArg0(1, XRayEntryType::ENTRY);
-    FDRLogging_handleArg0(1, XRayEntryType::EXIT);
+    fdrLoggingHandleArg0(1, XRayEntryType::ENTRY);
+    fdrLoggingHandleArg0(1, XRayEntryType::EXIT);
   }
-  ASSERT_EQ(FDRLogging_finalize(), XRayLogInitStatus::XRAY_LOG_FINALIZED);
-  ASSERT_EQ(FDRLogging_flush(), XRayLogFlushStatus::XRAY_LOG_FLUSHED);
-  ASSERT_EQ(FDRLogging_reset(), XRayLogInitStatus::XRAY_LOG_UNINITIALIZED);
+  ASSERT_EQ(fdrLoggingFinalize(), XRayLogInitStatus::XRAY_LOG_FINALIZED);
+  ASSERT_EQ(fdrLoggingFlush(), XRayLogFlushStatus::XRAY_LOG_FLUSHED);
+  ASSERT_EQ(fdrLoggingReset(), XRayLogInitStatus::XRAY_LOG_UNINITIALIZED);
 
   // To do this properly, we have to close the file descriptor then re-open the
   // file for reading this time.
   ASSERT_EQ(close(Options.Fd), 0);
   int Fd = open(TmpFilename, O_RDONLY);
   ASSERT_NE(-1, Fd);
   ScopedFileCloserAndDeleter Guard(Fd, TmpFilename);
   auto Size = lseek(Fd, 0, SEEK_END);

compiler-rt/trunk/lib/xray/xray_arm.cc

write32bitLoadReg(uint8_t regNo, uint32_t *Address,
   *Address = (0xE3400000 | (uint32_t(regNo) << 12) | getMovtMask(Value));
   return Address + 1;
 }
 
 // Writes the following instructions:
 //   MOVW r0, #<lower 16 bits of the |Value|>
 //   MOVT r0, #<higher 16 bits of the |Value|>
 inline static uint32_t *
-Write32bitLoadR0(uint32_t *Address,
+write32bitLoadR0(uint32_t *Address,
                  const uint32_t Value) XRAY_NEVER_INSTRUMENT {
   return write32bitLoadReg(0, Address, Value);
 }
 
 // Writes the following instructions:
 //   MOVW ip, #<lower 16 bits of the |Value|>
 //   MOVT ip, #<higher 16 bits of the |Value|>
 inline static uint32_t *
-Write32bitLoadIP(uint32_t *Address,
+write32bitLoadIP(uint32_t *Address,
                  const uint32_t Value) XRAY_NEVER_INSTRUMENT {
   return write32bitLoadReg(12, Address, Value);
 }
 
 inline static bool patchSled(const bool Enable, const uint32_t FuncId,
                              const XRaySledEntry &Sled,
                              void (*TracingHook)()) XRAY_NEVER_INSTRUMENT {
   // When |Enable| == true,
inline static bool patchSled(const bool Enable, const uint32_t FuncId,
   //
   // When |Enable|==false, we set back the first instruction in the sled to be
   //   B #20
 
   uint32_t *FirstAddress = reinterpret_cast<uint32_t *>(Sled.Address);
   uint32_t *CurAddress = FirstAddress + 1;
   if (Enable) {
     CurAddress =
-        Write32bitLoadR0(CurAddress, reinterpret_cast<uint32_t>(FuncId));
+        write32bitLoadR0(CurAddress, reinterpret_cast<uint32_t>(FuncId));
     CurAddress =
-        Write32bitLoadIP(CurAddress, reinterpret_cast<uint32_t>(TracingHook));
+        write32bitLoadIP(CurAddress, reinterpret_cast<uint32_t>(TracingHook));
     *CurAddress = uint32_t(PatchOpcodes::PO_BlxIp);
     CurAddress++;
     *CurAddress = uint32_t(PatchOpcodes::PO_PopR0Lr);
     CurAddress++;
     std::atomic_store_explicit(
         reinterpret_cast<std::atomic<uint32_t> *>(FirstAddress),
         uint32_t(PatchOpcodes::PO_PushR0Lr), std::memory_order_release);
   } else {

compiler-rt/trunk/lib/xray/xray_fdr_logging.h

 
 // Options used by the FDR implementation.
 struct FDRLoggingOptions {
   bool ReportErrors = false;
   int Fd = -1;
 };
 
 // Flight Data Recorder mode implementation interfaces.
-XRayLogInitStatus FDRLogging_init(size_t BufferSize, size_t BufferMax,
+XRayLogInitStatus fdrLoggingInit(size_t BufferSize, size_t BufferMax,
                                   void *Options, size_t OptionsSize);
-XRayLogInitStatus FDRLogging_finalize();
-void FDRLogging_handleArg0(int32_t FuncId, XRayEntryType Entry);
-XRayLogFlushStatus FDRLogging_flush();
-XRayLogInitStatus FDRLogging_reset();
+XRayLogInitStatus fdrLoggingFinalize();
+void fdrLoggingHandleArg0(int32_t FuncId, XRayEntryType Entry);
+XRayLogFlushStatus fdrLoggingFlush();
+XRayLogInitStatus fdrLoggingReset();
 
 } // namespace __xray
 
 #endif // XRAY_XRAY_FDR_LOGGING_H

compiler-rt/trunk/lib/xray/xray_fdr_logging.cc

 std::atomic<XRayLogInitStatus> LoggingStatus{
     XRayLogInitStatus::XRAY_LOG_UNINITIALIZED};
 
 std::atomic<XRayLogFlushStatus> LogFlushStatus{
     XRayLogFlushStatus::XRAY_LOG_NOT_FLUSHING};
 
 std::unique_ptr<FDRLoggingOptions> FDROptions;
 
-XRayLogInitStatus FDRLogging_init(std::size_t BufferSize, std::size_t BufferMax,
+XRayLogInitStatus fdrLoggingInit(std::size_t BufferSize, std::size_t BufferMax,
                                   void *Options,
                                   size_t OptionsSize) XRAY_NEVER_INSTRUMENT {
   assert(OptionsSize == sizeof(FDRLoggingOptions));
   XRayLogInitStatus CurrentStatus = XRayLogInitStatus::XRAY_LOG_UNINITIALIZED;
   if (!LoggingStatus.compare_exchange_strong(
           CurrentStatus, XRayLogInitStatus::XRAY_LOG_INITIALIZING,
           std::memory_order_release, std::memory_order_relaxed))
     return CurrentStatus;
 
   FDROptions.reset(new FDRLoggingOptions());
   *FDROptions = *reinterpret_cast<FDRLoggingOptions *>(Options);
   if (FDROptions->ReportErrors)
-    SetPrintfAndReportCallback(PrintToStdErr);
+    SetPrintfAndReportCallback(printToStdErr);
 
   bool Success = false;
   BQ = std::make_shared<BufferQueue>(BufferSize, BufferMax, Success);
   if (!Success) {
     Report("BufferQueue init failed.\n");
     return XRayLogInitStatus::XRAY_LOG_UNINITIALIZED;
   }
 
   // Install the actual handleArg0 handler after initialising the buffers.
-  __xray_set_handler(FDRLogging_handleArg0);
+  __xray_set_handler(fdrLoggingHandleArg0);
 
   LoggingStatus.store(XRayLogInitStatus::XRAY_LOG_INITIALIZED,
                       std::memory_order_release);
   return XRayLogInitStatus::XRAY_LOG_INITIALIZED;
 }
 
 // Must finalize before flushing.
-XRayLogFlushStatus FDRLogging_flush() XRAY_NEVER_INSTRUMENT {
+XRayLogFlushStatus fdrLoggingFlush() XRAY_NEVER_INSTRUMENT {
   if (LoggingStatus.load(std::memory_order_acquire) !=
       XRayLogInitStatus::XRAY_LOG_FINALIZED)
     return XRayLogFlushStatus::XRAY_LOG_NOT_FLUSHING;
 
   XRayLogFlushStatus Result = XRayLogFlushStatus::XRAY_LOG_NOT_FLUSHING;
   if (!LogFlushStatus.compare_exchange_strong(
           Result, XRayLogFlushStatus::XRAY_LOG_FLUSHING,
           std::memory_order_release, std::memory_order_relaxed))
LocalBQ->apply([&](const BufferQueue::Buffer &B) {
     retryingWriteAll(Fd, reinterpret_cast<char *>(B.Buffer),
                      reinterpret_cast<char *>(B.Buffer) + B.Size);
   });
   LogFlushStatus.store(XRayLogFlushStatus::XRAY_LOG_FLUSHED,
                        std::memory_order_release);
   return XRayLogFlushStatus::XRAY_LOG_FLUSHED;
 }
 
-XRayLogInitStatus FDRLogging_finalize() XRAY_NEVER_INSTRUMENT {
+XRayLogInitStatus fdrLoggingFinalize() XRAY_NEVER_INSTRUMENT {
   XRayLogInitStatus CurrentStatus = XRayLogInitStatus::XRAY_LOG_INITIALIZED;
   if (!LoggingStatus.compare_exchange_strong(
           CurrentStatus, XRayLogInitStatus::XRAY_LOG_FINALIZING,
           std::memory_order_release, std::memory_order_relaxed))
     return CurrentStatus;
 
   // Do special things to make the log finalize itself, and not allow any more
   // operations to be performed until re-initialized.
   BQ->finalize();
 
   LoggingStatus.store(XRayLogInitStatus::XRAY_LOG_FINALIZED,
                       std::memory_order_release);
   return XRayLogInitStatus::XRAY_LOG_FINALIZED;
 }
 
-XRayLogInitStatus FDRLogging_reset() XRAY_NEVER_INSTRUMENT {
+XRayLogInitStatus fdrLoggingReset() XRAY_NEVER_INSTRUMENT {
   XRayLogInitStatus CurrentStatus = XRayLogInitStatus::XRAY_LOG_FINALIZED;
   if (!LoggingStatus.compare_exchange_strong(
           CurrentStatus, XRayLogInitStatus::XRAY_LOG_UNINITIALIZED,
           std::memory_order_release, std::memory_order_relaxed))
     return CurrentStatus;
 
   // Release the in-memory buffer queue.
   BQ.reset();

 
 inline bool loggingInitialized() {
   return LoggingStatus.load(std::memory_order_acquire) ==
          XRayLogInitStatus::XRAY_LOG_INITIALIZED;
 }
 
 } // namespace
 
-void FDRLogging_handleArg0(int32_t FuncId,
+void fdrLoggingHandleArg0(int32_t FuncId,
                            XRayEntryType Entry) XRAY_NEVER_INSTRUMENT {
   // We want to get the TSC as early as possible, so that we can check whether
   // we've seen this CPU before. We also do it before we load anything else, to
   // allow for forward progress with the scheduling.
   unsigned char CPU;
   uint64_t TSC = __xray::readTSC(CPU);
 
   // Bail out right away if logging is not initialized yet.

 }
 
 } // namespace __xray
 
 static auto Unused = [] {
   using namespace __xray;
   if (flags()->xray_fdr_log) {
     XRayLogImpl Impl{
-        FDRLogging_init, FDRLogging_finalize, FDRLogging_handleArg0,
-        FDRLogging_flush,
+        fdrLoggingInit, fdrLoggingFinalize, fdrLoggingHandleArg0,
+        fdrLoggingFlush,
     };
     __xray_set_log_impl(Impl);
   }
   return true;
 }();

compiler-rt/trunk/lib/xray/xray_flags.h

 
 namespace __xray {
 
 struct Flags {
 #define XRAY_FLAG(Type, Name, DefaultValue, Description) Type Name;
 #include "xray_flags.inc"
 #undef XRAY_FLAG
 
-  void SetDefaults();
+  void setDefaults();
 };
 
 extern Flags xray_flags_dont_use_directly;
 inline Flags *flags() { return &xray_flags_dont_use_directly; }
 
-void InitializeFlags();
+void initializeFlags();
 
 } // namespace __xray
 
 #endif // XRAY_FLAGS_H

compiler-rt/trunk/lib/xray/xray_flags.cc

 #include "xray_defs.h"
 
 using namespace __sanitizer;
 
 namespace __xray {
 
 Flags xray_flags_dont_use_directly; // use via flags().
 
-void Flags::SetDefaults() XRAY_NEVER_INSTRUMENT {
+void Flags::setDefaults() XRAY_NEVER_INSTRUMENT {
 #define XRAY_FLAG(Type, Name, DefaultValue, Description) Name = DefaultValue;
 #include "xray_flags.inc"
 #undef XRAY_FLAG
 }
 
-static void RegisterXRayFlags(FlagParser *P, Flags *F) XRAY_NEVER_INSTRUMENT {
+static void registerXRayFlags(FlagParser *P, Flags *F) XRAY_NEVER_INSTRUMENT {
 #define XRAY_FLAG(Type, Name, DefaultValue, Description)                       \
   RegisterFlag(P, #Name, Description, &F->Name);
 #include "xray_flags.inc"
 #undef XRAY_FLAG
 }
 
-void InitializeFlags() XRAY_NEVER_INSTRUMENT {
+void initializeFlags() XRAY_NEVER_INSTRUMENT {
   SetCommonFlagsDefaults();
   auto *F = flags();
-  F->SetDefaults();
+  F->setDefaults();
 
   FlagParser XRayParser;
-  RegisterXRayFlags(&XRayParser, F);
+  registerXRayFlags(&XRayParser, F);
   RegisterCommonFlags(&XRayParser);
 
   // Override from command line.
   XRayParser.ParseString(GetEnv("XRAY_OPTIONS"));
 
   InitializeCommonFlags();
 
   if (Verbosity())
     ReportUnrecognizedFlags();
 
   if (common_flags()->help) {
     XRayParser.PrintFlagDescriptions();
   }
 }
 
 } // namespace __xray

compiler-rt/trunk/lib/xray/xray_init.cc

 std::atomic<bool> XRayInitialized{false};
 
 // This should always be updated before XRayInitialized is updated.
 std::atomic<__xray::XRaySledMap> XRayInstrMap{};
 
 // __xray_init() will do the actual loading of the current process' memory map
 // and then proceed to look for the .xray_instr_map section/segment.
 void __xray_init() XRAY_NEVER_INSTRUMENT {
-  InitializeFlags();
+  initializeFlags();
   if (__start_xray_instr_map == nullptr) {
     Report("XRay instrumentation map missing. Not initializing XRay.\n");
     return;
   }
 
   // Now initialize the XRayInstrMap global struct with the address of the
   // entries, reinterpreted as an array of XRaySledEntry objects. We use the
   // virtual pointer we have from the section to provide us the correct

compiler-rt/trunk/lib/xray/xray_interface.cc

public:
   CleanupInvoker(CleanupInvoker &&) XRAY_NEVER_INSTRUMENT = default;
   CleanupInvoker &
   operator=(const CleanupInvoker &) XRAY_NEVER_INSTRUMENT = delete;
   CleanupInvoker &operator=(CleanupInvoker &&) XRAY_NEVER_INSTRUMENT = delete;
   ~CleanupInvoker() XRAY_NEVER_INSTRUMENT { Fn(); }
 };
 
 template <class Function>
-CleanupInvoker<Function> ScopeCleanup(Function Fn) XRAY_NEVER_INSTRUMENT {
+CleanupInvoker<Function> scopeCleanup(Function Fn) XRAY_NEVER_INSTRUMENT {
   return CleanupInvoker<Function>{Fn};
 }
 
-// ControlPatching implements the common internals of the patching/unpatching
+// controlPatching implements the common internals of the patching/unpatching
 // implementation. |Enable| defines whether we're enabling or disabling the
 // runtime XRay instrumentation.
-XRayPatchingStatus ControlPatching(bool Enable) XRAY_NEVER_INSTRUMENT {
+XRayPatchingStatus controlPatching(bool Enable) XRAY_NEVER_INSTRUMENT {
   if (!XRayInitialized.load(std::memory_order_acquire))
     return XRayPatchingStatus::NOT_INITIALIZED; // Not initialized.
 
   static bool NotPatching = false;
   if (!XRayPatching.compare_exchange_strong(NotPatching, true,
                                             std::memory_order_acq_rel,
                                             std::memory_order_acquire)) {
     return XRayPatchingStatus::ONGOING; // Already patching.
   }
 
   bool PatchingSuccess = false;
-  auto XRayPatchingStatusResetter = ScopeCleanup([&PatchingSuccess] {
+  auto XRayPatchingStatusResetter = scopeCleanup([&PatchingSuccess] {
     if (!PatchingSuccess) {
       XRayPatching.store(false, std::memory_order_release);
     }
   });
 
   // Step 1: Compute the function id, as a unique identifier per function in the
   // instrumentation map.
   XRaySledMap InstrMap = XRayInstrMap.load(std::memory_order_acquire);
for (std::size_t I = 0; I < InstrMap.Entries; I++) {
     (void)Success;
   }
   XRayPatching.store(false, std::memory_order_release);
   PatchingSuccess = true;
   return XRayPatchingStatus::SUCCESS;
 }
 
 XRayPatchingStatus __xray_patch() XRAY_NEVER_INSTRUMENT {
-  return ControlPatching(true);
+  return controlPatching(true);
 }
 
 XRayPatchingStatus __xray_unpatch() XRAY_NEVER_INSTRUMENT {
-  return ControlPatching(false);
+  return controlPatching(false);
 }

compiler-rt/trunk/lib/xray/xray_utils.h

 #define XRAY_UTILS_H
 
 #include <sys/types.h>
 #include <utility>
 
 namespace __xray {
 
 // Default implementation of the reporting interface for sanitizer errors.
-void PrintToStdErr(const char *Buffer);
+void printToStdErr(const char *Buffer);
 
 // EINTR-safe write routine, provided a file descriptor and a character range.
 void retryingWriteAll(int Fd, char *Begin, char *End);
 
 // Reads a long long value from a provided file.
 bool readValueFromFile(const char *Filename, long long *Value);
 
 // EINTR-safe read routine, providing a file descriptor and a character range.

compiler-rt/trunk/lib/xray/xray_utils.cc

 #elif defined(__arm__) || defined(__aarch64__)
 #include "xray_emulate_tsc.h"
 #else
 #error "Unsupported CPU Architecture"
 #endif /* CPU architecture */
 
 namespace __xray {
 
-void PrintToStdErr(const char *Buffer) XRAY_NEVER_INSTRUMENT {
+void printToStdErr(const char *Buffer) XRAY_NEVER_INSTRUMENT {
   fprintf(stderr, "%s", Buffer);
 }
 
 void retryingWriteAll(int Fd, char *Begin, char *End) XRAY_NEVER_INSTRUMENT {
   if (Begin == End)
     return;
   auto TotalBytes = std::distance(Begin, End);
   while (auto Written = write(Fd, Begin, TotalBytes)) {

 #else
 #error "Unsupported CPU Architecture"
 #endif /* CPU architecture */
   return CPUFrequency;
 }
 
 int getLogFD() XRAY_NEVER_INSTRUMENT {
   // FIXME: Figure out how to make this less stderr-dependent.
-  SetPrintfAndReportCallback(PrintToStdErr);
+  SetPrintfAndReportCallback(printToStdErr);
   // Open a temporary file once for the log.
   static char TmpFilename[256] = {};
   static char TmpWildcardPattern[] = "XXXXXX";
   auto Argv = GetArgv();
   const char *Progname = Argv[0] == nullptr ? "(unknown)" : Argv[0];
   const char *LastSlash = internal_strrchr(Progname, '/');
 
   if (LastSlash != nullptr)