[XRay][compiler-rt] Add function id utilities for XRay

[dberris]

Summary

This change allows us to provide users and implementers of XRay handlers
a means of converting XRay function id's to addresses. This, in
combination with the facilities provided in D32695, allows users to find
out:

• How many function id's there are defined in the current binary.
• Get the address of the function associated with this function id.
• Patch only specific functions according to their requirements.

While we don't directly provide symbolization support in XRay, having
the function's address lets users determine this information easily
either during runtime, or offline with tools like 'addr2line'.

[dblaikie]

Slightly curious to me that function IDs are > 0, but use a signed type - but no big deal, I guess there's probably a reason.

test/xray/TestCases/Linux/func-id-utils.cc

26–28 ↗

(On Diff #97780)

What does this test?

Should the test case print the &foo and &bar, or assert(xray_function_address(1) == &foo), etc?

[dberris]

In D32846#746274, @dblaikie wrote:

Slightly curious to me that function IDs are > 0, but use a signed type - but no big deal, I guess there's probably a reason.

I agonised over this for a while. There's no real reason why it's signed, but changing it now might be too late (unless we start doing XRay versioning of the sleds). It's hard to assume that when we're laying down bytes in the binary with the compiler that signed numbers and unsigned numbers have the same representation (maybe they are for one platform, while not in another).

I suspect we can change it. Probably should do it a later time though. :)

test/xray/TestCases/Linux/func-id-utils.cc

26–28 ↗

(On Diff #97780)

It does look a little goofy, but it's testing that:

• We do have functions instrumented (i.e. __xray_max_function_id() != 0).
• The maximum function id has an address associated with it.
• We don't have a function id 0 that has an address. :)

While it's tempting to print the addresses of function id's and check, unfortunately we cannot assume that the compiler/linker will lay out the functions in a stable manner -- and thus function id's won't be guaranteed to always be mapped to specific function name.

[dberris]

Update tests to actually check the addresses.

compiler-rt/trunk/include/xray/xray_interface.h

 // This file is a part of XRay, a dynamic runtime instrumentation system.
 //
 // APIs for controlling XRay functionality explicitly.
 //===----------------------------------------------------------------------===//
 #ifndef XRAY_XRAY_INTERFACE_H
 #define XRAY_XRAY_INTERFACE_H
 
 #include <cstdint>
+#include <stddef.h>
 
 extern "C" {
 
 /// Synchronize this with AsmPrinter::SledKind in LLVM.
 enum XRayEntryType {
   ENTRY = 0,
   EXIT = 1,
   TAIL = 2,

 /// This patches a specific function id. See XRayPatchingStatus for possible
 /// result values.
 extern XRayPatchingStatus __xray_patch_function(int32_t FuncId);
 
 /// This unpatches a specific function id. See XRayPatchingStatus for possible
 /// result values.
 extern XRayPatchingStatus __xray_unpatch_function(int32_t FuncId);
 
+/// This function returns the address of the function provided a valid function
+/// id. We return 0 if we encounter any error, even if 0 may be a valid function
+/// address.
+extern uintptr_t __xray_function_address(int32_t FuncId);
+
+/// This function returns the maximum valid function id. Returns 0 if we
+/// encounter errors (when there are no instrumented functions, etc.).
+extern size_t __xray_max_function_id();
 
 }
 
 #endif

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

XRayPatchingStatus patchFunction(int32_t FuncId,
   }
 
   // If we don't have an index, we can't patch individual functions.
   if (InstrMap.Functions == 0)
     return XRayPatchingStatus::NOT_INITIALIZED;
 
   // FuncId must be a positive number, less than the number of functions
   // instrumented.
-  if (FuncId <= 0 || static_cast<size_t>(FuncId) >= InstrMap.Functions) {
+  if (FuncId <= 0 || static_cast<size_t>(FuncId) > InstrMap.Functions) {
     Report("Invalid function id provided: %d\n", FuncId);
     return XRayPatchingStatus::FAILED;
   }
 
   // Now we patch ths sleds for this specific function.
   auto SledRange = InstrMap.SledsIndex[FuncId - 1];
   auto *f = SledRange.Begin;
   auto *e = SledRange.End;
int __xray_set_handler_arg1(void (*Handler)(int32_t, XRayEntryType, uint64_t)) {
   // A relaxed write might not be visible even if the current thread gets
   // scheduled on a different CPU/NUMA node.  We need to wait for everyone to
   // have this handler installed for consistency of collected data across CPUs.
   __sanitizer::atomic_store(&XRayArgLogger, reinterpret_cast<uint64_t>(Handler),
                             __sanitizer::memory_order_release);
   return 1;
 }
 int __xray_remove_handler_arg1() { return __xray_set_handler_arg1(nullptr); }
+
+uintptr_t __xray_function_address(int32_t FuncId) XRAY_NEVER_INSTRUMENT {
+  __sanitizer::SpinMutexLock Guard(&XRayInstrMapMutex);
+  if (FuncId <= 0 || static_cast<size_t>(FuncId) > XRayInstrMap.Functions)
+    return 0;
+  return XRayInstrMap.SledsIndex[FuncId - 1].Begin->Address;
+}
+
+size_t __xray_max_function_id() XRAY_NEVER_INSTRUMENT {
+  __sanitizer::SpinMutexLock Guard(&XRayInstrMapMutex);
+  return XRayInstrMap.Functions;
+}

compiler-rt/trunk/test/xray/TestCases/Linux/func-id-utils.cc

+// Check that we can turn a function id to a function address, and also get the
+// maximum function id for the current binary.
+//
+// RUN: %clangxx_xray -std=c++11 %s -o %t
+// RUN: XRAY_OPTIONS="patch_premain=false xray_naive_log=false" %run %t | FileCheck %s
+
+#include "xray/xray_interface.h"
+#include <algorithm>
+#include <cstdio>
+#include <set>
+#include <iterator>
+
+[[clang::xray_always_instrument]] void bar(){
+    // do nothing!
+}
+
+    [[clang::xray_always_instrument]] void foo() {
+  bar();
+}
+
+[[clang::xray_always_instrument]] int main(int argc, char *argv[]) {
+  printf("max function id: %zu\n", __xray_max_function_id());
+  // CHECK: max function id: [[MAX:.*]]
+
+  std::set<void *> must_be_instrumented;
+  must_be_instrumented.insert(reinterpret_cast<void*>(&foo));
+  must_be_instrumented.insert(reinterpret_cast<void*>(&bar));
+  printf("addresses:\n");
+  std::set<void *> all_instrumented;
+  for (auto i = __xray_max_function_id(); i != 0; --i) {
+    auto addr = __xray_function_address(i);
+    printf("#%lu -> @%04lx\n", i, addr);
+    all_instrumented.insert(reinterpret_cast<void *>(addr));
+  }
+
+  // CHECK-LABEL: addresses:
+  // CHECK: #[[MAX]] -> @[[ADDR:.*]]
+  // CHECK-NOT: #0 -> @{{.*}}
+  std::set<void *> common;
+
+  std::set_intersection(all_instrumented.begin(), all_instrumented.end(),
+                        must_be_instrumented.begin(),
+                        must_be_instrumented.end(),
+                        std::inserter(common, common.begin()));
+  return common == must_be_instrumented ? 0 : 1;
+}