Merge from 'main' to 'sycl-web' (#7)

  CONFLICT (content): Merge conflict in clang/include/clang/Sema/Sema.h

Author: abhinavgaba

clang/lib/Headers/__clang_hip_runtime_wrapper.h

@@ -101,7 +101,6 @@ typedef __SIZE_TYPE__ size_t;
 #include <__clang_hip_libdevice_declares.h>
 #include <__clang_hip_math.h>
 
-#if !_OPENMP || __HIP_ENABLE_CUDA_WRAPPER_FOR_OPENMP__
 #if defined(__HIPCC_RTC__)
 #include <__clang_hip_cmath.h>
 #else
@@ -112,7 +111,6 @@ typedef __SIZE_TYPE__ size_t;
 #include <complex>
 #include <new>
 #endif // __HIPCC_RTC__
-#endif // !_OPENMP || __HIP_ENABLE_CUDA_WRAPPER_FOR_OPENMP__
 
 #define __CLANG_HIP_RUNTIME_WRAPPER_INCLUDED__ 1
 #if defined(__HIPCC_RTC__)

compiler-rt/include/profile/InstrProfData.inc

@@ -137,7 +137,6 @@ INSTR_PROF_RAW_HEADER(uint64_t, NamesSize,  NamesSize)
 INSTR_PROF_RAW_HEADER(uint64_t, CountersDelta, (uintptr_t)CountersBegin)
 INSTR_PROF_RAW_HEADER(uint64_t, NamesDelta, (uintptr_t)NamesBegin)
 INSTR_PROF_RAW_HEADER(uint64_t, ValueKindLast, IPVK_Last)
-INSTR_PROF_RAW_HEADER(uint64_t, BinaryIdsSize, __llvm_write_binary_ids(NULL))
 #undef INSTR_PROF_RAW_HEADER
 /* INSTR_PROF_RAW_HEADER  end */
 
@@ -646,7 +645,7 @@ serializeValueProfDataFrom(ValueProfRecordClosure *Closure,
         (uint64_t)'f' << 16 | (uint64_t)'R' << 8 | (uint64_t)129
 
 /* Raw profile format version (start from 1). */
-#define INSTR_PROF_RAW_VERSION 6
+#define INSTR_PROF_RAW_VERSION 5
 /* Indexed profile format version (start from 1). */
 #define INSTR_PROF_INDEX_VERSION 7
 /* Coverage mapping format version (start from 0). */

compiler-rt/lib/profile/InstrProfilingInternal.c

@@ -23,22 +23,4 @@ COMPILER_RT_VISIBILITY void lprofSetProfileDumped(unsigned Value) {
   ProfileDumped = Value;
 }
 
-static unsigned RuntimeCounterRelocation = 0;
-
-COMPILER_RT_VISIBILITY unsigned lprofRuntimeCounterRelocation(void) {
-  return RuntimeCounterRelocation;
-}
-
-COMPILER_RT_VISIBILITY void lprofSetRuntimeCounterRelocation(unsigned Value) {
-  RuntimeCounterRelocation = Value;
-}
-
-/*
- * The runtime provides the default definition of this function
- * for the platforms that do not support binary id.
- */
-COMPILER_RT_VISIBILITY int __llvm_write_binary_ids(ProfDataWriter *Writer) {
-  return 0;
-}
-
 #endif

compiler-rt/lib/profile/InstrProfilingInternal.h

@@ -193,10 +193,4 @@ 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.
- */
-COMPILER_RT_VISIBILITY int __llvm_write_binary_ids(ProfDataWriter *Writer);
-
 #endif

compiler-rt/lib/profile/InstrProfilingPlatformLinux.c

@@ -9,13 +9,9 @@
 #if defined(__linux__) || defined(__FreeBSD__) || defined(__Fuchsia__) || \
     (defined(__sun__) && defined(__svr4__)) || defined(__NetBSD__)
 
-#include <elf.h>
-#include <link.h>
 #include <stdlib.h>
-#include <string.h>
 
 #include "InstrProfiling.h"
-#include "InstrProfilingInternal.h"
 
 #define PROF_DATA_START INSTR_PROF_SECT_START(INSTR_PROF_DATA_COMMON)
 #define PROF_DATA_STOP INSTR_PROF_SECT_STOP(INSTR_PROF_DATA_COMMON)
@@ -76,108 +72,4 @@ COMPILER_RT_VISIBILITY ValueProfNode *__llvm_profile_end_vnodes(void) {
 COMPILER_RT_VISIBILITY ValueProfNode *CurrentVNode = &PROF_VNODES_START;
 COMPILER_RT_VISIBILITY ValueProfNode *EndVNode = &PROF_VNODES_STOP;
 
-static size_t RoundUp(size_t size, size_t align) {
-  return (size + align - 1) & ~(align - 1);
-}
-
-/*
- * Write binary id length and then its data, because binary id does not
- * have a fixed length.
- */
-int WriteOneBinaryId(ProfDataWriter *Writer, uint64_t BinaryIdLen,
-                     const uint8_t *BinaryIdData) {
-  ProfDataIOVec BinaryIdIOVec[] = {
-      {&BinaryIdLen, sizeof(uint64_t), 1, 0},
-      {BinaryIdData, sizeof(uint8_t), BinaryIdLen, 0}};
-  if (Writer->Write(Writer, BinaryIdIOVec,
-                    sizeof(BinaryIdIOVec) / sizeof(*BinaryIdIOVec)))
-    return -1;
-
-  /* Successfully wrote binary id, report success. */
-  return 0;
-}
-
-/*
- * Look for the note that has the name "GNU\0" and type NT_GNU_BUILD_ID
- * that contains build id. If build id exists, write binary id.
- *
- * Each note in notes section starts with a struct which includes
- * n_namesz, n_descsz, and n_type members. It is followed by the name
- * (whose length is defined in n_namesz) and then by the descriptor
- * (whose length is defined in n_descsz).
- *
- * Note sections like .note.ABI-tag and .note.gnu.build-id are aligned
- * to 4 bytes, so round n_namesz and n_descsz to the nearest 4 bytes.
- */
-int WriteBinaryIdForNote(ProfDataWriter *Writer, const ElfW(Nhdr) * Note) {
-  int BinaryIdSize = 0;
-
-  const char *NoteName = (const char *)Note + sizeof(ElfW(Nhdr));
-  if (Note->n_type == NT_GNU_BUILD_ID && Note->n_namesz == 4 &&
-      memcmp(NoteName, "GNU\0", 4) == 0) {
-
-    uint64_t BinaryIdLen = Note->n_descsz;
-    const uint8_t *BinaryIdData =
-        (const uint8_t *)(NoteName + RoundUp(Note->n_namesz, 4));
-    if (Writer != NULL &&
-        WriteOneBinaryId(Writer, BinaryIdLen, BinaryIdData) == -1)
-      return -1;
-
-    BinaryIdSize = sizeof(BinaryIdLen) + BinaryIdLen;
-  }
-
-  return BinaryIdSize;
-}
-
-/*
- * Helper function that iterates through notes section and find build ids.
- * If writer is given, write binary ids into profiles.
- * If an error happens while writing, return -1.
- */
-int WriteBinaryIds(ProfDataWriter *Writer, const ElfW(Nhdr) * Note,
-                   const ElfW(Nhdr) * NotesEnd) {
-  int TotalBinaryIdsSize = 0;
-  while (Note < NotesEnd) {
-    int Result = WriteBinaryIdForNote(Writer, Note);
-    if (Result == -1)
-      return -1;
-    TotalBinaryIdsSize += Result;
-
-    /* Calculate the offset of the next note in notes section. */
-    size_t NoteOffset = sizeof(ElfW(Nhdr)) + RoundUp(Note->n_namesz, 4) +
-                        RoundUp(Note->n_descsz, 4);
-    Note = (const ElfW(Nhdr) *)((const char *)(Note) + NoteOffset);
-  }
-
-  return TotalBinaryIdsSize;
-}
-
-/*
- * Write binary ids into profiles if writer is given.
- * Return the total size of binary ids.
- * If an error happens while writing, return -1.
- */
-COMPILER_RT_VISIBILITY int __llvm_write_binary_ids(ProfDataWriter *Writer) {
-  extern const ElfW(Ehdr) __ehdr_start __attribute__((visibility("hidden")));
-  const ElfW(Ehdr) *ElfHeader = &__ehdr_start;
-  const ElfW(Phdr) *ProgramHeader =
-      (const ElfW(Phdr) *)((uintptr_t)ElfHeader + ElfHeader->e_phoff);
-
-  uint32_t I;
-  /* Iterate through entries in the program header. */
-  for (I = 0; I < ElfHeader->e_phnum; I++) {
-    /* Look for the notes section in program header entries. */
-    if (ProgramHeader[I].p_type != PT_NOTE)
-      continue;
-
-    const ElfW(Nhdr) *Note =
-        (const ElfW(Nhdr) *)((uintptr_t)ElfHeader + ProgramHeader[I].p_offset);
-    const ElfW(Nhdr) *NotesEnd =
-        (const ElfW(Nhdr) *)((const char *)(Note) + ProgramHeader[I].p_filesz);
-    return WriteBinaryIds(Writer, Note, NotesEnd);
-  }
-
-  return 0;
-}
-
 #endif

compiler-rt/lib/profile/InstrProfilingWriter.c

@@ -283,24 +283,16 @@ lprofWriteDataImpl(ProfDataWriter *Writer, const __llvm_profile_data *DataBegin,
 #define INSTR_PROF_RAW_HEADER(Type, Name, Init) Header.Name = Init;
 #include "profile/InstrProfData.inc"
 
-  /* Write the profile header. */
-  ProfDataIOVec IOVec[] = {{&Header, sizeof(__llvm_profile_header), 1, 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[] = {
+  /* Write the data. */
+  ProfDataIOVec IOVec[] = {
+      {&Header, sizeof(__llvm_profile_header), 1, 0},
       {DataBegin, sizeof(__llvm_profile_data), DataSize, 0},
       {NULL, sizeof(uint8_t), PaddingBytesBeforeCounters, 1},
       {CountersBegin, sizeof(uint64_t), CountersSize, 0},
       {NULL, sizeof(uint8_t), PaddingBytesAfterCounters, 1},
       {SkipNameDataWrite ? NULL : NamesBegin, sizeof(uint8_t), NamesSize, 0},
       {NULL, sizeof(uint8_t), PaddingBytesAfterNames, 1}};
-  if (Writer->Write(Writer, IOVecData, sizeof(IOVecData) / sizeof(*IOVecData)))
+  if (Writer->Write(Writer, IOVec, sizeof(IOVec) / sizeof(*IOVec)))
     return -1;
 
   /* Value profiling is not yet supported in continuous mode. */

compiler-rt/lib/sanitizer_common/sanitizer_mac.cpp

@@ -532,7 +532,7 @@ void BlockingMutex::Unlock() {
 }
 
 void BlockingMutex::CheckLocked() const {
-  CHECK_NE(*(OSSpinLock*)&opaque_storage_, 0);
+  CHECK_NE(*(const OSSpinLock*)&opaque_storage_, 0);
 }
 
 u64 NanoTime() {

compiler-rt/test/profile/Linux/corrupted-profile.c

@@ -43,9 +43,9 @@ int main(int argc, char** argv) {
       bail("mmap");
 
     // We're trying to make the first CounterPtr invalid.
-    // 11 64-bit words as header.
+    // 10 64-bit words as header.
     // CounterPtr is the third 64-bit word field.
-    memset(&Buf[11 * 8 + 2 * 8], 0xAB, 8);
+    memset(&Buf[10 * 8 + 2 * 8], 0xAB, 8);
 
     if (munmap(Buf, FileSize))
       bail("munmap");

compiler-rt/test/profile/binary-id.c

@@ -1103,7 +1103,6 @@ namespace RawInstrProf {
 // raw header.
 // Version 5: Bit 60 of FuncHash is reserved for the flag for the context
 // sensitive records.
-// Version 6: Added binary id.
 const uint64_t Version = INSTR_PROF_RAW_VERSION;
 
 template <class IntPtrT> inline uint64_t getMagic();

llvm/include/llvm/ProfileData/InstrProf.h

@@ -137,7 +137,6 @@ INSTR_PROF_RAW_HEADER(uint64_t, NamesSize,  NamesSize)
 INSTR_PROF_RAW_HEADER(uint64_t, CountersDelta, (uintptr_t)CountersBegin)
 INSTR_PROF_RAW_HEADER(uint64_t, NamesDelta, (uintptr_t)NamesBegin)
 INSTR_PROF_RAW_HEADER(uint64_t, ValueKindLast, IPVK_Last)
-INSTR_PROF_RAW_HEADER(uint64_t, BinaryIdsSize, __llvm_write_binary_ids(NULL))
 #undef INSTR_PROF_RAW_HEADER
 /* INSTR_PROF_RAW_HEADER  end */
 
@@ -646,7 +645,7 @@ serializeValueProfDataFrom(ValueProfRecordClosure *Closure,
         (uint64_t)'f' << 16 | (uint64_t)'R' << 8 | (uint64_t)129
 
 /* Raw profile format version (start from 1). */
-#define INSTR_PROF_RAW_VERSION 6
+#define INSTR_PROF_RAW_VERSION 5
 /* Indexed profile format version (start from 1). */
 #define INSTR_PROF_INDEX_VERSION 7
 /* Coverage mapping format version (start from 0). */

llvm/include/llvm/ProfileData/InstrProfData.inc

@@ -82,9 +82,6 @@ class InstrProfReader {
   /// Read a single record.
   virtual Error readNextRecord(NamedInstrProfRecord &Record) = 0;
 
-  /// Print binary ids on stream OS.
-  virtual Error printBinaryIds(raw_ostream &OS) { return success(); };
-
   /// Iterator over profile data.
   InstrProfIterator begin() { return InstrProfIterator(this); }
   InstrProfIterator end() { return InstrProfIterator(); }
@@ -225,9 +222,6 @@ class RawInstrProfReader : public InstrProfReader {
   uint32_t ValueKindLast;
   uint32_t CurValueDataSize;
 
-  uint64_t BinaryIdsSize;
-  const uint8_t *BinaryIdsStart;
-
 public:
   RawInstrProfReader(std::unique_ptr<MemoryBuffer> DataBuffer)
       : DataBuffer(std::move(DataBuffer)) {}
@@ -237,7 +231,6 @@ class RawInstrProfReader : public InstrProfReader {
   static bool hasFormat(const MemoryBuffer &DataBuffer);
   Error readHeader() override;
   Error readNextRecord(NamedInstrProfRecord &Record) override;
-  Error printBinaryIds(raw_ostream &OS) override;
 
   bool isIRLevelProfile() const override {
     return (Version & VARIANT_MASK_IR_PROF) != 0;

llvm/include/llvm/ProfileData/InstrProfReader.h

@@ -24,8 +24,8 @@
 #include "llvm/Support/Error.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/MemoryBuffer.h"
-#include "llvm/Support/SwapByteOrder.h"
 #include "llvm/Support/SymbolRemappingReader.h"
+#include "llvm/Support/SwapByteOrder.h"
 #include <algorithm>
 #include <cctype>
 #include <cstddef>
@@ -374,13 +374,11 @@ Error RawInstrProfReader<IntPtrT>::readHeader(
   auto PaddingBytesAfterCounters = swap(Header.PaddingBytesAfterCounters);
   NamesSize = swap(Header.NamesSize);
   ValueKindLast = swap(Header.ValueKindLast);
-  BinaryIdsSize = swap(Header.BinaryIdsSize);
 
   auto DataSizeInBytes = DataSize * sizeof(RawInstrProf::ProfileData<IntPtrT>);
   auto PaddingSize = getNumPaddingBytes(NamesSize);
 
-  // Profile data starts after profile header and binary ids if exist.
-  ptrdiff_t DataOffset = sizeof(RawInstrProf::Header) + BinaryIdsSize;
+  ptrdiff_t DataOffset = sizeof(RawInstrProf::Header);
   ptrdiff_t CountersOffset =
       DataOffset + DataSizeInBytes + PaddingBytesBeforeCounters;
   ptrdiff_t NamesOffset = CountersOffset + (sizeof(uint64_t) * CountersSize) +
@@ -394,10 +392,6 @@ Error RawInstrProfReader<IntPtrT>::readHeader(
   Data = reinterpret_cast<const RawInstrProf::ProfileData<IntPtrT> *>(
       Start + DataOffset);
   DataEnd = Data + DataSize;
-
-  // Binary ids start just after the header.
-  BinaryIdsStart =
-      reinterpret_cast<const uint8_t *>(&Header) + sizeof(RawInstrProf::Header);
   CountersStart = reinterpret_cast<const uint64_t *>(Start + CountersOffset);
   NamesStart = Start + NamesOffset;
   ValueDataStart = reinterpret_cast<const uint8_t *>(Start + ValueDataOffset);
@@ -512,33 +506,6 @@ Error RawInstrProfReader<IntPtrT>::readNextRecord(NamedInstrProfRecord &Record)
   return success();
 }
 
-template <class IntPtrT>
-Error RawInstrProfReader<IntPtrT>::printBinaryIds(raw_ostream &OS) {
-  if (BinaryIdsSize == 0)
-    return success();
-
-  OS << "Binary IDs: \n";
-  const uint8_t *BI = BinaryIdsStart;
-  while (BI < BinaryIdsStart + BinaryIdsSize) {
-    uint64_t BinaryIdLen = swap(*reinterpret_cast<const uint64_t *>(BI));
-    // Increment by binary id length data type size.
-    BI += sizeof(BinaryIdLen);
-    if (BI > (const uint8_t *)DataBuffer->getBufferEnd())
-      return make_error<InstrProfError>(instrprof_error::malformed);
-
-    for (uint64_t I = 0; I < BinaryIdLen; I++)
-      OS << format("%02x", BI[I]);
-    OS << "\n";
-
-    // Increment by binary id data length.
-    BI += BinaryIdLen;
-    if (BI > (const uint8_t *)DataBuffer->getBufferEnd())
-      return make_error<InstrProfError>(instrprof_error::malformed);
-  }
-
-  return success();
-}
-
 namespace llvm {
 
 template class RawInstrProfReader<uint32_t>;