text: /*===- InstrProfilingUtil.c - Support library for PGO instrumentation -----===*\
  |*
  |* 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
  |*
  \*===----------------------------------------------------------------------===*/
  
  #ifdef _WIN32
  #include <direct.h>
  #include <process.h>
  #include <windows.h>
  #include "WindowsMMap.h"
  #else
  #include <errno.h>
  #include <fcntl.h>
  #include <sys/file.h>
  #include <sys/mman.h>
  #include <sys/stat.h>
  #include <sys/types.h>
  #include <unistd.h>
  #endif
  
  #ifdef COMPILER_RT_HAS_UNAME
  #include <sys/utsname.h>
  #endif
  
  #include <stdlib.h>
  #include <string.h>
  
  #if defined(__linux__)
  #include <signal.h>
  #include <sys/prctl.h>
  #endif
  
  #if defined(__Fuchsia__)
  #include <zircon/process.h>
  #include <zircon/syscalls.h>
  #endif
  
  #include "InstrProfiling.h"
  #include "InstrProfilingUtil.h"
  
  COMPILER_RT_WEAK unsigned lprofDirMode = 0755;
  
  COMPILER_RT_VISIBILITY
  void __llvm_profile_recursive_mkdir(char *path) {
    int i;
    int start = 1;
  
  #if defined(__ANDROID__) && defined(__ANDROID_API__) &&                        \
      defined(__ANDROID_API_FUTURE__) &&                                         \
      __ANDROID_API__ == __ANDROID_API_FUTURE__
    // Avoid spammy selinux denial messages in Android by not attempting to
    // create directories in GCOV_PREFIX.  These denials occur when creating (or
    // even attempting to stat()) top-level directories like "/data".
    //
    // Do so by ignoring ${GCOV_PREFIX} when invoking mkdir().
    const char *gcov_prefix = getenv("GCOV_PREFIX");
    if (gcov_prefix != NULL) {
      const int gcov_prefix_len = strlen(gcov_prefix);
      if (strncmp(path, gcov_prefix, gcov_prefix_len) == 0)
        start = gcov_prefix_len;
    }
  #endif
  
    for (i = start; path[i] != '\0'; ++i) {
      char save = path[i];
      if (!IS_DIR_SEPARATOR(path[i]))
        continue;
      path[i] = '\0';
  #ifdef _WIN32
      _mkdir(path);
  #else
      /* Some of these will fail, ignore it. */
      mkdir(path, __llvm_profile_get_dir_mode());
  #endif
      path[i] = save;
    }
  }
  
  COMPILER_RT_VISIBILITY
  void __llvm_profile_set_dir_mode(unsigned Mode) { lprofDirMode = Mode; }
  
  COMPILER_RT_VISIBILITY
  unsigned __llvm_profile_get_dir_mode(void) { return lprofDirMode; }
  
  #if COMPILER_RT_HAS_ATOMICS != 1
  COMPILER_RT_VISIBILITY
  uint32_t lprofBoolCmpXchg(void **Ptr, void *OldV, void *NewV) {
    void *R = *Ptr;
    if (R == OldV) {
      *Ptr = NewV;
      return 1;
    }
    return 0;
  }
  COMPILER_RT_VISIBILITY
  void *lprofPtrFetchAdd(void **Mem, long ByteIncr) {
    void *Old = *Mem;
    *((char **)Mem) += ByteIncr;
    return Old;
  }
  
  #endif
  
  #ifdef _WIN32
  COMPILER_RT_VISIBILITY int lprofGetHostName(char *Name, int Len) {
    WCHAR Buffer[COMPILER_RT_MAX_HOSTLEN];
    DWORD BufferSize = sizeof(Buffer);
    BOOL Result =
        GetComputerNameExW(ComputerNameDnsFullyQualified, Buffer, &BufferSize);
    if (!Result)
      return -1;
    if (WideCharToMultiByte(CP_UTF8, 0, Buffer, -1, Name, Len, NULL, NULL) == 0)
      return -1;
    return 0;
  }
  #elif defined(COMPILER_RT_HAS_UNAME)
  COMPILER_RT_VISIBILITY int lprofGetHostName(char *Name, int Len) {
    struct utsname N;
    int R = uname(&N);
    if (R >= 0) {
      strncpy(Name, N.nodename, Len);
      return 0;
    }
    return R;
  }
  #endif
  
  COMPILER_RT_VISIBILITY int lprofLockFd(int fd) {
  #ifdef COMPILER_RT_HAS_FCNTL_LCK
    struct flock s_flock;
  
    s_flock.l_whence = SEEK_SET;
    s_flock.l_start = 0;
    s_flock.l_len = 0; /* Until EOF.  */
    s_flock.l_pid = getpid();
    s_flock.l_type = F_WRLCK;
  
    while (fcntl(fd, F_SETLKW, &s_flock) == -1) {
      if (errno != EINTR) {
        if (errno == ENOLCK) {
          return -1;
        }
        break;
      }
    }
    return 0;
  #else
    flock(fd, LOCK_EX);
    return 0;
  #endif
  }
  
  COMPILER_RT_VISIBILITY int lprofUnlockFd(int fd) {
  #ifdef COMPILER_RT_HAS_FCNTL_LCK
    struct flock s_flock;
  
    s_flock.l_whence = SEEK_SET;
    s_flock.l_start = 0;
    s_flock.l_len = 0; /* Until EOF.  */
    s_flock.l_pid = getpid();
    s_flock.l_type = F_UNLCK;
  
    while (fcntl(fd, F_SETLKW, &s_flock) == -1) {
      if (errno != EINTR) {
        if (errno == ENOLCK) {
          return -1;
        }
        break;
      }
    }
    return 0;
  #else
    flock(fd, LOCK_UN);
    return 0;
  #endif
  }
  
  COMPILER_RT_VISIBILITY int lprofLockFileHandle(FILE *F) {
    int fd;
  #if defined(_WIN32)
    fd = _fileno(F);
  #else
    fd = fileno(F);
  #endif
    return lprofLockFd(fd);
  }
  
  COMPILER_RT_VISIBILITY int lprofUnlockFileHandle(FILE *F) {
    int fd;
  #if defined(_WIN32)
    fd = _fileno(F);
  #else
    fd = fileno(F);
  #endif
    return lprofUnlockFd(fd);
  }
  
  COMPILER_RT_VISIBILITY FILE *lprofOpenFileEx(const char *ProfileName) {
    FILE *f;
    int fd;
  #ifdef COMPILER_RT_HAS_FCNTL_LCK
    fd = open(ProfileName, O_RDWR | O_CREAT, 0666);
    if (fd < 0)
      return NULL;
  
    if (lprofLockFd(fd) != 0)
      PROF_WARN("Data may be corrupted during profile merging : %s\n",
                "Fail to obtain file lock due to system limit.");
  
    f = fdopen(fd, "r+b");
  #elif defined(_WIN32)
    // FIXME: Use the wide variants to handle Unicode filenames.
    HANDLE h = CreateFileA(ProfileName, GENERIC_READ | GENERIC_WRITE,
                           FILE_SHARE_READ | FILE_SHARE_WRITE, 0, OPEN_ALWAYS,
                           FILE_ATTRIBUTE_NORMAL, 0);
    if (h == INVALID_HANDLE_VALUE)
      return NULL;
  
    fd = _open_osfhandle((intptr_t)h, 0);
    if (fd == -1) {
      CloseHandle(h);
      return NULL;
    }
  
    if (lprofLockFd(fd) != 0)
      PROF_WARN("Data may be corrupted during profile merging : %s\n",
                "Fail to obtain file lock due to system limit.");
  
    f = _fdopen(fd, "r+b");
    if (f == 0) {
      CloseHandle(h);
      return NULL;
    }
  #else
    /* Worst case no locking applied.  */
    PROF_WARN("Concurrent file access is not supported : %s\n",
              "lack file locking");
    fd = open(ProfileName, O_RDWR | O_CREAT, 0666);
    if (fd < 0)
      return NULL;
    f = fdopen(fd, "r+b");
  #endif
  
    return f;
  }
  
  COMPILER_RT_VISIBILITY const char *lprofGetPathPrefix(int *PrefixStrip,
                                                        size_t *PrefixLen) {
    const char *Prefix = getenv("GCOV_PREFIX");
    const char *PrefixStripStr = getenv("GCOV_PREFIX_STRIP");
  
    *PrefixLen = 0;
    *PrefixStrip = 0;
    if (Prefix == NULL || Prefix[0] == '\0')
      return NULL;
  
    if (PrefixStripStr) {
      *PrefixStrip = atoi(PrefixStripStr);
  
      /* Negative GCOV_PREFIX_STRIP values are ignored */
      if (*PrefixStrip < 0)
        *PrefixStrip = 0;
    } else {
      *PrefixStrip = 0;
    }
    *PrefixLen = strlen(Prefix);
  
    return Prefix;
  }
  
  COMPILER_RT_VISIBILITY void
  lprofApplyPathPrefix(char *Dest, const char *PathStr, const char *Prefix,
                       size_t PrefixLen, int PrefixStrip) {
  
    const char *Ptr;
    int Level;
    const char *StrippedPathStr = PathStr;
  
    for (Level = 0, Ptr = PathStr + 1; Level < PrefixStrip; ++Ptr) {
      if (*Ptr == '\0')
        break;
  
      if (!IS_DIR_SEPARATOR(*Ptr))
        continue;
  
      StrippedPathStr = Ptr;
      ++Level;
    }
  
    memcpy(Dest, Prefix, PrefixLen);
  
    if (!IS_DIR_SEPARATOR(Prefix[PrefixLen - 1]))
      Dest[PrefixLen++] = DIR_SEPARATOR;
  
    memcpy(Dest + PrefixLen, StrippedPathStr, strlen(StrippedPathStr) + 1);
  }
  
  COMPILER_RT_VISIBILITY const char *
  lprofFindFirstDirSeparator(const char *Path) {
    const char *Sep = strchr(Path, DIR_SEPARATOR);
  #if defined(DIR_SEPARATOR_2)
    const char *Sep2 = strchr(Path, DIR_SEPARATOR_2);
    if (Sep2 && (!Sep || Sep2 < Sep))
      Sep = Sep2;
  #endif
    return Sep;
  }
  
  COMPILER_RT_VISIBILITY const char *lprofFindLastDirSeparator(const char *Path) {
    const char *Sep = strrchr(Path, DIR_SEPARATOR);
  #if defined(DIR_SEPARATOR_2)
    const char *Sep2 = strrchr(Path, DIR_SEPARATOR_2);
    if (Sep2 && (!Sep || Sep2 > Sep))
      Sep = Sep2;
  #endif
    return Sep;
  }
  
  COMPILER_RT_VISIBILITY int lprofSuspendSigKill() {
  #if defined(__linux__)
    int PDeachSig = 0;
    /* Temporarily suspend getting SIGKILL upon exit of the parent process. */
    if (prctl(PR_GET_PDEATHSIG, &PDeachSig) == 0 && PDeachSig == SIGKILL)
      prctl(PR_SET_PDEATHSIG, 0);
    return (PDeachSig == SIGKILL);
  #else
    return 0;
  #endif
  }
  
  COMPILER_RT_VISIBILITY void lprofRestoreSigKill() {
  #if defined(__linux__)
    prctl(PR_SET_PDEATHSIG, SIGKILL);
  #endif
  }
  
  COMPILER_RT_VISIBILITY int lprofReleaseMemoryPagesToOS(uintptr_t Begin,
                                                         uintptr_t End) {
    size_t PageSize = getpagesize();
    uintptr_t BeginAligned = lprofRoundUpTo((uintptr_t)Begin, PageSize);
    uintptr_t EndAligned = lprofRoundDownTo((uintptr_t)End, PageSize);
    if (BeginAligned < EndAligned) {
  #if defined(__Fuchsia__)
      return _zx_vmar_op_range(_zx_vmar_root_self(), ZX_VMAR_OP_DECOMMIT,
                               (zx_vaddr_t)BeginAligned,
                               EndAligned - BeginAligned, NULL, 0);
  #else
      return madvise((void *)BeginAligned, EndAligned - BeginAligned,
                     MADV_DONTNEED);
  #endif
    }
    return 0;
  }
  