[XRay] Fix the test func-id-utils.cc on PPC.

[timshen]

Summary

The test fails on PPC, because the address of a function may vary
depending on whether the "taker" shares the same ToC (roughly, in the
same "module") as the function.

Therefore the addresses of the functions taken in func-id-utils.cc may be
different from the addresses taken in xray runtime.

Change the test to be permissive on address comparison.

[timshen]

s/==/</ on non-PPC platforms. set_difference takes a less-than comparator.

[dberris]

LGTM

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
-// FIXME: When we know why this fails in ppc, un-xfail it.
-// XFAIL: powerpc64le
 
 #include "xray/xray_interface.h"
 #include <algorithm>
 #include <cassert>
 #include <cstdio>
 #include <iterator>
 #include <set>
 
[[clang::xray_always_instrument]] int main(int argc, char *argv[]) {
   std::set<void *> all_instrumented;
   for (auto i = __xray_max_function_id(); i != 0; --i) {
     auto addr = __xray_function_address(i);
     all_instrumented.insert(reinterpret_cast<void *>(addr));
   }
   assert(all_instrumented.size() == __xray_max_function_id() &&
          "each function id must be assigned to a unique function");
 
-  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()));
+  std::set<void *> not_instrumented;
+  const auto comp = [](void *lhs, void *rhs) {
+#ifdef __PPC__
+    return reinterpret_cast<uintptr_t>(lhs) + 8 <
+           reinterpret_cast<uintptr_t>(rhs);
+#else
+    return lhs < rhs;
+#endif
+  };
+  std::set_difference(must_be_instrumented.begin(), must_be_instrumented.end(),
+                      all_instrumented.begin(), all_instrumented.end(),
+                      std::inserter(not_instrumented, not_instrumented.begin()),
+                      comp);
   assert(
-      common == must_be_instrumented &&
+      not_instrumented.empty() &&
       "we should see all explicitly instrumented functions with function ids");
-  return common == must_be_instrumented ? 0 : 1;
+  return not_instrumented.empty() ? 0 : 1;
 }