bolt/runtime/common.h - third_party/llvm-project - Git at Google

 //===- bolt/runtime/common.h ------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//

 #if defined(__linux__)

 #include <cstddef>
 #include <cstdint>

 #include "config.h"

 #ifdef HAVE_ELF_H
 #include <elf.h>
 #endif

 #elif defined(__APPLE__)

 typedef __SIZE_TYPE__ size_t;
 #define __SSIZE_TYPE__                                                         \
   __typeof__(_Generic((__SIZE_TYPE__)0, unsigned long long int                 \
                       : (long long int)0, unsigned long int                    \
                       : (long int)0, unsigned int                              \
                       : (int)0, unsigned short                                 \
                       : (short)0, unsigned char                                \
                       : (signed char)0))
 typedef __SSIZE_TYPE__ ssize_t;

 typedef unsigned long long uint64_t;
 typedef unsigned uint32_t;
 typedef unsigned char uint8_t;

 typedef long long int64_t;
 typedef int int32_t;

 #else
 #error "For Linux or MacOS only"
 #endif

 #define PROT_READ 0x1  /* Page can be read.  */
 #define PROT_WRITE 0x2 /* Page can be written.  */
 #define PROT_EXEC 0x4  /* Page can be executed.  */
 #define PROT_NONE 0x0  /* Page can not be accessed.  */
 #define PROT_GROWSDOWN                                                         \
   0x01000000 /* Extend change to start of                                      \
                 growsdown vma (mprotect only).  */
 #define PROT_GROWSUP                                                           \
   0x02000000 /* Extend change to start of                                      \
                 growsup vma (mprotect only).  */

 /* Sharing types (must choose one and only one of these).  */
 #define MAP_SHARED 0x01  /* Share changes.  */
 #define MAP_PRIVATE 0x02 /* Changes are private.  */
 #define MAP_FIXED 0x10   /* Interpret addr exactly.  */

 #if defined(__APPLE__)
 #define MAP_ANONYMOUS 0x1000
 #else
 #define MAP_ANONYMOUS 0x20
 #endif

 #define MAP_FAILED ((void *)-1)

 #define SEEK_SET 0 /* Seek from beginning of file.  */
 #define SEEK_CUR 1 /* Seek from current position.  */
 #define SEEK_END 2 /* Seek from end of file.  */

 #define O_RDONLY 0
 #define O_WRONLY 1
 #define O_RDWR 2
 #define O_CREAT 64
 #define O_TRUNC 512
 #define O_APPEND 1024

 // 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(void *Buf, int C, size_t Size) {
   char *S = (char *)Buf;
   for (size_t I = 0; I < Size; ++I)
     *S++ = C;
   return Buf;
 }

 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 {

 struct dirent64 {
   uint64_t d_ino;          /* Inode number */
   int64_t d_off;           /* Offset to next linux_dirent */
   unsigned short d_reclen; /* Length of this linux_dirent */
   unsigned char d_type;
   char d_name[]; /* Filename (null-terminated) */
                  /* length is actually (d_reclen - 2 -
                    offsetof(struct linux_dirent, d_name)) */
 };

 /* Length of the entries in `struct utsname' is 65.  */
 #define _UTSNAME_LENGTH 65

 struct UtsNameTy {
   char sysname[_UTSNAME_LENGTH];  /* Operating system name (e.g., "Linux") */
   char nodename[_UTSNAME_LENGTH]; /* Name within "some implementation-defined
                       network" */
   char release[_UTSNAME_LENGTH]; /* Operating system release (e.g., "2.6.28") */
   char version[_UTSNAME_LENGTH]; /* Operating system version */
   char machine[_UTSNAME_LENGTH]; /* Hardware identifier */
   char domainname[_UTSNAME_LENGTH]; /* NIS or YP domain name */
 };

 struct timespec {
   uint64_t tv_sec;  /* seconds */
   uint64_t tv_nsec; /* nanoseconds */
 };

 #if defined(__aarch64__)
 #include "sys_aarch64.h"
 #else
 #include "sys_x86_64.h"
 #endif

 constexpr uint32_t BufSize = 10240;

 // Helper functions for writing strings to the .fdata file. We intentionally
 // 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) {
     *Ptr++ = *(Chars + (Num % Base));
     Num /= Base;
   }
   if (Ptr == Buf) {
     *OutBuf++ = '0';
     return OutBuf;
   }
   while (Ptr != Buf)
     *OutBuf++ = *--Ptr;

   return OutBuf;
 }

 /// Copy Str to OutBuf, returns a pointer to the end of the copied string
 char *strCopy(char *OutBuf, const char *Str, int32_t Size = BufSize) {
   while (*Str) {
     *OutBuf++ = *Str++;
     if (--Size <= 0)
       return OutBuf;
   }
   return OutBuf;
 }

 /// Compare two strings, at most Num bytes.
 int strnCmp(const char *Str1, const char *Str2, size_t Num) {
   while (Num && *Str1 && (*Str1 == *Str2)) {
     Num--;
     Str1++;
     Str2++;
   }
   if (Num == 0)
     return 0;
   return *(unsigned char *)Str1 - *(unsigned char *)Str2;
 }

 uint32_t strLen(const char *Str) {
   uint32_t Size = 0;
   while (*Str++)
     ++Size;
   return Size;
 }

 void *strStr(const char *const Haystack, const char *const Needle) {
   int j = 0;

   for (int i = 0; i < strLen(Haystack); i++) {
     if (Haystack[i] == Needle[0]) {
       for (j = 1; j < strLen(Needle); j++) {
         if (Haystack[i + j] != Needle[j])
           break;
       }
       if (j == strLen(Needle))
         return (void *)&Haystack[i];
     }
   }
   return nullptr;
 }

 void reportNumber(const char *Msg, uint64_t Num, uint32_t Base) {
   char Buf[BufSize];
   char *Ptr = Buf;
   Ptr = strCopy(Ptr, Msg, BufSize - 23);
   Ptr = intToStr(Ptr, Num, Base);
   Ptr = strCopy(Ptr, "\n");
   __write(2, Buf, Ptr - Buf);
 }

 void report(const char *Msg) { __write(2, Msg, strLen(Msg)); }

 unsigned long hexToLong(const char *Str, char Terminator = '\0') {
   unsigned long Res = 0;
   while (*Str != Terminator) {
     Res <<= 4;
     if ('0' <= *Str && *Str <= '9')
       Res += *Str++ - '0';
     else if ('a' <= *Str && *Str <= 'f')
       Res += *Str++ - 'a' + 10;
     else if ('A' <= *Str && *Str <= 'F')
       Res += *Str++ - 'A' + 10;
     else
       return 0;
   }
   return Res;
 }

 /// Starting from character at \p buf, find the longest consecutive sequence
 /// of digits (0-9) and convert it to uint32_t. The converted value
 /// is put into \p ret. \p end marks the end of the buffer to avoid buffer
 /// overflow. The function \returns whether a valid uint32_t value is found.
 /// \p buf will be updated to the next character right after the digits.
 static bool scanUInt32(const char *&Buf, const char *End, uint32_t &Ret) {
   uint64_t Result = 0;
   const char *OldBuf = Buf;
   while (Buf < End && ((*Buf) >= '0' && (*Buf) <= '9')) {
     Result = Result * 10 + (*Buf) - '0';
     ++Buf;
   }
   if (OldBuf != Buf && Result <= 0xFFFFFFFFu) {
     Ret = static_cast<uint32_t>(Result);
     return true;
   }
   return false;
 }

 void reportError(const char *Msg, uint64_t Size) {
   __write(2, Msg, Size);
   __exit(1);
 }

 void assert(bool Assertion, const char *Msg) {
   if (Assertion)
     return;
   char Buf[BufSize];
   char *Ptr = Buf;
   Ptr = strCopy(Ptr, "Assertion failed: ");
   Ptr = strCopy(Ptr, Msg, BufSize - 40);
   Ptr = strCopy(Ptr, "\n");
   reportError(Buf, Ptr - Buf);
 }

 #define SIG_BLOCK 0
 #define SIG_UNBLOCK 1
 #define SIG_SETMASK 2

 static const uint64_t MaskAllSignals[] = {-1ULL};

 class Mutex {
   volatile bool InUse{false};

 public:
   bool acquire() { return !__atomic_test_and_set(&InUse, __ATOMIC_ACQUIRE); }
   void release() { __atomic_clear(&InUse, __ATOMIC_RELEASE); }
 };

 /// RAII wrapper for Mutex
 class Lock {
   Mutex &M;
   uint64_t SignalMask[1] = {};

 public:
   Lock(Mutex &M) : M(M) {
     __sigprocmask(SIG_BLOCK, MaskAllSignals, SignalMask);
     while (!M.acquire()) {
     }
   }

   ~Lock() {
     M.release();
     __sigprocmask(SIG_SETMASK, SignalMask, nullptr);
   }
 };

 /// RAII wrapper for Mutex
 class TryLock {
   Mutex &M;
   bool Locked = false;

 public:
   TryLock(Mutex &M) : M(M) {
     int Retry = 100;
     while (--Retry && !M.acquire())
       ;
     if (Retry)
       Locked = true;
   }
   bool isLocked() { return Locked; }

   ~TryLock() {
     if (isLocked())
       M.release();
   }
 };

 inline uint64_t alignTo(uint64_t Value, uint64_t Align) {
   return (Value + Align - 1) / Align * Align;
 }

 } // anonymous namespace
	//===- bolt/runtime/common.h ------------------------------------- C++ --===//
	//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//
	//===----------------------------------------------------------------------===//

	#if defined(__linux__)

	#include <cstddef>
	#include <cstdint>

	#include "config.h"

	#ifdef HAVE_ELF_H
	#include <elf.h>
	#endif

	#elif defined(__APPLE__)

	typedef __SIZE_TYPE__ size_t;
	#define __SSIZE_TYPE__ \
	__typeof__(_Generic((__SIZE_TYPE__)0, unsigned long long int \
	: (long long int)0, unsigned long int \
	: (long int)0, unsigned int \
	: (int)0, unsigned short \
	: (short)0, unsigned char \
	: (signed char)0))
	typedef __SSIZE_TYPE__ ssize_t;

	typedef unsigned long long uint64_t;
	typedef unsigned uint32_t;
	typedef unsigned char uint8_t;

	typedef long long int64_t;
	typedef int int32_t;

	#else
	#error "For Linux or MacOS only"
	#endif

	#define PROT_READ 0x1 /* Page can be read. */
	#define PROT_WRITE 0x2 /* Page can be written. */
	#define PROT_EXEC 0x4 /* Page can be executed. */
	#define PROT_NONE 0x0 /* Page can not be accessed. */
	#define PROT_GROWSDOWN \
	0x01000000 /* Extend change to start of \
	growsdown vma (mprotect only). */
	#define PROT_GROWSUP \
	0x02000000 /* Extend change to start of \
	growsup vma (mprotect only). */

	/* Sharing types (must choose one and only one of these). */
	#define MAP_SHARED 0x01 /* Share changes. */
	#define MAP_PRIVATE 0x02 /* Changes are private. */
	#define MAP_FIXED 0x10 /* Interpret addr exactly. */

	#if defined(__APPLE__)
	#define MAP_ANONYMOUS 0x1000
	#else
	#define MAP_ANONYMOUS 0x20
	#endif

	#define MAP_FAILED ((void *)-1)

	#define SEEK_SET 0 /* Seek from beginning of file. */
	#define SEEK_CUR 1 /* Seek from current position. */
	#define SEEK_END 2 /* Seek from end of file. */

	#define O_RDONLY 0
	#define O_WRONLY 1
	#define O_RDWR 2
	#define O_CREAT 64
	#define O_TRUNC 512
	#define O_APPEND 1024

	// 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(void Buf, int C, size_t Size) {
	char S = (char )Buf;
	for (size_t I = 0; I < Size; ++I)
	*S++ = C;
	return Buf;
	}

	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 {

	struct dirent64 {
	uint64_t d_ino; /* Inode number */
	int64_t d_off; /* Offset to next linux_dirent */
	unsigned short d_reclen; /* Length of this linux_dirent */
	unsigned char d_type;
	char d_name[]; /* Filename (null-terminated) */
	/* length is actually (d_reclen - 2 -
	offsetof(struct linux_dirent, d_name)) */
	};

	/* Length of the entries in `struct utsname' is 65. */
	#define _UTSNAME_LENGTH 65

	struct UtsNameTy {
	char sysname[_UTSNAME_LENGTH]; /* Operating system name (e.g., "Linux") */
	char nodename[_UTSNAME_LENGTH]; /* Name within "some implementation-defined
	network" */
	char release[_UTSNAME_LENGTH]; /* Operating system release (e.g., "2.6.28") */
	char version[_UTSNAME_LENGTH]; /* Operating system version */
	char machine[_UTSNAME_LENGTH]; /* Hardware identifier */
	char domainname[_UTSNAME_LENGTH]; /* NIS or YP domain name */
	};

	struct timespec {
	uint64_t tv_sec; /* seconds */
	uint64_t tv_nsec; /* nanoseconds */
	};

	#if defined(__aarch64__)
	#include "sys_aarch64.h"
	#else
	#include "sys_x86_64.h"
	#endif

	constexpr uint32_t BufSize = 10240;

	// Helper functions for writing strings to the .fdata file. We intentionally
	// 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) {
	Ptr++ = (Chars + (Num % Base));
	Num /= Base;
	}
	if (Ptr == Buf) {
	*OutBuf++ = '0';
	return OutBuf;
	}
	while (Ptr != Buf)
	OutBuf++ = --Ptr;

	return OutBuf;
	}

	/// Copy Str to OutBuf, returns a pointer to the end of the copied string
	char strCopy(char OutBuf, const char *Str, int32_t Size = BufSize) {
	while (*Str) {
	OutBuf++ = Str++;
	if (--Size <= 0)
	return OutBuf;
	}
	return OutBuf;
	}

	/// Compare two strings, at most Num bytes.
	int strnCmp(const char Str1, const char Str2, size_t Num) {
	while (Num && Str1 && (Str1 == *Str2)) {
	Num--;
	Str1++;
	Str2++;
	}
	if (Num == 0)
	return 0;
	return (unsigned char )Str1 - (unsigned char )Str2;
	}

	uint32_t strLen(const char *Str) {
	uint32_t Size = 0;
	while (*Str++)
	++Size;
	return Size;
	}

	void strStr(const char const Haystack, const char *const Needle) {
	int j = 0;

	for (int i = 0; i < strLen(Haystack); i++) {
	if (Haystack[i] == Needle[0]) {
	for (j = 1; j < strLen(Needle); j++) {
	if (Haystack[i + j] != Needle[j])
	break;
	}
	if (j == strLen(Needle))
	return (void *)&Haystack[i];
	}
	}
	return nullptr;
	}

	void reportNumber(const char *Msg, uint64_t Num, uint32_t Base) {
	char Buf[BufSize];
	char *Ptr = Buf;
	Ptr = strCopy(Ptr, Msg, BufSize - 23);
	Ptr = intToStr(Ptr, Num, Base);
	Ptr = strCopy(Ptr, "\n");
	__write(2, Buf, Ptr - Buf);
	}

	void report(const char *Msg) { __write(2, Msg, strLen(Msg)); }

	unsigned long hexToLong(const char *Str, char Terminator = '\0') {
	unsigned long Res = 0;
	while (*Str != Terminator) {
	Res <<= 4;
	if ('0' <= Str && Str <= '9')
	Res += *Str++ - '0';
	else if ('a' <= Str && Str <= 'f')
	Res += *Str++ - 'a' + 10;
	else if ('A' <= Str && Str <= 'F')
	Res += *Str++ - 'A' + 10;
	else
	return 0;
	}
	return Res;
	}

	/// Starting from character at \p buf, find the longest consecutive sequence
	/// of digits (0-9) and convert it to uint32_t. The converted value
	/// is put into \p ret. \p end marks the end of the buffer to avoid buffer
	/// overflow. The function \returns whether a valid uint32_t value is found.
	/// \p buf will be updated to the next character right after the digits.
	static bool scanUInt32(const char &Buf, const char End, uint32_t &Ret) {
	uint64_t Result = 0;
	const char *OldBuf = Buf;
	while (Buf < End && ((Buf) >= '0' && (Buf) <= '9')) {
	Result = Result * 10 + (*Buf) - '0';
	++Buf;
	}
	if (OldBuf != Buf && Result <= 0xFFFFFFFFu) {
	Ret = static_cast<uint32_t>(Result);
	return true;
	}
	return false;
	}

	void reportError(const char *Msg, uint64_t Size) {
	__write(2, Msg, Size);
	__exit(1);
	}

	void assert(bool Assertion, const char *Msg) {
	if (Assertion)
	return;
	char Buf[BufSize];
	char *Ptr = Buf;
	Ptr = strCopy(Ptr, "Assertion failed: ");
	Ptr = strCopy(Ptr, Msg, BufSize - 40);
	Ptr = strCopy(Ptr, "\n");
	reportError(Buf, Ptr - Buf);
	}

	#define SIG_BLOCK 0
	#define SIG_UNBLOCK 1
	#define SIG_SETMASK 2

	static const uint64_t MaskAllSignals[] = {-1ULL};

	class Mutex {
	volatile bool InUse{false};

	public:
	bool acquire() { return !__atomic_test_and_set(&InUse, __ATOMIC_ACQUIRE); }
	void release() { __atomic_clear(&InUse, __ATOMIC_RELEASE); }
	};

	/// RAII wrapper for Mutex
	class Lock {
	Mutex &M;
	uint64_t SignalMask[1] = {};

	public:
	Lock(Mutex &M) : M(M) {
	__sigprocmask(SIG_BLOCK, MaskAllSignals, SignalMask);
	while (!M.acquire()) {
	}
	}

	~Lock() {
	M.release();
	__sigprocmask(SIG_SETMASK, SignalMask, nullptr);
	}
	};

	/// RAII wrapper for Mutex
	class TryLock {
	Mutex &M;
	bool Locked = false;

	public:
	TryLock(Mutex &M) : M(M) {
	int Retry = 100;
	while (--Retry && !M.acquire())
	;
	if (Retry)
	Locked = true;
	}
	bool isLocked() { return Locked; }

	~TryLock() {
	if (isLocked())
	M.release();
	}
	};

	inline uint64_t alignTo(uint64_t Value, uint64_t Align) {
	return (Value + Align - 1) / Align * Align;
	}

	} // anonymous namespace