[BOLT] Add runtime functions required by freestanding environment

[maksfb]

Summary

Compiler can generate calls to some functions implicitly, even under
constraints of freestanding environment. Make sure these functions are
available in our runtime objects.

Fixes test failures on some systems after https://reviews.llvm.org/D128960.

[yota9]

Haha, so much time used nostdlib, but didn't read about such a behaviour, interesting. LGTM, thanks!

[maksfb]

clang-format

bolt/runtime/common.h

#define RESTORE_ALL                                                            \
   "pop %%rbp\n"                                                                \
   "pop %%rsi\n"                                                                \
   "pop %%rdi\n"                                                                \
   "pop %%rdx\n"                                                                \
   "pop %%rcx\n"                                                                \
   "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 {
 
 constexpr uint32_t BufSize = 10240;
 
 #define _STRINGIFY(x) #x
 #define STRINGIFY(x) _STRINGIFY(x)
 
__asm__ __volatile__("movq $" STRINGIFY(EXIT_SYSCALL) ", %%rax\n"
                        "syscall\n"
                        : "=a"(ret)
                        : "D"(code)
                        : "cc", "rcx", "r11", "memory");
   return ret;
 }
 
 // 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.
 char *intToStr(char *OutBuf, uint64_t Num, uint32_t Base) {
   const char *Chars = "0123456789abcdef";
   char Buf[21];
   char *Ptr = Buf;
   while (Num) {
while (Num && *Str1 && (*Str1 == *Str2)) {
     Str1++;
     Str2++;
   }
   if (Num == 0)
     return 0;
   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++)
     ++Size;
   return Size;
 }
 
 void reportNumber(const char *Msg, uint64_t Num, uint32_t Base) {

bolt/runtime/hugify.cpp

if (mem == (void *)MAP_FAILED) {
     char msg[] = "Could not allocate memory for text move\n";
     reportError(msg, sizeof(msg));
   }
 #ifdef ENABLE_DEBUG
   reportNumber("Allocated temporary space: ", (uint64_t)mem, 16);
 #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,
              PROT_READ | PROT_WRITE | PROT_EXEC,
              MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1,
              0) == (void *)MAP_FAILED) {
     char msg[] = "failed to mmap memory for large page move terminating\n";
     reportError(msg, sizeof(msg));
   }
 
   // Mark the hot code page to be huge page.
   if (__madvise(from, size, MADV_HUGEPAGE) == -1) {
     char msg[] = "failed to allocate large page\n";
     reportError(msg, sizeof(msg));
   }
 
   // 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);
 
   __munmap(mem, size);
 }
 #endif
 

bolt/runtime/instr.cpp

 } // anonymous namespace
 
 // User-defined placement new operators. We only use those (as opposed to
 // overriding the regular operator new) so we can keep our allocator in the
 // stack instead of in a data section (global).
 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.
 // C++ language weirdness
 void operator delete(void *Ptr, BumpPtrAllocator &A) { A.deallocate(Ptr); }
 
 namespace {
 

 /// any attached debugger during runtime. There is a useful oneliner for gdb:
 ///
 ///   gdb -p $(pgrep -xo PROCESSNAME) -ex 'p ((void(*)())0xdeadbeef)()' \
 ///     -ex 'set confirm off' -ex quit
 ///
 /// 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();
 }
 
 /// This is the entry point for profile writing.
 /// There are three ways of getting here:
 ///