[profile] Enable on Solaris

[ro]

Summary

The test/asan/TestCases/asan_and_llvm_coverage_test.cc failed to link on Solaris
since libclang_rt.profile was missing. Instead of trying to document that requirement
in the test, I just tried to enable the library on Solaris instead.

Most changes are probably straightforward, but two bear explanation:

• The getpid prototype in lib/profile/InstrProfilingFile.c conflicted with the system one (returning pid_t instead of instead), so I removed it.

• While parts of the profile library prefer fcntl(F_SETLCKW) over flock(LOCK_EX) if available, others unconditionally use flock. flock just doesn't exist on Solaris, so I moved the locking to common code.

[vsk]

lib/profile/GCDAProfiling.c

33–34

Why not migrate O_BINARY to the common header as well?

lib/profile/InstrProfilingUtil.c

118

Is flock available on Windows? If not, please handle that case by reporting a warning, and document the limitation near the header declarations of lprof(Un)lockFd.

136

Please clang-format your changes.

[ro]

lib/profile/GCDAProfiling.c

33–34

Looking closer, I see that both MAP_FILE and O_BINARY
are problematic: InstrProfilingPort.h and/or InstrProfiling.h
are included before system headers, but such fallback definitions
need to come after those had a chance to provide the real
definitions. To fix this, either the system header includes
need to be moved to the InstProfiling{Port,}.h files or those
need to be included after system headers. WDYT?

lib/profile/InstrProfilingUtil.c

118

I guess so: even before my patch, it was used unconditionally
in GCDAProfiling.c which is common code.

136

Will do: I missed this because formatting errors in may
sanitizer patches were pointed out during the build, so I assumed
this applied to all of compiler-rt (or even llvm).

[vsk]

lib/profile/GCDAProfiling.c

33–34

Moving the InstrProfiling*.h imports after the system header imports sgtm, but please add a short comment there explaining why we're relying on that sort of textual #include (it goes against typical llvm practice).

[ro]

I've moved the InstrProfiling*.h after the system headers now (without a comment
yet because it's unclear where best to put it), but there are reasons to also include them
early:

COMPILER_RT_HAS_UNAME was defined in InstrProfilingPort.h and used to control
whether or not to include <sys/utsname.h>. When InstrProfilingPort.h is included later,
this won't work, so I moved the check for <sys/utsname.h> to CMakeLists.txt.
Initially, this didn't work as expected: I tried check_include_file. Although checking for
a header could be a compile-only test, that function tries to link, which fails since
cmake/config-ix.cmake adds -nodefaultlibs to CMAKE_REQUIRED_FLAGS, so both
the startup files and libc are missing and the link fails.

Besides, I now print getpid() as long (which it can be on Solaris), avoiding a warning.

uname(2) is documented in POSIX.1-2008 to be non-negative on success (and
Solaris returns 1), while InstrProfilingUtil.c (lprofGetHostName) only expects the
0 return value found on Linux.

Last but not least, I found that I'd overlooked to enable the profile tests. With
a version of Solaris ld that supports the non-standard GNU ld extension of adding
start_SECNAME and stop_SECNAME labels to sections whose names are valid
as C identifiers and an LLVM companion patch to enable that (https://reviews.llvm.org/D41111),
all tests pass.

[vsk]

Thanks! LGTM with a nit -- please add the comment we discussed in InstrProfilingPort.h.

lib/profile/InstrProfilingPort.h

9

This is a good place to add a comment stating that this header must be textually #included before all others.

lib/profile/InstrProfilingUtil.c

90

Nice catch.

[ro]

lib/profile/InstrProfilingPort.h

9

Included after all the others, actually :-)

[ro]

Added comment.

Could someone please commit the patch for me? Thanks.

cmake/config-ix.cmake

 if (COMPILER_RT_HAS_SANITIZER_COMMON AND MSAN_SUPPORTED_ARCH AND
     OS_NAME MATCHES "Linux|NetBSD")
   set(COMPILER_RT_HAS_MSAN TRUE)
 else()
   set(COMPILER_RT_HAS_MSAN FALSE)
 endif()
 
 if (PROFILE_SUPPORTED_ARCH AND NOT LLVM_USE_SANITIZER AND
-    OS_NAME MATCHES "Darwin|Linux|FreeBSD|Windows|Android")
+    OS_NAME MATCHES "Darwin|Linux|FreeBSD|Windows|Android|SunOS")
   set(COMPILER_RT_HAS_PROFILE TRUE)
 else()
   set(COMPILER_RT_HAS_PROFILE FALSE)
 endif()
 
 if (COMPILER_RT_HAS_SANITIZER_COMMON AND TSAN_SUPPORTED_ARCH AND
     OS_NAME MATCHES "Darwin|Linux|FreeBSD|Android|NetBSD")
   set(COMPILER_RT_HAS_TSAN TRUE)

