[compiler-rt][profile] Compile as C++

[abrachet]

Summary

Moving to C++ can in the future allow for less duplicated code across the runtimes, in particular allows using sanitizer_common. This move was discussed on the mailing list https://lists.llvm.org/pipermail/llvm-dev/2021-July/151789.html

[phosek]

Thank you for doing this! While this change looks fairly straightforward, I still think it'd be great to have a check in place to ensure that the ABI of libclang_rt.profile.a doesn't change prior to landing this change.

To do this, we could generate a list of exported symbols and compare it against a golden file that's checked into the repository.

Ideally, we would use llvm-ifs for that purpose, but that tool doesn't yet support static archives. I'm wondering if we could reuse https://github.com/llvm/llvm-project/tree/main/libcxx/utils/libcxx/sym_check in the meantime?

[abrachet]

Going to abandon while waiting for llvm-ifs to support static archives

compiler-rt/include/profile/InstrProfData.inc

typedef struct ValueProfRecord {
   uint8_t Padding[X];
    */
 
   /* The array of value profile data. The size of the array is the sum
    * of all elements in SiteCountArray[].
   InstrProfValueData ValueData[];
    */
 
-#ifdef __cplusplus
+#if defined(__cplusplus) && !defined(COMPILER_RT)
   /*!
    * Return the number of value sites.
    */
   uint32_t getNumValueSites() const { return NumValueSites; }
   /*!
    * Read data from this record and save it to Record.
    */
   void deserializeTo(InstrProfRecord &Record,
typedef struct ValueProfData {
   /*
    * Following are a sequence of variable length records. The prefix/header
    * of each record is defined by ValueProfRecord type. The number of
    * records is NumValueKinds.
    * ValueProfRecord Record_1;
    * ValueProfRecord Record_N;
    */
 
-#if __cplusplus
+#if __cplusplus && !defined(COMPILER_RT)
   /*!
    * Return the total size in bytes of the on-disk value profile data
    * given the data stored in Record.
    */
   static uint32_t getSize(const InstrProfRecord &Record);
   /*!
    * Return a pointer to \c ValueProfData instance ready to be streamed.
    */

compiler-rt/lib/profile/CMakeLists.txt

  return 0;
 }
 
 " COMPILER_RT_TARGET_HAS_UNAME)
 
 add_compiler_rt_component(profile)
 
 set(PROFILE_SOURCES
-  GCDAProfiling.c
-  InstrProfiling.c
-  InstrProfilingInternal.c
-  InstrProfilingValue.c
-  InstrProfilingBuffer.c
-  InstrProfilingFile.c
-  InstrProfilingMerge.c
-  InstrProfilingMergeFile.c
-  InstrProfilingNameVar.c
-  InstrProfilingVersionVar.c
-  InstrProfilingWriter.c
-  InstrProfilingPlatformDarwin.c
-  InstrProfilingPlatformFuchsia.c
-  InstrProfilingPlatformLinux.c
-  InstrProfilingPlatformOther.c
-  InstrProfilingPlatformWindows.c
+  GCDAProfiling.cpp
+  InstrProfiling.cpp
+  InstrProfilingInternal.cpp
+  InstrProfilingValue.cpp
+  InstrProfilingBuffer.cpp
+  InstrProfilingFile.cpp
+  InstrProfilingMerge.cpp
+  InstrProfilingMergeFile.cpp
+  InstrProfilingNameVar.cpp
+  InstrProfilingVersionVar.cpp
+  InstrProfilingWriter.cpp
+  InstrProfilingPlatformDarwin.cpp
+  InstrProfilingPlatformFuchsia.cpp
+  InstrProfilingPlatformLinux.cpp
+  InstrProfilingPlatformOther.cpp
+  InstrProfilingPlatformWindows.cpp
   InstrProfilingRuntime.cpp
-  InstrProfilingUtil.c
+  InstrProfilingUtil.cpp
   )
 
 set(PROFILE_HEADERS
   InstrProfiling.h
   InstrProfilingInternal.h
   InstrProfilingPort.h
   InstrProfilingUtil.h
   WindowsMMap.h

 endif()
 
 if(COMPILER_RT_TARGET_HAS_UNAME)
  set(EXTRA_FLAGS
      ${EXTRA_FLAGS}
      -DCOMPILER_RT_HAS_UNAME=1)
 endif()
 
+set(EXTRA_FLAGS ${EXTRA_FLAGS} -DCOMPILER_RT=1)
+
 # We don't use the C++ Standard Library here, so avoid including it by mistake.
 append_list_if(COMPILER_RT_HAS_NOSTDINCXX_FLAG -nostdinc++ EXTRA_FLAGS)
 # XRay uses C++ standard library headers.
 string(REGEX REPLACE "-stdlib=[a-zA-Z+]*" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
 
 # 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

compiler-rt/lib/profile/GCDAProfiling.cpp

 #include <sys/mman.h>
 #include <sys/types.h>
 #include <unistd.h>
 #endif
 
 #include "InstrProfiling.h"
 #include "InstrProfilingUtil.h"
 
+extern "C" {
+
 /* #define DEBUG_GCDAPROFILING */
 
 enum {
   GCOV_DATA_MAGIC = 0x67636461, // "gcda"
 
   GCOV_TAG_FUNCTION = 0x01000000,
   GCOV_TAG_COUNTER_ARCS = 0x01a10000,
   // GCOV_TAG_OBJECT_SUMMARY superseded GCOV_TAG_PROGRAM_SUMMARY in GCC 9.

 struct fn_list writeout_fn_list;
 
 /*
  *  A list of reset functions, shared between all dynamic objects.
  */
 struct fn_list reset_fn_list;
 
 static void fn_list_insert(struct fn_list* list, fn_ptr fn) {
-  struct fn_node* new_node = malloc(sizeof(struct fn_node));
+  struct fn_node* new_node = static_cast<struct fn_node*>(malloc(sizeof(struct fn_node)));
   new_node->fn = fn;
   new_node->next = NULL;
   new_node->id = CURRENT_ID;
 
   if (!list->head) {
     list->head = list->tail = new_node;
   } else {
     list->tail->next = new_node;

 }
 
 static void resize_write_buffer(uint64_t size) {
   if (!new_file) return;
   size += cur_pos;
   if (size <= cur_buffer_size) return;
   size = (size - 1) / WRITE_BUFFER_SIZE + 1;
   size *= WRITE_BUFFER_SIZE;
-  write_buffer = realloc(write_buffer, size);
+  write_buffer = static_cast<unsigned char*>(realloc(write_buffer, size));
   cur_buffer_size = size;
 }
 
 static void write_bytes(const char *s, size_t len) {
   resize_write_buffer(len);
   memcpy(&write_buffer[cur_pos], s, len);
   cur_pos += len;
 }
static char *mangle_filename(const char *orig_filename) {
   char *new_filename;
   size_t prefix_len;
   int prefix_strip;
   const char *prefix = lprofGetPathPrefix(&prefix_strip, &prefix_len);
 
   if (prefix == NULL)
     return strdup(orig_filename);
 
-  new_filename = malloc(prefix_len + 1 + strlen(orig_filename) + 1);
+  new_filename = static_cast<char*>(malloc(prefix_len + 1 + strlen(orig_filename) + 1));
   lprofApplyPathPrefix(new_filename, orig_filename, prefix, prefix_len,
                        prefix_strip);
 
   return new_filename;
 }
 
 static int map_file() {
   fseek(output_file, 0L, SEEK_END);
#if defined(_WIN32)
   write_buffer = MapViewOfFile(mmap_handle, FILE_MAP_WRITE, 0, 0, file_size);
   if (write_buffer == NULL) {
     fprintf(stderr, "profiling: %s: cannot map: %lu\n", filename,
             GetLastError());
     CloseHandle(mmap_handle);
     return -1;
   }
 #else
-  write_buffer = mmap(0, file_size, PROT_READ | PROT_WRITE,
-                      MAP_FILE | MAP_SHARED, fd, 0);
+  write_buffer = static_cast<unsigned char*>(mmap(0, file_size, PROT_READ | PROT_WRITE,
+                      MAP_FILE | MAP_SHARED, fd, 0));
   if (write_buffer == (void *)-1) {
     int errnum = errno;
     fprintf(stderr, "profiling: %s: cannot map: %s\n", filename,
             strerror(errnum));
     return -1;
   }
 #endif
 
if (val != (uint32_t)-1) {
     val = read_32bit_value();
     if (val == (uint32_t)-1 || val / 2 != num_counters) {
       fprintf(stderr, "profiling: %s: cannot merge previous GCDA file: "
                       "mismatched number of counters (%d)\n",
               filename, val);
       return;
     }
 
-    old_ctrs = malloc(sizeof(uint64_t) * num_counters);
+    old_ctrs = static_cast<uint64_t*>(malloc(sizeof(uint64_t) * num_counters));
     for (i = 0; i < num_counters; ++i)
       old_ctrs[i] = read_64bit_value();
   }
 
   cur_pos = save_cur_pos;
 
   /* Counter #1 (arcs) tag */
   write_32bit_value(GCOV_TAG_COUNTER_ARCS);
for (struct fn_node *f = writeout_fn_list.head; f; f = f->next)
     f->fn();
 }
 
 void __gcov_reset(void) {
   for (struct fn_node *f = reset_fn_list.head; f; f = f->next)
     f->fn();
 }
 
+} // extern "C"
+
 #endif

compiler-rt/lib/profile/InstrProfiling.h

 /*===- InstrProfiling.h- 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
 |*
 \*===----------------------------------------------------------------------===*/
 
 #ifndef PROFILE_INSTRPROFILING_H_
 #define PROFILE_INSTRPROFILING_H_
 
 #include "InstrProfilingPort.h"
 #include <stdio.h>
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #define INSTR_PROF_VISIBILITY COMPILER_RT_VISIBILITY
 #include "profile/InstrProfData.inc"
 
 enum ValueKind {
 #define VALUE_PROF_KIND(Enumerator, Value, Descr) Enumerator = Value,
 #include "profile/InstrProfData.inc"
 };
 
 typedef void *IntPtrT;
 typedef struct COMPILER_RT_ALIGNAS(INSTR_PROF_DATA_ALIGNMENT)
     __llvm_profile_data {
 #define INSTR_PROF_DATA(Type, LLVMType, Name, Initializer) Type Name;
 #include "profile/InstrProfData.inc"
 } __llvm_profile_data;
 
 typedef struct __llvm_profile_header {
 #define INSTR_PROF_RAW_HEADER(Type, Name, Initializer) Type Name;
 #include "profile/InstrProfData.inc"
 } __llvm_profile_header;
 
-typedef struct ValueProfNode * PtrToNodeT;
+typedef struct ValueProfNode *PtrToNodeT;
 typedef struct ValueProfNode {
 #define INSTR_PROF_VALUE_NODE(Type, LLVMType, Name, Initializer) Type Name;
 #include "profile/InstrProfData.inc"
 } ValueProfNode;
 
 /*!
  * \brief Return 1 if profile counters are continuously synced to the raw
  * profile via an mmap(). This is in contrast to the default mode, in which

 
 /*! \brief Check if profile in buffer matches the current binary.
  *
  *  Returns 0 (success) if the profile data in buffer \p Profile with size
  *  \p Size was generated by the same binary and therefore matches
  *  structurally the in-process counters. If the profile data in buffer is
  *  not compatible, the interface returns 1 (failure).
  */
-int __llvm_profile_check_compatibility(const char *Profile,
-                                       uint64_t Size);
+int __llvm_profile_check_compatibility(const char *Profile, uint64_t Size);
 
 /*!
  * \brief Counts the number of times a target value is seen.
  *
  * Records the target value for the CounterIndex if not seen before. Otherwise,
  * increments the counter associated w/ the target value.
  * void __llvm_profile_instrument_target(uint64_t TargetValue, void *Data,
  *                                       uint32_t CounterIndex);
  */
 void INSTR_PROF_VALUE_PROF_FUNC(
 #define VALUE_PROF_FUNC_PARAM(ArgType, ArgName, ArgLLVMType) ArgType ArgName
 #include "profile/InstrProfData.inc"
-    );
 
 void __llvm_profile_instrument_target_value(uint64_t TargetValue, void *Data,
                                             uint32_t CounterIndex,
                                             uint64_t CounterValue);
 
 /*!
  * \brief Write instrumentation data to the current file.
  *

  * This variable is defined in InstrProfilingRuntime.cpp as a hidden
  * symbol. Its main purpose is to enable profile runtime user to
  * bypass runtime initialization code -- if the client code explicitly
  * define this variable, then InstProfileRuntime.o won't be linked in.
  * Note that this variable's visibility needs to be hidden so that the
  * definition of this variable in an instrumented shared library won't
  * affect runtime initialization decision of the main program.
  *  __llvm_profile_profile_runtime. */
-COMPILER_RT_VISIBILITY extern int INSTR_PROF_PROFILE_RUNTIME_VAR;
+__attribute__((visibility("hidden"))) extern int INSTR_PROF_PROFILE_RUNTIME_VAR;
 
 /*!
  * This variable is defined in InstrProfilingVersionVar.c as a hidden symbol
  * (except on Apple platforms where this symbol is checked by TAPI).  Its main
  * purpose is to encode the raw profile version value and other format related
  * information such as whether the profile is from IR based instrumentation. The
  * variable is defined as weak so that compiler can emit an overriding
  * definition depending on user option.
  */
 extern uint64_t INSTR_PROF_RAW_VERSION_VAR; /* __llvm_profile_raw_version */
 
 /*!
  * This variable is a weak symbol defined in InstrProfiling.c. It allows
  * compiler instrumentation to provide overriding definition with value
  * from compiler command line. This variable has default visibility.
  */
 extern char INSTR_PROF_PROFILE_NAME_VAR[1]; /* __llvm_profile_filename. */
 
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
 #endif /* PROFILE_INSTRPROFILING_H_ */

compiler-rt/lib/profile/InstrProfiling.cpp

 #include <string.h>
 
 #include "InstrProfiling.h"
 #include "InstrProfilingInternal.h"
 
 #define INSTR_PROF_VALUE_PROF_DATA
 #include "profile/InstrProfData.inc"
 
+extern "C" {
+
 COMPILER_RT_VISIBILITY uint64_t __llvm_profile_get_magic(void) {
   return sizeof(void *) == sizeof(uint64_t) ? (INSTR_PROF_RAW_MAGIC_64)
                                             : (INSTR_PROF_RAW_MAGIC_32);
 }
 
 COMPILER_RT_VISIBILITY void __llvm_profile_set_dumped() {
   lprofSetProfileDumped(1);
 }
for (i = 0; i < CurrentVSiteCount; ++i) {
       while (CurrentVNode) {
         CurrentVNode->Count = 0;
         CurrentVNode = CurrentVNode->Next;
       }
     }
   }
   lprofSetProfileDumped(0);
 }
+
+} // extern "C"

compiler-rt/lib/profile/InstrProfilingBuffer.cpp

 /*===- InstrProfilingBuffer.c - Write instrumentation to a memory buffer --===*\
 |*
 |* 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
 |*
 \*===----------------------------------------------------------------------===*/
 
 // Note: This is linked into the Darwin kernel, and must remain compatible
 // with freestanding compilation. See `darwin_add_builtin_libraries`.
 
 #include "InstrProfiling.h"
 #include "InstrProfilingInternal.h"
 #include "InstrProfilingPort.h"
 
+extern "C" {
+
 /* When continuous mode is enabled (%c), this parameter is set to 1.
  *
  * This parameter is defined here in InstrProfilingBuffer.o, instead of in
  * InstrProfilingFile.o, to sequester all libc-dependent code in
  * InstrProfilingFile.o. The test `instrprof-without-libc` will break if this
  * layering is violated. */
 static int ContinuouslySyncProfile = 0;
 
COMPILER_RT_VISIBILITY int __llvm_profile_write_buffer_internal(
     char *Buffer, const __llvm_profile_data *DataBegin,
     const __llvm_profile_data *DataEnd, const char *CountersBegin,
     const char *CountersEnd, const char *NamesBegin, const char *NamesEnd) {
   ProfDataWriter BufferWriter;
   initBufferWriter(&BufferWriter, Buffer);
   return lprofWriteDataImpl(&BufferWriter, DataBegin, DataEnd, CountersBegin,
                             CountersEnd, 0, NamesBegin, NamesEnd, 0);
 }
+
+} // extern "C"

compiler-rt/lib/profile/InstrProfilingFile.cpp

 #endif
 #endif
 
 #include "InstrProfiling.h"
 #include "InstrProfilingInternal.h"
 #include "InstrProfilingPort.h"
 #include "InstrProfilingUtil.h"
 
+extern "C" {
+
 /* 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,

 
 COMPILER_RT_VISIBILITY ProfBufferIO *
 lprofCreateBufferIOInternal(void *File, uint32_t BufferSz) {
   FreeHook = &free;
   DynamicBufferIOBuffer = (uint8_t *)calloc(BufferSz, 1);
   VPBufferSize = BufferSz;
   ProfDataWriter *fileWriter =
       (ProfDataWriter *)calloc(sizeof(ProfDataWriter), 1);
-  initFileWriter(fileWriter, File);
+  initFileWriter(fileWriter, static_cast<FILE*>(File));
   ProfBufferIO *IO = lprofCreateBufferIO(fileWriter);
   IO->OwnFileWriter = 1;
   return IO;
 }
 
 static void setupIOBuffer() {
   const char *BufferSzStr = 0;
   BufferSzStr = getenv("LLVM_VP_BUFFER_SIZE");

 
 /* mmap() \p ProfileFile for profile merging purposes, assuming that an
  * exclusive lock is held on the file and that \p ProfileFileSize is the
  * length of the file. Return the mmap'd buffer in the inout variable
  * \p ProfileBuffer. Returns -1 on failure. On success, the caller is
  * responsible for unmapping the mmap'd buffer in \p ProfileBuffer. */
 static int mmapProfileForMerging(FILE *ProfileFile, uint64_t ProfileFileSize,
                                  char **ProfileBuffer) {
-  *ProfileBuffer = mmap(NULL, ProfileFileSize, PROT_READ, MAP_SHARED | MAP_FILE,
-                        fileno(ProfileFile), 0);
+  *ProfileBuffer = static_cast<char*>(mmap(NULL, ProfileFileSize, PROT_READ,
+                                           MAP_SHARED | MAP_FILE, fileno(ProfileFile), 0));
   if (*ProfileBuffer == MAP_FAILED) {
     PROF_ERR("Unable to merge profile data, mmap failed: %s\n",
              strerror(errno));
     return -1;
   }
 
   if (__llvm_profile_check_compatibility(*ProfileBuffer, ProfileFileSize)) {
     (void)munmap(*ProfileBuffer, ProfileFileSize);
if (doMerging()) {
     lprofUnlockFileHandle(File);
     fclose(File);
   }
 }
 
 static const char *DefaultProfileName = "default.profraw";
 static void resetFilenameToDefault(void) {
   if (lprofCurFilename.FilenamePat && lprofCurFilename.OwnsFilenamePat) {
-    free((void *)lprofCurFilename.FilenamePat);
+    free(const_cast<char *>(lprofCurFilename.FilenamePat));
   }
   memset(&lprofCurFilename, 0, sizeof(lprofCurFilename));
   lprofCurFilename.FilenamePat = DefaultProfileName;
   lprofCurFilename.PNS = PNS_default;
 }
 
 static unsigned getMergePoolSize(const char *FilenamePat, int *I) {
   unsigned J = 0, Num = 0;
static int parseFilenamePattern(const char *FilenamePat,
   int NumPids = 0, NumHosts = 0, I;
   char *PidChars = &lprofCurFilename.PidChars[0];
   char *Hostname = &lprofCurFilename.Hostname[0];
   int MergingEnabled = 0;
   int FilenamePatLen = strlen(FilenamePat);
 
   /* Clean up cached prefix and filename.  */
   if (lprofCurFilename.ProfilePathPrefix)
-    free((void *)lprofCurFilename.ProfilePathPrefix);
+    free(const_cast<char *>(lprofCurFilename.ProfilePathPrefix));
 
   if (lprofCurFilename.FilenamePat && lprofCurFilename.OwnsFilenamePat) {
-    free((void *)lprofCurFilename.FilenamePat);
+    free(const_cast<char *>(lprofCurFilename.FilenamePat));
   }
 
   memset(&lprofCurFilename, 0, sizeof(lprofCurFilename));
 
   if (!CopyFilenamePat)
     lprofCurFilename.FilenamePat = FilenamePat;
   else {
     lprofCurFilename.FilenamePat = strdup(FilenamePat);
if (__llvm_profile_is_continuous_mode_enabled()) {
     lprofUnlockFileHandle(File);
   } else {
     setProfileFile(File);
     setProfileMergeRequested(EnableMerge);
   }
   return 0;
 }
 
+}
+
 #endif

compiler-rt/lib/profile/InstrProfilingInternal.h

 /*===- InstrProfiling.h- 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
 |*
 \*===----------------------------------------------------------------------===*/
 
 #ifndef PROFILE_INSTRPROFILING_INTERNALH_
 #define PROFILE_INSTRPROFILING_INTERNALH_
 
 #include <stddef.h>
 
 #include "InstrProfiling.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*!
  * \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(
     const __llvm_profile_data *DataBegin, const __llvm_profile_data *DataEnd,

  * The class that defines a set of methods to read value profile
  * data for streaming/serialization from the instrumentation runtime.
  */
 typedef struct VPDataReaderType {
   uint32_t (*InitRTRecord)(const __llvm_profile_data *Data,
                            uint8_t *SiteCountArray[]);
   /* Function pointer to getValueProfRecordHeader method. */
   uint32_t (*GetValueProfRecordHeaderSize)(uint32_t NumSites);
-  /* Function pointer to getFristValueProfRecord method. */  
+  /* Function pointer to getFristValueProfRecord method. */
   struct ValueProfRecord *(*GetFirstValueProfRecord)(struct ValueProfData *);
   /* Return the number of value data for site \p Site.  */
   uint32_t (*GetNumValueDataForSite)(uint32_t VK, uint32_t Site);
-  /* Return the total size of the value profile data of the 
+  /* Return the total size of the value profile data of the
    * current function.  */
   uint32_t (*GetValueProfDataSize)(void);
-  /*! 
+  /*!
    * Read the next \p N value data for site \p Site and store the data
    * in \p Dst. \p StartNode is the first value node to start with if
    * it is not null. The function returns the pointer to the value
    * node pointer to be used as the \p StartNode of the next batch reading.
    * If there is nothing left, it returns NULL.
    */
   struct ValueProfNode *(*GetValueData)(uint32_t ValueKind, uint32_t Site,
                                         struct InstrProfValueData *Dst,

 
 /* Merge value profile data pointed to by SrcValueProfData into
  * in-memory profile counters pointed by to DstData.  */
 void lprofMergeValueProfData(struct ValueProfData *SrcValueProfData,
                              __llvm_profile_data *DstData);
 
 VPDataReaderType *lprofGetVPDataReader();
 
-/* Internal interface used by test to reset the max number of 
+/* Internal interface used by test to reset the max number of
  * tracked values per value site to be \p MaxVals.
  */
 void lprofSetMaxValsPerSite(uint32_t MaxVals);
 void lprofSetupValueProfiler();
 
 /* Return the profile header 'signature' value associated with the current
  * executable or shared library. The signature value can be used to for
  * a profile name that is unique to this load module so that it does not
  * collide with profiles from other binaries. It also allows shared libraries
  * to dump merged profile data into its own profile file. */
 uint64_t lprofGetLoadModuleSignature();
 
-/* 
+/*
  * Return non zero value if the profile data has already been
  * dumped to the file.
  */
 unsigned lprofProfileDumped(void);
 void lprofSetProfileDumped(unsigned);
 
 COMPILER_RT_VISIBILITY extern void (*FreeHook)(void *);
 COMPILER_RT_VISIBILITY extern uint8_t *DynamicBufferIOBuffer;
 COMPILER_RT_VISIBILITY extern uint32_t VPBufferSize;
 COMPILER_RT_VISIBILITY extern uint32_t VPMaxNumValsPerSite;
 /* Pointer to the start of static value counters to be allocted. */
 COMPILER_RT_VISIBILITY extern ValueProfNode *CurrentVNode;
 COMPILER_RT_VISIBILITY extern ValueProfNode *EndVNode;
 extern void (*VPMergeHook)(struct ValueProfData *, __llvm_profile_data *);
 
 /*
  * Write binary ids into profiles if writer is given.
  * Return -1 if an error occurs, otherwise, return total size of binary ids.
  */
 int __llvm_write_binary_ids(ProfDataWriter *Writer);
 
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
 #endif

compiler-rt/lib/profile/InstrProfilingInternal.cpp

 /*===- InstrProfilingInternal.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
 |*
 \*===----------------------------------------------------------------------===*/
 
 // Note: This is linked into the Darwin kernel, and must remain compatible
 // with freestanding compilation. See `darwin_add_builtin_libraries`.
 
 #if !defined(__Fuchsia__)
 
 #include "InstrProfilingInternal.h"
 
+extern "C" {
+
 static unsigned ProfileDumped = 0;
 
 COMPILER_RT_VISIBILITY unsigned lprofProfileDumped() {
   return ProfileDumped;
 }
 
 COMPILER_RT_VISIBILITY void lprofSetProfileDumped(unsigned Value) {
   ProfileDumped = Value;
 }
 
+} // extern "C"
+
 #endif

compiler-rt/lib/profile/InstrProfilingMerge.cpp

 
 #include "InstrProfiling.h"
 #include "InstrProfilingInternal.h"
 #include "InstrProfilingUtil.h"
 
 #define INSTR_PROF_VALUE_PROF_DATA
 #include "profile/InstrProfData.inc"
 
+extern "C" {
+
 COMPILER_RT_VISIBILITY
 void (*VPMergeHook)(ValueProfData *, __llvm_profile_data *);
 
 COMPILER_RT_VISIBILITY
 uint64_t lprofGetLoadModuleSignature() {
   /* A very fast way to compute a module signature.  */
   uint64_t Version = __llvm_profile_get_version();
   uint64_t NumCounters = __llvm_profile_get_num_counters(
return (NamesSize << 40) + (NumCounters << 30) + (NumData << 20) +
          __llvm_profile_get_magic();
 }
 
 /* Returns 1 if profile is not structurally compatible.  */
 COMPILER_RT_VISIBILITY
 int __llvm_profile_check_compatibility(const char *ProfileData,
                                        uint64_t ProfileSize) {
   /* Check profile header only for now  */
-  __llvm_profile_header *Header = (__llvm_profile_header *)ProfileData;
-  __llvm_profile_data *SrcDataStart, *SrcDataEnd, *SrcData, *DstData;
+  const __llvm_profile_header *Header = (const __llvm_profile_header *)ProfileData;
+  const __llvm_profile_data *SrcDataStart, *SrcDataEnd, *SrcData, *DstData;
   SrcDataStart =
-      (__llvm_profile_data *)(ProfileData + sizeof(__llvm_profile_header) +
+      (const __llvm_profile_data *)(ProfileData + sizeof(__llvm_profile_header) +
                               Header->BinaryIdsSize);
   SrcDataEnd = SrcDataStart + Header->DataSize;
 
   if (ProfileSize < sizeof(__llvm_profile_header))
     return 1;
 
   /* Check the header first.  */
   if (Header->Magic != __llvm_profile_get_magic() ||
int __llvm_profile_check_compatibility(const char *ProfileData,
 
   if (ProfileSize <
       sizeof(__llvm_profile_header) + Header->BinaryIdsSize +
           Header->DataSize * sizeof(__llvm_profile_data) + Header->NamesSize +
           Header->CountersSize * __llvm_profile_counter_entry_size())
     return 1;
 
   for (SrcData = SrcDataStart,
-       DstData = (__llvm_profile_data *)__llvm_profile_begin_data();
+       DstData = (const __llvm_profile_data *)__llvm_profile_begin_data();
        SrcData < SrcDataEnd; ++SrcData, ++DstData) {
     if (SrcData->NameRef != DstData->NameRef ||
         SrcData->FuncHash != DstData->FuncHash ||
         SrcData->NumCounters != DstData->NumCounters)
       return 1;
   }
 
   /* Matched! */
int __llvm_profile_merge_from_buffer(const char *ProfileData,
   if (__llvm_profile_get_version() & VARIANT_MASK_DBG_CORRELATE) {
     PROF_ERR(
         "%s\n",
         "Debug info correlation does not support profile merging at runtime. "
         "Instead, merge raw profiles using the llvm-profdata tool.");
     return 1;
   }
 
-  __llvm_profile_data *SrcDataStart, *SrcDataEnd, *SrcData, *DstData;
-  __llvm_profile_header *Header = (__llvm_profile_header *)ProfileData;
-  char *SrcCountersStart;
-  const char *SrcNameStart;
-  const char *SrcValueProfDataStart, *SrcValueProfData;
+  const __llvm_profile_data *SrcDataStart, *SrcDataEnd, *SrcData, *DstData;
+  const __llvm_profile_header *Header = (const __llvm_profile_header *)ProfileData;
+  uintptr_t SrcCountersStart;
+  uintptr_t SrcNameStart;
+  uintptr_t SrcValueProfDataStart, SrcValueProfData;
   uintptr_t CountersDelta = Header->CountersDelta;
 
   SrcDataStart =
-      (__llvm_profile_data *)(ProfileData + sizeof(__llvm_profile_header) +
+      (const __llvm_profile_data *)(ProfileData + sizeof(__llvm_profile_header) +
                               Header->BinaryIdsSize);
   SrcDataEnd = SrcDataStart + Header->DataSize;
-  SrcCountersStart = (char *)SrcDataEnd;
+  SrcCountersStart = (uintptr_t)SrcDataEnd;
   SrcNameStart = SrcCountersStart +
                  Header->CountersSize * __llvm_profile_counter_entry_size();
   SrcValueProfDataStart =
       SrcNameStart + Header->NamesSize +
       __llvm_profile_get_num_padding_bytes(Header->NamesSize);
   if (SrcNameStart < SrcCountersStart)
     return 1;
 
   for (SrcData = SrcDataStart,
-      DstData = (__llvm_profile_data *)__llvm_profile_begin_data(),
+      DstData = (const __llvm_profile_data *)__llvm_profile_begin_data(),
       SrcValueProfData = SrcValueProfDataStart;
        SrcData < SrcDataEnd; ++SrcData, ++DstData) {
     // For the in-memory destination, CounterPtr is the distance from the start
     // address of the data to the start address of the counter. On WIN64,
     // CounterPtr is a truncated 32-bit value due to COFF limitation. Sign
     // extend CounterPtr to get the original value.
     char *DstCounters =
         (char *)((uintptr_t)DstData + signextIfWin64(DstData->CounterPtr));
     unsigned NVK = 0;
 
     // SrcData is a serialized representation of the memory image. We need to
     // compute the in-buffer counter offset from the in-memory address distance.
     // The initial CountersDelta is the in-memory address difference
     // start(__llvm_prf_cnts)-start(__llvm_prf_data), so SrcData->CounterPtr -
     // CountersDelta computes the offset into the in-buffer counter section.
     //
     // On WIN64, CountersDelta is truncated as well, so no need for signext.
-    char *SrcCounters =
+    uintptr_t SrcCounters =
         SrcCountersStart + ((uintptr_t)SrcData->CounterPtr - CountersDelta);
     // CountersDelta needs to be decreased as we advance to the next data
     // record.
     CountersDelta -= sizeof(*SrcData);
     unsigned NC = SrcData->NumCounters;
     if (NC == 0)
       return 1;
     if (SrcCounters < SrcCountersStart || SrcCounters >= SrcNameStart ||
         (SrcCounters + __llvm_profile_counter_entry_size() * NC) > SrcNameStart)
       return 1;
     for (unsigned I = 0; I < NC; I++)
       ((uint64_t *)DstCounters)[I] += ((uint64_t *)SrcCounters)[I];
 
     /* Now merge value profile data. */
     if (!VPMergeHook)
       continue;
 
     for (unsigned I = 0; I <= IPVK_Last; I++)
       NVK += (SrcData->NumValueSites[I] != 0);
 
     if (!NVK)
       continue;
 
-    if (SrcValueProfData >= ProfileData + ProfileSize)
+    if (SrcValueProfData >= (uintptr_t)ProfileData + ProfileSize)
       return 1;
-    VPMergeHook((ValueProfData *)SrcValueProfData, DstData);
+    VPMergeHook((ValueProfData *)SrcValueProfData, const_cast<__llvm_profile_data *>(DstData));
     SrcValueProfData =
         SrcValueProfData + ((ValueProfData *)SrcValueProfData)->TotalSize;
   }
 
   return 0;
 }
+
+} // extern "C"

compiler-rt/lib/profile/InstrProfilingMergeFile.cpp

 
 #include "InstrProfiling.h"
 #include "InstrProfilingInternal.h"
 #include "InstrProfilingUtil.h"
 
 #define INSTR_PROF_VALUE_PROF_DATA
 #include "profile/InstrProfData.inc"
 
+extern "C" {
+
 /* Merge value profile data pointed to by SrcValueProfData into
  * in-memory profile counters pointed by to DstData.  */
 COMPILER_RT_VISIBILITY
 void lprofMergeValueProfData(ValueProfData *SrcValueProfData,
                              __llvm_profile_data *DstData) {
   unsigned I, S, V, DstIndex = 0;
   InstrProfValueData *VData;
   ValueProfRecord *VR = getFirstValueProfRecord(SrcValueProfData);
   for (I = 0; I < SrcValueProfData->NumValueKinds; I++) {
     VData = getValueProfRecordValueData(VR);
     unsigned SrcIndex = 0;
     for (S = 0; S < VR->NumValueSites; S++) {
       uint8_t NV = VR->SiteCountArray[S];
       for (V = 0; V < NV; V++) {
         __llvm_profile_instrument_target_value(VData[SrcIndex].Value, DstData,
                                                DstIndex, VData[SrcIndex].Count);
         ++SrcIndex;
       }
       ++DstIndex;
     }
     VR = getValueProfRecordNext(VR);
   }
 }
 
+} // extern "C"
+
 #endif

compiler-rt/lib/profile/InstrProfilingNameVar.cpp

 /*===- InstrProfilingNameVar.c - profile name variable setup  -------------===*\
 |*
 |* 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
 |*
 \*===----------------------------------------------------------------------===*/
 
 #include "InstrProfiling.h"
 
+extern "C" {
+
 /* char __llvm_profile_filename[1]
  *
  * The runtime should only provide its own definition of this symbol when the
  * user has not specified one. Set this up by moving the runtime's copy of this
  * symbol to an object file within the archive.
  */
 COMPILER_RT_WEAK char INSTR_PROF_PROFILE_NAME_VAR[1] = {0};
+
+} // extern "C"

compiler-rt/lib/profile/InstrProfilingPlatformDarwin.cpp

 /*===- InstrProfilingPlatformDarwin.c - Profile data on Darwin ------------===*\
 |*
 |* 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
 |*
 \*===----------------------------------------------------------------------===*/
 
 // Note: This is linked into the Darwin kernel, and must remain compatible
 // with freestanding compilation. See `darwin_add_builtin_libraries`.
 
 #include "InstrProfiling.h"
 #include "InstrProfilingInternal.h"
 
+extern "C" {
+
 #if defined(__APPLE__)
 /* Use linker magic to find the bounds of the Data section. */
 COMPILER_RT_VISIBILITY
 extern __llvm_profile_data
     DataStart __asm("section$start$__DATA$" INSTR_PROF_DATA_SECT_NAME);
 COMPILER_RT_VISIBILITY
 extern __llvm_profile_data
     DataEnd __asm("section$end$__DATA$" INSTR_PROF_DATA_SECT_NAME);

 COMPILER_RT_VISIBILITY ValueProfNode *CurrentVNode = &VNodesStart;
 COMPILER_RT_VISIBILITY ValueProfNode *EndVNode = &VNodesEnd;
 
 COMPILER_RT_VISIBILITY int __llvm_write_binary_ids(ProfDataWriter *Writer) {
   return 0;
 }
 
 #endif
+
+} // extern "C"

compiler-rt/lib/profile/InstrProfilingPlatformFuchsia.cpp

 #include <zircon/sanitizer.h>
 #include <zircon/status.h>
 #include <zircon/syscalls.h>
 
 #include "InstrProfiling.h"
 #include "InstrProfilingInternal.h"
 #include "InstrProfilingUtil.h"
 
+extern "C" {
+
 /* This variable is an external reference to symbol defined by the compiler. */
 COMPILER_RT_VISIBILITY extern intptr_t INSTR_PROF_PROFILE_COUNTER_BIAS_VAR;
 
 COMPILER_RT_VISIBILITY unsigned lprofProfileDumped() {
   return 1;
 }
 COMPILER_RT_VISIBILITY void lprofSetProfileDumped(unsigned Value) {}
 
void __llvm_profile_initialize(void) {
   /* Update the profile fields based on the current mapping. */
   INSTR_PROF_PROFILE_COUNTER_BIAS_VAR =
       (intptr_t)Mapping - (uintptr_t)CountersBegin + CountersOffset;
 
   /* Return the memory allocated for counters to OS. */
   lprofReleaseMemoryPagesToOS((uintptr_t)CountersBegin, (uintptr_t)CountersEnd);
 }
 
+} // extern "C"
+
 #endif

compiler-rt/lib/profile/InstrProfilingPlatformLinux.cpp

 #include <elf.h>
 #include <link.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "InstrProfiling.h"
 #include "InstrProfilingInternal.h"
 
+extern "C" {
+
 #if defined(__FreeBSD__) && !defined(ElfW)
 /*
  * FreeBSD's elf.h and link.h headers do not define the ElfW(type) macro yet.
  * If this is added to all supported FreeBSD versions in the future, this
  * compatibility macro can be removed.
  */
 #define ElfW(type) __ElfN(type)
 #endif

  * Write binary id length and then its data, because binary id does not
  * have a fixed length.
  */
 static int WriteOneBinaryId(ProfDataWriter *Writer, uint64_t BinaryIdLen,
                             const uint8_t *BinaryIdData,
                             uint64_t BinaryIdPadding) {
   ProfDataIOVec BinaryIdIOVec[] = {
       {&BinaryIdLen, sizeof(uint64_t), 1, 0},
-      {BinaryIdData, sizeof(uint8_t), BinaryIdLen, 0},
-      {NULL, sizeof(uint8_t), BinaryIdPadding, 1},
+      {BinaryIdData, sizeof(uint8_t), static_cast<size_t>(BinaryIdLen), 0},
+      {NULL, sizeof(uint8_t), static_cast<size_t>(BinaryIdPadding), 1},
   };
   if (Writer->Write(Writer, BinaryIdIOVec,
                     sizeof(BinaryIdIOVec) / sizeof(*BinaryIdIOVec)))
     return -1;
 
   /* Successfully wrote binary id, report success. */
   return 0;
 }

  * Fallback implementation for targets that don't support the GNU
  * extensions NT_GNU_BUILD_ID and __ehdr_start.
  */
 COMPILER_RT_VISIBILITY int __llvm_write_binary_ids(ProfDataWriter *Writer) {
   return 0;
 }
 #endif
 
+} // extern "C"
+
 #endif

compiler-rt/lib/profile/InstrProfilingPlatformOther.cpp

#if !defined(__APPLE__) && !defined(__linux__) && !defined(__FreeBSD__) &&     \
     !defined(_WIN32)
 
 #include <stdlib.h>
 #include <stdio.h>
 
 #include "InstrProfiling.h"
 #include "InstrProfilingInternal.h"
 
+extern "C" {
+
 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 char *CountersFirst = NULL;
 static char *CountersLast = NULL;
 static uint32_t *OrderFileFirst = NULL;
 

 
 COMPILER_RT_VISIBILITY ValueProfNode *CurrentVNode = 0;
 COMPILER_RT_VISIBILITY ValueProfNode *EndVNode = 0;
 
 COMPILER_RT_VISIBILITY int __llvm_write_binary_ids(ProfDataWriter *Writer) {
   return 0;
 }
 
+} // extern "C"
+
 #endif

compiler-rt/lib/profile/InstrProfilingPlatformWindows.cpp

 /*===- InstrProfilingPlatformWindows.c - Profile data on Windows ----------===*\
 |*
 |* 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
 |*
 \*===----------------------------------------------------------------------===*/
 
 #include "InstrProfiling.h"
 #include "InstrProfilingInternal.h"
 
 #if defined(_WIN32)
 
+extern "C" {
+
 #if defined(_MSC_VER)
 /* Merge read-write sections into .data. */
 #pragma comment(linker, "/MERGE:.lprfc=.data")
 #pragma comment(linker, "/MERGE:.lprfd=.data")
 #pragma comment(linker, "/MERGE:.lprfv=.data")
 #pragma comment(linker, "/MERGE:.lprfnd=.data")
 /* Do *NOT* merge .lprfn and .lcovmap into .rdata. llvm-cov must be able to find
  * after the fact.

 
 ValueProfNode *CurrentVNode = &VNodesStart + 1;
 ValueProfNode *EndVNode = &VNodesEnd;
 
 COMPILER_RT_VISIBILITY int __llvm_write_binary_ids(ProfDataWriter *Writer) {
   return 0;
 }
 
+} // extern "C"
+
 #endif

compiler-rt/lib/profile/InstrProfilingUtil.h

 /*===- InstrProfilingUtil.h - 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
 |*
 \*===----------------------------------------------------------------------===*/
 
 #ifndef PROFILE_INSTRPROFILINGUTIL_H
 #define PROFILE_INSTRPROFILINGUTIL_H
 
 #include <inttypes.h>
 #include <stddef.h>
 #include <stdio.h>
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*! \brief Create a directory tree. */
 void __llvm_profile_recursive_mkdir(char *Pathname);
 
 /*! Set the mode used when creating profile directories. */
 void __llvm_profile_set_dir_mode(unsigned Mode);
 
 /*! Return the directory creation mode. */
 unsigned __llvm_profile_get_dir_mode(void);
 
 int lprofLockFd(int fd);
 int lprofUnlockFd(int fd);
 int lprofLockFileHandle(FILE *F);
 int lprofUnlockFileHandle(FILE *F);
 
 /*! 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 setenv/getenv/fork. Define a shim. */
 #if __ORBIS__
 #include <sys/types.h>
 static inline char *getenv(const char *name) { return NULL; }
-static inline int setenv(const char *name, const char *value, int overwrite)
-{ return 0; }
+static inline int setenv(const char *name, const char *value, int overwrite) {
+  return 0;
+}
 static pid_t fork() { return -1; }
 #endif /* #if __ORBIS__ */
 
 /* GCOV_PREFIX and GCOV_PREFIX_STRIP support */
 /* Return the path prefix specified by GCOV_PREFIX environment variable.
  * If GCOV_PREFIX_STRIP is also specified, the strip level (integer value)
  * is returned via \c *PrefixStrip. The prefix length is stored in *PrefixLen.
  */

 }
 
 static inline size_t lprofRoundDownTo(size_t x, size_t boundary) {
   return x & ~(boundary - 1);
 }
 
 int lprofReleaseMemoryPagesToOS(uintptr_t Begin, uintptr_t End);
 
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
 #endif /* PROFILE_INSTRPROFILINGUTIL_H */

compiler-rt/lib/profile/InstrProfilingUtil.cpp

 #if defined(__FreeBSD__)
 #include <signal.h>
 #include <sys/procctl.h>
 #endif
 
 #include "InstrProfiling.h"
 #include "InstrProfilingUtil.h"
 
+extern "C" {
+
 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__) &&                        \

 #else
     return madvise((void *)BeginAligned, EndAligned - BeginAligned,
                    MADV_DONTNEED);
 #endif
   }
   return 0;
 #endif
 }
+
+} // extern "C"

compiler-rt/lib/profile/InstrProfilingValue.cpp

 #include "InstrProfilingInternal.h"
 #include "InstrProfilingUtil.h"
 
 #define INSTR_PROF_VALUE_PROF_DATA
 #define INSTR_PROF_COMMON_API_IMPL
 #define INSTR_PROF_VALUE_PROF_MEMOP_API
 #include "profile/InstrProfData.inc"
 
+extern "C" {
+
 static int hasStaticCounters = 1;
 static int OutOfNodesWarnings = 0;
 static int hasNonDefaultValsPerSite = 0;
 #define INSTR_PROF_MAX_VP_WARNS 10
 #define INSTR_PROF_DEFAULT_NUM_VAL_PER_SITE 24
 #define INSTR_PROF_VNODE_POOL_SIZE 1024
 
 #ifndef _MSC_VER
COMPILER_RT_VISIBILITY void lprofSetMaxValsPerSite(uint32_t MaxVals) {
   VPMaxNumValsPerSite = MaxVals;
   hasNonDefaultValsPerSite = 1;
 }
 
 /* This method is only used in value profiler mock testing.  */
 COMPILER_RT_VISIBILITY void
 __llvm_profile_set_num_value_sites(__llvm_profile_data *Data,
                                    uint32_t ValueKind, uint16_t NumValueSites) {
-  *((uint16_t *)&Data->NumValueSites[ValueKind]) = NumValueSites;
+  *(const_cast<uint16_t *>(Data->NumValueSites + ValueKind)) = NumValueSites;
 }
 
 /* This method is only used in value profiler mock testing.  */
 COMPILER_RT_VISIBILITY const __llvm_profile_data *
 __llvm_profile_iterate_data(const __llvm_profile_data *Data) {
   return Data + 1;
 }
 

 static VPDataReaderType TheVPDataReader = {
     initializeValueProfRuntimeRecord, getValueProfRecordHeaderSize,
     getFirstValueProfRecord,          getNumValueDataForSiteWrapper,
     getValueProfDataSizeWrapper,      getNextNValueData};
 
 COMPILER_RT_VISIBILITY VPDataReaderType *lprofGetVPDataReader() {
   return &TheVPDataReader;
 }
+
+} // extern "C"

compiler-rt/lib/profile/InstrProfilingVersionVar.cpp

 /*===- InstrProfilingVersionVar.c - profile version variable setup  -------===*\
 |*
 |* 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
 |*
 \*===----------------------------------------------------------------------===*/
 
 #include "InstrProfiling.h"
 
+extern "C" {
+
 /* uint64 __llvm_profile_raw_version
  *
  * The runtime should only provide its own definition of this symbol when the
  * user has not specified one. Set this up by moving the runtime's copy of this
  * symbol to an object file within the archive.
  *
  * Hide this symbol everywhere except Apple platforms, where its presence is
  * checked by the TAPI tool.
  */
 #if !defined(__APPLE__)
 #define VERSION_VAR_VISIBILITY COMPILER_RT_VISIBILITY
 #else
 #define VERSION_VAR_VISIBILITY
 #endif
 VERSION_VAR_VISIBILITY COMPILER_RT_WEAK uint64_t INSTR_PROF_RAW_VERSION_VAR =
     INSTR_PROF_RAW_VERSION;
+
+} // extern "C"

compiler-rt/lib/profile/InstrProfilingWriter.cpp

 
 #include "InstrProfiling.h"
 #include "InstrProfilingInternal.h"
 #include "InstrProfilingPort.h"
 
 #define INSTR_PROF_VALUE_PROF_DATA
 #include "profile/InstrProfData.inc"
 
+extern "C" {
+
 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];
 static uint32_t VPDataArraySize = sizeof(VPDataArray) / sizeof(*VPDataArray);
 
 COMPILER_RT_VISIBILITY uint8_t *DynamicBufferIOBuffer = 0;
if (Writer->Write(Writer, IOVec, sizeof(IOVec) / sizeof(*IOVec)))
     return -1;
 
   /* Write the binary id lengths and data. */
   if (__llvm_write_binary_ids(Writer) == -1)
     return -1;
 
   /* Write the profile data. */
   ProfDataIOVec IOVecData[] = {
-      {DebugInfoCorrelate ? NULL : DataBegin, sizeof(uint8_t), DataSize, 0},
-      {NULL, sizeof(uint8_t), PaddingBytesBeforeCounters, 1},
-      {CountersBegin, sizeof(uint8_t), CountersSize, 0},
-      {NULL, sizeof(uint8_t), PaddingBytesAfterCounters, 1},
+      {DebugInfoCorrelate ? NULL : DataBegin, sizeof(uint8_t), static_cast<size_t>(DataSize), 0},
+      {NULL, sizeof(uint8_t), static_cast<size_t>(PaddingBytesBeforeCounters), 1},
+      {CountersBegin, sizeof(uint8_t), static_cast<size_t>(CountersSize), 0},
+      {NULL, sizeof(uint8_t), static_cast<size_t>(PaddingBytesAfterCounters), 1},
       {(SkipNameDataWrite || DebugInfoCorrelate) ? NULL : NamesBegin,
-       sizeof(uint8_t), NamesSize, 0},
-      {NULL, sizeof(uint8_t), PaddingBytesAfterNames, 1}};
+       sizeof(uint8_t), static_cast<size_t>(NamesSize), 0},
+      {NULL, sizeof(uint8_t), static_cast<size_t>(PaddingBytesAfterNames), 1}};
   if (Writer->Write(Writer, IOVecData, sizeof(IOVecData) / sizeof(*IOVecData)))
     return -1;
 
   /* Value profiling is not yet supported in continuous mode. */
   if (__llvm_profile_is_continuous_mode_enabled())
     return 0;
 
   return writeValueProfData(Writer, VPDataReader, DataBegin, DataEnd);
 }
+
+} // extern "C"