contrib/compiler-rt/lib/profile/InstrProfilingUtil.c

   1 /*===- InstrProfilingUtil.c - Support library for PGO instrumentation -----===*\
   2 |*
   3 |*                     The LLVM Compiler Infrastructure
   4 |*
   5 |* This file is distributed under the University of Illinois Open Source
   6 |* License. See LICENSE.TXT for details.
   7 |*
   8 \*===----------------------------------------------------------------------===*/
   9
  10 #ifdef _WIN32
  11 #include <direct.h>
  12 #include <process.h>
  13 #include <windows.h>
  14 #include "WindowsMMap.h"
  15 #else
  16 #include <sys/stat.h>
  17 #include <sys/types.h>
  18 #include <unistd.h>
  19 #include <fcntl.h>
  20 #include <errno.h>
  21 #endif
  22
  23 #ifdef COMPILER_RT_HAS_UNAME
  24 #include <sys/utsname.h>
  25 #endif
  26
  27 #include <stdlib.h>
  28 #include <string.h>
  29
  30 #if defined(__linux__)
  31 #include <signal.h>
  32 #include <sys/prctl.h>
  33 #endif
  34
  35 #include "InstrProfiling.h"
  36 #include "InstrProfilingUtil.h"
  37
  38 COMPILER_RT_WEAK unsigned lprofDirMode = 0755;
  39
  40 COMPILER_RT_VISIBILITY
  41 void __llvm_profile_recursive_mkdir(char *path) {
  42   int i;
  43
  44   for (i = 1; path[i] != '\0'; ++i) {
  45     char save = path[i];
  46     if (!IS_DIR_SEPARATOR(path[i]))
  47       continue;
  48     path[i] = '\0';
  49 #ifdef _WIN32
  50     _mkdir(path);
  51 #else
  52     /* Some of these will fail, ignore it. */
  53     mkdir(path, __llvm_profile_get_dir_mode());
  54 #endif
  55     path[i] = save;
  56   }
  57 }
  58
  59 COMPILER_RT_VISIBILITY
  60 void __llvm_profile_set_dir_mode(unsigned Mode) { lprofDirMode = Mode; }
  61
  62 COMPILER_RT_VISIBILITY
  63 unsigned __llvm_profile_get_dir_mode(void) { return lprofDirMode; }
  64
  65 #if COMPILER_RT_HAS_ATOMICS != 1
  66 COMPILER_RT_VISIBILITY
  67 uint32_t lprofBoolCmpXchg(void **Ptr, void *OldV, void *NewV) {
  68   void *R = *Ptr;
  69   if (R == OldV) {
  70     *Ptr = NewV;
  71     return 1;
  72   }
  73   return 0;
  74 }
  75 COMPILER_RT_VISIBILITY
  76 void *lprofPtrFetchAdd(void **Mem, long ByteIncr) {
  77   void *Old = *Mem;
  78   *((char **)Mem) += ByteIncr;
  79   return Old;
  80 }
  81
  82 #endif
  83
  84 #ifdef _MSC_VER
  85 COMPILER_RT_VISIBILITY int lprofGetHostName(char *Name, int Len) {
  86   WCHAR Buffer[COMPILER_RT_MAX_HOSTLEN];
  87   DWORD BufferSize = sizeof(Buffer);
  88   BOOL Result =
  89       GetComputerNameExW(ComputerNameDnsFullyQualified, Buffer, &BufferSize);
  90   if (!Result)
  91     return -1;
  92   if (WideCharToMultiByte(CP_UTF8, 0, Buffer, -1, Name, Len, NULL, NULL) == 0)
  93     return -1;
  94   return 0;
  95 }
  96 #elif defined(COMPILER_RT_HAS_UNAME)
  97 COMPILER_RT_VISIBILITY int lprofGetHostName(char *Name, int Len) {
  98   struct utsname N;
  99   int R = uname(&N);
 100   if (R >= 0) {
 101     strncpy(Name, N.nodename, Len);
 102     return 0;
 103   }
 104   return R;
 105 }
 106 #endif
 107
 108 COMPILER_RT_VISIBILITY int lprofLockFd(int fd) {
 109 #ifdef COMPILER_RT_HAS_FCNTL_LCK
 110   struct flock s_flock;
 111
 112   s_flock.l_whence = SEEK_SET;
 113   s_flock.l_start = 0;
 114   s_flock.l_len = 0; /* Until EOF.  */
 115   s_flock.l_pid = getpid();
 116   s_flock.l_type = F_WRLCK;
 117
 118   while (fcntl(fd, F_SETLKW, &s_flock) == -1) {
 119     if (errno != EINTR) {
 120       if (errno == ENOLCK) {
 121         return -1;
 122       }
 123       break;
 124     }
 125   }
 126   return 0;
 127 #else
 128   flock(fd, LOCK_EX);
 129   return 0;
 130 #endif
 131 }
 132
 133 COMPILER_RT_VISIBILITY int lprofUnlockFd(int fd) {
 134 #ifdef COMPILER_RT_HAS_FCNTL_LCK
 135   struct flock s_flock;
 136
 137   s_flock.l_whence = SEEK_SET;
 138   s_flock.l_start = 0;
 139   s_flock.l_len = 0; /* Until EOF.  */
 140   s_flock.l_pid = getpid();
 141   s_flock.l_type = F_UNLCK;
 142
 143   while (fcntl(fd, F_SETLKW, &s_flock) == -1) {
 144     if (errno != EINTR) {
 145       if (errno == ENOLCK) {
 146         return -1;
 147       }
 148       break;
 149     }
 150   }
 151   return 0;
 152 #else
 153   flock(fd, LOCK_UN);
 154   return 0;
 155 #endif
 156 }
 157
 158 COMPILER_RT_VISIBILITY FILE *lprofOpenFileEx(const char *ProfileName) {
 159   FILE *f;
 160   int fd;
 161 #ifdef COMPILER_RT_HAS_FCNTL_LCK
 162   fd = open(ProfileName, O_RDWR | O_CREAT, 0666);
 163   if (fd < 0)
 164     return NULL;
 165
 166   if (lprofLockFd(fd) != 0)
 167     PROF_WARN("Data may be corrupted during profile merging : %s\n",
 168               "Fail to obtain file lock due to system limit.");
 169
 170   f = fdopen(fd, "r+b");
 171 #elif defined(_WIN32)
 172   // FIXME: Use the wide variants to handle Unicode filenames.
 173   HANDLE h = CreateFileA(ProfileName, GENERIC_READ | GENERIC_WRITE, 0, 0,
 174                          OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
 175   if (h == INVALID_HANDLE_VALUE)
 176     return NULL;
 177
 178   fd = _open_osfhandle((intptr_t)h, 0);
 179   if (fd == -1) {
 180     CloseHandle(h);
 181     return NULL;
 182   }
 183
 184   f = _fdopen(fd, "r+b");
 185   if (f == 0) {
 186     CloseHandle(h);
 187     return NULL;
 188   }
 189 #else
 190   /* Worst case no locking applied.  */
 191   PROF_WARN("Concurrent file access is not supported : %s\n",
 192             "lack file locking");
 193   fd = open(ProfileName, O_RDWR | O_CREAT, 0666);
 194   if (fd < 0)
 195     return NULL;
 196   f = fdopen(fd, "r+b");
 197 #endif
 198
 199   return f;
 200 }
 201
 202 COMPILER_RT_VISIBILITY const char *lprofGetPathPrefix(int *PrefixStrip,
 203                                                       size_t *PrefixLen) {
 204   const char *Prefix = getenv("GCOV_PREFIX");
 205   const char *PrefixStripStr = getenv("GCOV_PREFIX_STRIP");
 206
 207   *PrefixLen = 0;
 208   *PrefixStrip = 0;
 209   if (Prefix == NULL || Prefix[0] == '\0')
 210     return NULL;
 211
 212   if (PrefixStripStr) {
 213     *PrefixStrip = atoi(PrefixStripStr);
 214
 215     /* Negative GCOV_PREFIX_STRIP values are ignored */
 216     if (*PrefixStrip < 0)
 217       *PrefixStrip = 0;
 218   } else {
 219     *PrefixStrip = 0;
 220   }
 221   *PrefixLen = strlen(Prefix);
 222
 223   return Prefix;
 224 }
 225
 226 COMPILER_RT_VISIBILITY void
 227 lprofApplyPathPrefix(char *Dest, const char *PathStr, const char *Prefix,
 228                      size_t PrefixLen, int PrefixStrip) {
 229
 230   const char *Ptr;
 231   int Level;
 232   const char *StrippedPathStr = PathStr;
 233
 234   for (Level = 0, Ptr = PathStr + 1; Level < PrefixStrip; ++Ptr) {
 235     if (*Ptr == '\0')
 236       break;
 237
 238     if (!IS_DIR_SEPARATOR(*Ptr))
 239       continue;
 240
 241     StrippedPathStr = Ptr;
 242     ++Level;
 243   }
 244
 245   memcpy(Dest, Prefix, PrefixLen);
 246
 247   if (!IS_DIR_SEPARATOR(Prefix[PrefixLen - 1]))
 248     Dest[PrefixLen++] = DIR_SEPARATOR;
 249
 250   memcpy(Dest + PrefixLen, StrippedPathStr, strlen(StrippedPathStr) + 1);
 251 }
 252
 253 COMPILER_RT_VISIBILITY const char *
 254 lprofFindFirstDirSeparator(const char *Path) {
 255   const char *Sep = strchr(Path, DIR_SEPARATOR);
 256 #if defined(DIR_SEPARATOR_2)
 257   const char *Sep2 = strchr(Path, DIR_SEPARATOR_2);
 258   if (Sep2 && (!Sep || Sep2 < Sep))
 259     Sep = Sep2;
 260 #endif
 261   return Sep;
 262 }
 263
 264 COMPILER_RT_VISIBILITY const char *lprofFindLastDirSeparator(const char *Path) {
 265   const char *Sep = strrchr(Path, DIR_SEPARATOR);
 266 #if defined(DIR_SEPARATOR_2)
 267   const char *Sep2 = strrchr(Path, DIR_SEPARATOR_2);
 268   if (Sep2 && (!Sep || Sep2 > Sep))
 269     Sep = Sep2;
 270 #endif
 271   return Sep;
 272 }
 273
 274 COMPILER_RT_VISIBILITY int lprofSuspendSigKill() {
 275 #if defined(__linux__)
 276   int PDeachSig = 0;
 277   /* Temporarily suspend getting SIGKILL upon exit of the parent process. */
 278   if (prctl(PR_GET_PDEATHSIG, &PDeachSig) == 0 && PDeachSig == SIGKILL)
 279     prctl(PR_SET_PDEATHSIG, 0);
 280   return (PDeachSig == SIGKILL);
 281 #else
 282   return 0;
 283 #endif
 284 }
 285
 286 COMPILER_RT_VISIBILITY void lprofRestoreSigKill() {
 287 #if defined(__linux__)
 288   prctl(PR_SET_PDEATHSIG, SIGKILL);
 289 #endif
 290 }