Merge commit '132d711554cbb3db0b0efd1e88d2acb9278b6be9' into pulldown-ww29

Author: dwoodwor-intel

bolt/runtime/common.h

@@ -76,6 +76,49 @@ typedef int int32_t;
   "pop %%rbx\n"                                                                \
   "pop %%rax\n"
 
+// Functions that are required by freestanding environment. Compiler may
+// generate calls to these implicitly.
+extern "C" {
+void *memcpy(void *Dest, const void *Src, size_t Len) {
+  uint8_t *d = static_cast<uint8_t *>(Dest);
+  const uint8_t *s = static_cast<const uint8_t *>(Src);
+  while (Len--)
+    *d++ = *s++;
+  return Dest;
+}
+
+void *memmove(void *Dest, const void *Src, size_t Len) {
+  uint8_t *d = static_cast<uint8_t *>(Dest);
+  const uint8_t *s = static_cast<const uint8_t *>(Src);
+  if (d < s) {
+    while (Len--)
+      *d++ = *s++;
+  } else {
+    s += Len - 1;
+    d += Len - 1;
+    while (Len--)
+      *d-- = *s--;
+  }
+
+  return Dest;
+}
+
+void memset(char *Buf, char C, uint32_t Size) {
+  for (int I = 0; I < Size; ++I)
+    *Buf++ = C;
+}
+
+int memcmp(const void *s1, const void *s2, size_t n) {
+  const uint8_t *c1 = static_cast<const uint8_t *>(s1);
+  const uint8_t *c2 = static_cast<const uint8_t *>(s2);
+  for (; n--; c1++, c2++) {
+    if (*c1 != *c2)
+      return *c1 < *c2 ? -1 : 1;
+  }
+  return 0;
+}
+} // extern "C"
+
 // Anonymous namespace covering everything but our library entry point
 namespace {
 
@@ -187,7 +230,7 @@ uint64_t __exit(uint64_t code) {
 }
 
 // Helper functions for writing strings to the .fdata file. We intentionally
-// avoid using libc names (lowercase memset) to make it clear it is our impl.
+// avoid using libc names to make it clear it is our impl.
 
 /// Write number Num using Base to the buffer in OutBuf, returns a pointer to
 /// the end of the string.
@@ -231,19 +274,6 @@ int strnCmp(const char *Str1, const char *Str2, size_t Num) {
   return *(unsigned char *)Str1 - *(unsigned char *)Str2;
 }
 
-void memSet(char *Buf, char C, uint32_t Size) {
-  for (int I = 0; I < Size; ++I)
-    *Buf++ = C;
-}
-
-void *memCpy(void *Dest, const void *Src, size_t Len) {
-  char *d = static_cast<char *>(Dest);
-  const char *s = static_cast<const char *>(Src);
-  while (Len--)
-    *d++ = *s++;
-  return Dest;
-}
-
 uint32_t strLen(const char *Str) {
   uint32_t Size = 0;
   while (*Str++)
@@ -468,17 +498,12 @@ void assert(bool Assertion, const char *Msg) {
   reportError(Buf, Ptr - Buf);
 }
 
-/// 1B mutex accessed by lock xchg
 class Mutex {
   volatile bool InUse{false};
 
 public:
-  bool acquire() {
-    bool Result = true;
-    asm volatile("lock; xchg %0, %1" : "+m"(InUse), "=r"(Result) : : "cc");
-    return !Result;
-  }
-  void release() { InUse = false; }
+  bool acquire() { return !__atomic_test_and_set(&InUse, __ATOMIC_ACQUIRE); }
+  void release() { __atomic_clear(&InUse, __ATOMIC_RELEASE); }
 };
 
 /// RAII wrapper for Mutex

bolt/runtime/hugify.cpp

@@ -59,7 +59,7 @@ static void hugify_for_old_kernel(uint8_t *from, uint8_t *to) {
 #endif
 
   // Copy the hot code to a temproary location.
-  memCpy(mem, from, size);
+  memcpy(mem, from, size);
 
   // Maps out the existing hot code.
   if (__mmap(reinterpret_cast<uint64_t>(from), size,
@@ -77,7 +77,7 @@ static void hugify_for_old_kernel(uint8_t *from, uint8_t *to) {
   }
 
   // Copy the hot code back.
-  memCpy(from, mem, size);
+  memcpy(from, mem, size);
 
   // Change permission back to read-only, ignore failure
   __mprotect(from, size, PROT_READ | PROT_EXEC);

bolt/runtime/instr.cpp

@@ -224,15 +224,15 @@ BumpPtrAllocator GlobalAlloc;
 void *operator new(size_t Sz, BumpPtrAllocator &A) { return A.allocate(Sz); }
 void *operator new(size_t Sz, BumpPtrAllocator &A, char C) {
   auto *Ptr = reinterpret_cast<char *>(A.allocate(Sz));
-  memSet(Ptr, C, Sz);
+  memset(Ptr, C, Sz);
   return Ptr;
 }
 void *operator new[](size_t Sz, BumpPtrAllocator &A) {
   return A.allocate(Sz);
 }
 void *operator new[](size_t Sz, BumpPtrAllocator &A, char C) {
   auto *Ptr = reinterpret_cast<char *>(A.allocate(Sz));
-  memSet(Ptr, C, Sz);
+  memset(Ptr, C, Sz);
   return Ptr;
 }
 // Only called during exception unwinding (useless). We must manually dealloc.
@@ -289,6 +289,7 @@ class SimpleHashTable {
   /// Traverses all elements in the table
   template <typename... Args>
   void forEachElement(void (*Callback)(MapEntry &, Args...), Args... args) {
+    Lock L(M);
     if (!TableRoot)
       return;
     return forEachElement(Callback, InitialSize, TableRoot, args...);
@@ -378,7 +379,6 @@ template <typename T> void resetIndCallCounter(T &Entry) {
 
 template <typename T, uint32_t X, uint32_t Y>
 void SimpleHashTable<T, X, Y>::resetCounters() {
-  Lock L(M);
   forEachElement(resetIndCallCounter);
 }
 
@@ -1438,7 +1438,7 @@ int openProfile() {
 /// Where 0xdeadbeef is this function address and PROCESSNAME your binary file
 /// name.
 extern "C" void __bolt_instr_clear_counters() {
-  memSet(reinterpret_cast<char *>(__bolt_instr_locations), 0,
+  memset(reinterpret_cast<char *>(__bolt_instr_locations), 0,
          __bolt_num_counters * 8);
   for (int I = 0; I < __bolt_instr_num_ind_calls; ++I)
     GlobalIndCallCounters[I].resetCounters();

clang-tools-extra/clang-tidy/misc/ConfusableIdentifierCheck.cpp

@@ -127,11 +127,13 @@ static bool mayShadow(const NamedDecl *ND0, const NamedDecl *ND1) {
   const DeclContext *DC1 = ND1->getDeclContext()->getPrimaryContext();
 
   if (const CXXRecordDecl *RD0 = dyn_cast<CXXRecordDecl>(DC0)) {
-    if (ND1->getAccess() != AS_private && isMemberOf(ND1, RD0))
+    RD0 = RD0->getDefinition();
+    if (RD0 && ND1->getAccess() != AS_private && isMemberOf(ND1, RD0))
       return true;
   }
   if (const CXXRecordDecl *RD1 = dyn_cast<CXXRecordDecl>(DC1)) {
-    if (ND0->getAccess() != AS_private && isMemberOf(ND0, RD1))
+    RD1 = RD1->getDefinition();
+    if (RD1 && ND0->getAccess() != AS_private && isMemberOf(ND0, RD1))
       return true;
   }