lib/profile/CMakeLists.txt

 
  s_flock.l_type = F_WRLCK;
  fcntl(fd, F_SETLKW, &s_flock);
  return 0;
 }
 
 " COMPILER_RT_TARGET_HAS_FCNTL_LCK)
 
+CHECK_CXX_SOURCE_COMPILES("
+#include <sys/utsname.h>
+int main() {
+ return 0;
+}
+
+" COMPILER_RT_TARGET_HAS_UNAME)
+
 add_compiler_rt_component(profile)
 
 set(PROFILE_SOURCES
   GCDAProfiling.c
   InstrProfiling.c
   InstrProfilingValue.c
   InstrProfilingBuffer.c
   InstrProfilingFile.c

 endif() 
 
 if(COMPILER_RT_TARGET_HAS_FCNTL_LCK)
  set(EXTRA_FLAGS
      ${EXTRA_FLAGS}
      -DCOMPILER_RT_HAS_FCNTL_LCK=1)
 endif()
 
+if(COMPILER_RT_TARGET_HAS_UNAME)
+ set(EXTRA_FLAGS
+     ${EXTRA_FLAGS}
+     -DCOMPILER_RT_HAS_UNAME=1)
+endif()
+
 # This appears to be a C-only warning banning the use of locals in aggregate
 # initializers. All other compilers accept this, though.
 # nonstandard extension used : 'identifier' : cannot be initialized using address of automatic variable
 append_list_if(COMPILER_RT_HAS_WD4221_FLAG /wd4221 EXTRA_FLAGS)
 
 if(APPLE)
   add_compiler_rt_runtime(clang_rt.profile
     STATIC

lib/profile/GCDAProfiling.c

 |* are only close enough that LCOV will happily parse them. Anything that lcov
 |* ignores is missing.
 |*
 |* TODO: gcov is multi-process safe by having each exit open the existing file
 |* and append to it. We'd like to achieve that and be thread-safe too.
 |*
 \*===----------------------------------------------------------------------===*/
 
-#include "InstrProfilingPort.h"
-#include "InstrProfilingUtil.h"
-
 #include <errno.h>
 #include <fcntl.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #if defined(_WIN32)
 #include "WindowsMMap.h"
 #else
 #include <sys/mman.h>
 #include <sys/file.h>
-#ifndef MAP_FILE
-#define MAP_FILE 0
-#endif
-#ifndef O_BINARY
-#define O_BINARY 0
-#endif
 #endif
 
 #if defined(__FreeBSD__) && defined(__i386__)
 #define I386_FREEBSD 1
 #else
 #define I386_FREEBSD 0
 #endif
 
 #if !defined(_MSC_VER) && !I386_FREEBSD
 #include <stdint.h>
 #endif
 
 #if defined(_MSC_VER)
 typedef unsigned char uint8_t;
 typedef unsigned int uint32_t;
 typedef unsigned long long uint64_t;
 #elif I386_FREEBSD
 /* System headers define 'size_t' incorrectly on x64 FreeBSD (prior to
  * FreeBSD 10, r232261) when compiled in 32-bit mode.
  */
 typedef unsigned char uint8_t;
 typedef unsigned int uint32_t;
 typedef unsigned long long uint64_t;
 #endif
 
+#include "InstrProfiling.h"
+#include "InstrProfilingUtil.h"
+
 /* #define DEBUG_GCDAPROFILING */
 
 /*
  * --- GCOV file format I/O primitives ---
  */
 
 /*
  * The current file name we're outputting. Used primarily for error logging.
if (fd == -1) {
       }
     }
   }
 
   /* Try to flock the file to serialize concurrent processes writing out to the
    * same GCDA. This can fail if the filesystem doesn't support it, but in that
    * case we'll just carry on with the old racy behaviour and hope for the best.
    */
-  flock(fd, LOCK_EX);
+  lprofLockFd(fd);
   output_file = fdopen(fd, mode);
 
   /* Initialize the write buffer. */
   write_buffer = NULL;
   cur_buffer_size = 0;
   cur_pos = 0;
 
   if (new_file) {
if (output_file) {
 
     if (new_file) {
       fwrite(write_buffer, cur_pos, 1, output_file);
       free(write_buffer);
     } else {
       unmap_file();
     }
 
-    flock(fd, LOCK_UN);
+    lprofUnlockFd(fd);
     fclose(output_file);
     output_file = NULL;
     write_buffer = NULL;
   }
   free(filename);
 
 #ifdef DEBUG_GCDAPROFILING
   fprintf(stderr, "llvmgcda: -----\n");

lib/profile/InstrProfiling.c

 /*===- InstrProfiling.c - Support library for PGO instrumentation ---------===*\
 |*
 |*                     The LLVM Compiler Infrastructure
 |*
 |* This file is distributed under the University of Illinois Open Source
 |* License. See LICENSE.TXT for details.
 |*
 \*===----------------------------------------------------------------------===*/
 
-#include "InstrProfiling.h"
-#include "InstrProfilingInternal.h"
 #include <limits.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+
+#include "InstrProfiling.h"
+#include "InstrProfilingInternal.h"
+
 #define INSTR_PROF_VALUE_PROF_DATA
 #include "InstrProfData.inc"
 
 
 COMPILER_RT_WEAK uint64_t INSTR_PROF_RAW_VERSION_VAR = INSTR_PROF_RAW_VERSION;
 
 COMPILER_RT_VISIBILITY uint64_t __llvm_profile_get_magic(void) {
   return sizeof(void *) == sizeof(uint64_t) ? (INSTR_PROF_RAW_MAGIC_64)

lib/profile/InstrProfilingFile.c

 /*===- InstrProfilingFile.c - Write instrumentation to a file -------------===*\
 |*
 |*                     The LLVM Compiler Infrastructure
 |*
 |* This file is distributed under the University of Illinois Open Source
 |* License. See LICENSE.TXT for details.
 |*
 \*===----------------------------------------------------------------------===*/
 
-#include "InstrProfiling.h"
-#include "InstrProfilingInternal.h"
-#include "InstrProfilingUtil.h"
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #ifdef _MSC_VER
 /* For _alloca. */
 #include <malloc.h>
 #endif
 #if defined(_WIN32)
 #include "WindowsMMap.h"
 /* For _chsize_s */
 #include <io.h>
 #else
 #include <sys/file.h>
 #include <sys/mman.h>
 #include <unistd.h>
 #if defined(__linux__)
 #include <sys/types.h>
 #endif
 #endif
 
+#include "InstrProfiling.h"
+#include "InstrProfilingInternal.h"
+#include "InstrProfilingUtil.h"
+
 /* From where is profile name specified.
  * The order the enumerators define their
  * precedence. Re-order them may lead to
  * runtime behavior change. */ 
 typedef enum ProfileNameSpecifier {
   PNS_unknown = 0,
   PNS_default,
   PNS_command_line,
typedef struct lprofFilename {
    * can only appear once at the end of the name pattern. */
   unsigned MergePoolSize;
   ProfileNameSpecifier PNS;
 } lprofFilename;
 
 COMPILER_RT_WEAK lprofFilename lprofCurFilename = {0, 0, 0, {0}, {0},
                                                    0, 0, 0, PNS_unknown};
 
-int getpid(void);
 static int getCurFilenameLength();
 static const char *getCurFilename(char *FilenameBuf);
 static unsigned doMerging() { return lprofCurFilename.MergePoolSize; }
 
 /* Return 1 if there is an error, otherwise return  0.  */
 static uint32_t fileWriter(ProfDataWriter *This, ProfDataIOVec *IOVecs,
                            uint32_t NumIOVecs) {
   uint32_t I;
else {
     lprofCurFilename.FilenamePat = strdup(FilenamePat);
     lprofCurFilename.OwnsFilenamePat = 1;
   }
   /* Check the filename for "%p", which indicates a pid-substitution. */
   for (I = 0; FilenamePat[I]; ++I)
     if (FilenamePat[I] == '%') {
       if (FilenamePat[++I] == 'p') {
         if (!NumPids++) {
-          if (snprintf(PidChars, MAX_PID_SIZE, "%d", getpid()) <= 0) {
+          if (snprintf(PidChars, MAX_PID_SIZE, "%ld", (long)getpid()) <= 0) {
             PROF_WARN("Unable to get pid for filename pattern %s. Using the "
                       "default name.",
                       FilenamePat);
             return -1;
           }
         }
       } else if (FilenamePat[I] == 'h') {
         if (!NumHosts++)

lib/profile/InstrProfilingInternal.h

 /*===- InstrProfiling.h- Support library for PGO instrumentation ----------===*\
 |*
 |*                     The LLVM Compiler Infrastructure
 |*
 |* This file is distributed under the University of Illinois Open Source
 |* License. See LICENSE.TXT for details.
 |*
 \*===----------------------------------------------------------------------===*/
 
 #ifndef PROFILE_INSTRPROFILING_INTERNALH_
 #define PROFILE_INSTRPROFILING_INTERNALH_
 
+#include <stddef.h>
+
 #include "InstrProfiling.h"
-#include "stddef.h"
 
 /*!
  * \brief Write instrumentation data to the given buffer, given explicit
  * pointers to the live data in memory.  This function is probably not what you
  * want.  Use __llvm_profile_get_size_for_buffer instead.  Use this function if
  * your program has a custom memory layout.
  */
 uint64_t __llvm_profile_get_size_for_buffer_internal(

lib/profile/InstrProfilingPlatformLinux.c

 /*===- InstrProfilingPlatformLinux.c - Profile data Linux platform ------===*\
 |*
 |*                     The LLVM Compiler Infrastructure
 |*
 |* This file is distributed under the University of Illinois Open Source
 |* License. See LICENSE.TXT for details.
 |*
 \*===----------------------------------------------------------------------===*/
 
-#include "InstrProfiling.h"
+#if defined(__linux__) || defined(__FreeBSD__) || \
+    (defined(__sun__) && defined(__svr4__))
 
-#if defined(__linux__) || defined(__FreeBSD__)
 #include <stdlib.h>
 
+#include "InstrProfiling.h"
+
 #define PROF_DATA_START INSTR_PROF_SECT_START(INSTR_PROF_DATA_SECT_NAME)
 #define PROF_DATA_STOP INSTR_PROF_SECT_STOP(INSTR_PROF_DATA_SECT_NAME)
 #define PROF_NAME_START INSTR_PROF_SECT_START(INSTR_PROF_NAME_SECT_NAME)
 #define PROF_NAME_STOP INSTR_PROF_SECT_STOP(INSTR_PROF_NAME_SECT_NAME)
 #define PROF_CNTS_START INSTR_PROF_SECT_START(INSTR_PROF_CNTS_SECT_NAME)
 #define PROF_CNTS_STOP INSTR_PROF_SECT_STOP(INSTR_PROF_CNTS_SECT_NAME)
 #define PROF_VNODES_START INSTR_PROF_SECT_START(INSTR_PROF_VNODES_SECT_NAME)
 #define PROF_VNODES_STOP INSTR_PROF_SECT_STOP(INSTR_PROF_VNODES_SECT_NAME)

lib/profile/InstrProfilingPlatformOther.c

 /*===- InstrProfilingPlatformOther.c - Profile data default platform ------===*\
 |*
 |*                     The LLVM Compiler Infrastructure
 |*
 |* This file is distributed under the University of Illinois Open Source
 |* License. See LICENSE.TXT for details.
 |*
 \*===----------------------------------------------------------------------===*/
 
-#include "InstrProfiling.h"
-
-#if !defined(__APPLE__) && !defined(__linux__) && !defined(__FreeBSD__)
+#if !defined(__APPLE__) && !defined(__linux__) && !defined(__FreeBSD__) && \
+    !(defined(__sun__) && defined(__svr4__))
 
 #include <stdlib.h>
 
+#include "InstrProfiling.h"
+
 static const __llvm_profile_data *DataFirst = NULL;
 static const __llvm_profile_data *DataLast = NULL;
 static const char *NamesFirst = NULL;
 static const char *NamesLast = NULL;
 static uint64_t *CountersFirst = NULL;
 static uint64_t *CountersLast = NULL;
 
 static const void *getMinAddr(const void *A1, const void *A2) {

lib/profile/InstrProfilingPort.h

 /*===- InstrProfilingPort.h- Support library for PGO instrumentation ------===*\
 |*
 |*                     The LLVM Compiler Infrastructure
 |*
 |* This file is distributed under the University of Illinois Open Source
 |* License. See LICENSE.TXT for details.
 |*
 \*===----------------------------------------------------------------------===*/
 
 #ifndef PROFILE_INSTRPROFILING_PORT_H_
 #define PROFILE_INSTRPROFILING_PORT_H_
 
 #ifdef _MSC_VER
 #define COMPILER_RT_ALIGNAS(x) __declspec(align(x))
 #define COMPILER_RT_VISIBILITY
 /* FIXME: selectany does not have the same semantics as weak. */
 #define COMPILER_RT_WEAK __declspec(selectany)

 #define COMPILER_RT_SECTION(Sect) __attribute__((section(Sect)))
 #endif
 
 #define COMPILER_RT_MAX_HOSTLEN 128
 #ifdef __ORBIS__
 #define COMPILER_RT_GETHOSTNAME(Name, Len) ((void)(Name), (void)(Len), (-1))
 #else
 #define COMPILER_RT_GETHOSTNAME(Name, Len) lprofGetHostName(Name, Len)
-#ifndef _MSC_VER
-#define COMPILER_RT_HAS_UNAME 1
-#endif
 #endif
 
 #if COMPILER_RT_HAS_ATOMICS == 1
 #ifdef _MSC_VER
 #include <windows.h>
 #if _MSC_VER < 1900
 #define snprintf _snprintf
 #endif
#define PROF_ERR(Format, ...)                                                  \
   fprintf(stderr, "LLVM Profile Error: " Format, __VA_ARGS__);
 
 #define PROF_WARN(Format, ...)                                                 \
   fprintf(stderr, "LLVM Profile Warning: " Format, __VA_ARGS__);
 
 #define PROF_NOTE(Format, ...)                                                 \
   fprintf(stderr, "LLVM Profile Note: " Format, __VA_ARGS__);
 
+#ifndef MAP_FILE
+#define MAP_FILE 0
+#endif
+
+#ifndef O_BINARY
+#define O_BINARY 0
+#endif
+
 #if defined(__FreeBSD__)
 
 #include <inttypes.h>
 #include <sys/types.h>
 
 #else /* defined(__FreeBSD__) */
 
 #include <inttypes.h>
 #include <stdint.h>
 
 #endif /* defined(__FreeBSD__) && defined(__i386__) */
 
 #endif /* PROFILE_INSTRPROFILING_PORT_H_ */

lib/profile/InstrProfilingUtil.h

 #define PROFILE_INSTRPROFILINGUTIL_H
 
 #include <stddef.h>
 #include <stdio.h>
 
 /*! \brief Create a directory tree. */
 void __llvm_profile_recursive_mkdir(char *Pathname);
 
+int lprofLockFd(int fd);
+int lprofUnlockFd(int fd);
+
 /*! Open file \c Filename for read+write with write
  * lock for exclusive access. The caller will block
  * if the lock is already held by another process. */
 FILE *lprofOpenFileEx(const char *Filename);
 /* PS4 doesn't have getenv. Define a shim. */
 #if __ORBIS__
 static inline char *getenv(const char *name) { return NULL; }
 #endif /* #if __ORBIS__ */

lib/profile/InstrProfilingUtil.c

 /*===- InstrProfilingUtil.c - Support library for PGO instrumentation -----===*\
 |*
 |*                     The LLVM Compiler Infrastructure
 |*
 |* This file is distributed under the University of Illinois Open Source
 |* License. See LICENSE.TXT for details.
 |*
 \*===----------------------------------------------------------------------===*/
 
-#include "InstrProfilingUtil.h"
-#include "InstrProfiling.h"
-
 #ifdef _WIN32
 #include <direct.h>
 #include <io.h>
 #include <windows.h>
 #else
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <unistd.h>
 #include <fcntl.h>
 #include <errno.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
 
+#include "InstrProfiling.h"
+#include "InstrProfilingUtil.h"
+
 COMPILER_RT_VISIBILITY
 void __llvm_profile_recursive_mkdir(char *path) {
   int i;
 
   for (i = 1; path[i] != '\0'; ++i) {
     char save = path[i];
     if (!IS_DIR_SEPARATOR(path[i]))
       continue;
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;
-  if (!(R = uname(&N)))
+  int R = uname(&N);
+  if (R >= 0) {
     strncpy(Name, N.nodename, Len);
+    return 0;
+  }
   return R;
 }
 #endif
 
-COMPILER_RT_VISIBILITY FILE *lprofOpenFileEx(const char *ProfileName) {
-  FILE *f;
-  int fd;
+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;
-  fd = open(ProfileName, O_RDWR | O_CREAT, 0666);
-  if (fd < 0)
-    return NULL;
 
   while (fcntl(fd, F_SETLKW, &s_flock) == -1) {
     if (errno != EINTR) {
       if (errno == ENOLCK) {
-        PROF_WARN("Data may be corrupted during profile merging : %s\n",
-                  "Fail to obtain file lock due to system limit.");
+        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 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, 0, 0,
                          OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
   if (h == INVALID_HANDLE_VALUE)
     return NULL;

lib/profile/InstrProfilingValue.c

 /*===- InstrProfilingValue.c - Support library for PGO instrumentation ----===*\
 |*
 |*                     The LLVM Compiler Infrastructure
 |*
 |* This file is distributed under the University of Illinois Open Source
 |* License. See LICENSE.TXT for details.
 |*
 \*===----------------------------------------------------------------------===*/
 
-#include "InstrProfiling.h"
-#include "InstrProfilingInternal.h"
-#include "InstrProfilingUtil.h" /* For PS4 getenv shim. */
 #include <limits.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+
+#include "InstrProfiling.h"
+#include "InstrProfilingInternal.h"
+#include "InstrProfilingUtil.h"
+
 #define INSTR_PROF_VALUE_PROF_DATA
 #define INSTR_PROF_COMMON_API_IMPL
 #include "InstrProfData.inc"
 
 static int hasStaticCounters = 1;
 static int OutOfNodesWarnings = 0;
 static int hasNonDefaultValsPerSite = 0;
 #define INSTR_PROF_MAX_VP_WARNS 10

lib/profile/InstrProfilingWriter.c

 /*===- InstrProfilingWriter.c - Write instrumentation to a file or buffer -===*\
 |*
 |*                     The LLVM Compiler Infrastructure
 |*
 |* This file is distributed under the University of Illinois Open Source
 |* License. See LICENSE.TXT for details.
 |*
 \*===----------------------------------------------------------------------===*/
 
-#include "InstrProfiling.h"
-#include "InstrProfilingInternal.h"
 #ifdef _MSC_VER
 /* For _alloca */
 #include <malloc.h>
 #endif
 #include <string.h>
 
+#include "InstrProfiling.h"
+#include "InstrProfilingInternal.h"
+
 #define INSTR_PROF_VALUE_PROF_DATA
 #include "InstrProfData.inc"
 
 COMPILER_RT_VISIBILITY void (*FreeHook)(void *) = NULL;
 static ProfBufferIO TheBufferIO;
 #define VP_BUFFER_SIZE 8 * 1024
 static uint8_t BufferIOBuffer[VP_BUFFER_SIZE];
 static InstrProfValueData VPDataArray[16];

lib/profile/WindowsMMap.c

  * CloseHandle:       http://msdn.microsoft.com/en-us/library/ms724211(VS.85).aspx
  * MapViewOfFile:     http://msdn.microsoft.com/en-us/library/aa366761(VS.85).aspx
  * UnmapViewOfFile:   http://msdn.microsoft.com/en-us/library/aa366882(VS.85).aspx
  */
 
 #if defined(_WIN32)
 
 #include "WindowsMMap.h"
-#include "InstrProfiling.h"
 
 #define WIN32_LEAN_AND_MEAN
 #include <windows.h>
 
+#include "InstrProfiling.h"
+
 #ifdef __USE_FILE_OFFSET64
 # define DWORD_HI(x) (x >> 32)
 # define DWORD_LO(x) ((x) & 0xffffffff)
 #else
 # define DWORD_HI(x) (0)
 # define DWORD_LO(x) (x)
 #endif
 

test/profile/lit.cfg

 config.substitutions.append( ("%clang_profgen_gcc=", build_invocation(clang_cflags) + " -fprofile-generate=") )
 config.substitutions.append( ("%clang_profuse_gcc=", build_invocation(clang_cflags) + " -fprofile-use=") )
 
 config.substitutions.append( ("%clang_profuse=", build_invocation(clang_cflags) + " -fprofile-instr-use=") )
 config.substitutions.append( ("%clangxx_profuse=", build_invocation(clang_cxxflags) + " -fprofile-instr-use=") )
 
 config.substitutions.append( ("%clang_lto_profgen=", build_invocation(clang_cflags, True) + " -fprofile-instr-generate=") )
 
-if config.host_os not in ['Darwin', 'FreeBSD', 'Linux']:
+if config.host_os not in ['Darwin', 'FreeBSD', 'Linux', 'SunOS']:
   config.unsupported = True
 
 if config.target_arch in ['armv7l']:
   config.unsupported = True
 
 if config.android:
   config.unsupported = True