[compiler-rt] [llvm] Revert type profiling change as compiler-rt test break on Windows. (PR #82583)
via llvm-commits
llvm-commits at lists.llvm.org
Wed Feb 21 21:41:24 PST 2024
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-pgo
Author: Mingming Liu (minglotus-6)
<details>
<summary>Changes</summary>
Examples https://lab.llvm.org/buildbot/#/builders/127/builds/62532/steps/8/logs/stdio
---
Patch is 70.88 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/82583.diff
32 Files Affected:
- (modified) compiler-rt/include/profile/InstrProfData.inc (+3-47)
- (modified) compiler-rt/lib/profile/InstrProfiling.h (+7-28)
- (modified) compiler-rt/lib/profile/InstrProfilingBuffer.c (+15-81)
- (modified) compiler-rt/lib/profile/InstrProfilingInternal.h (+2-6)
- (modified) compiler-rt/lib/profile/InstrProfilingMerge.c (+2-21)
- (modified) compiler-rt/lib/profile/InstrProfilingPlatformLinux.c (-20)
- (modified) compiler-rt/lib/profile/InstrProfilingWriter.c (+8-29)
- (modified) compiler-rt/test/profile/instrprof-write-buffer-internal.c (+2-4)
- (modified) llvm/include/llvm/ProfileData/InstrProf.h (+3-14)
- (modified) llvm/include/llvm/ProfileData/InstrProfData.inc (+3-47)
- (modified) llvm/include/llvm/ProfileData/InstrProfReader.h (-13)
- (modified) llvm/lib/ProfileData/InstrProf.cpp (+2-9)
- (modified) llvm/lib/ProfileData/InstrProfReader.cpp (+2-42)
- (modified) llvm/lib/ProfileData/InstrProfWriter.cpp (+7-36)
- (modified) llvm/test/Instrumentation/InstrProfiling/coverage.ll (+4-4)
- (modified) llvm/test/Transforms/PGOProfile/Inputs/thinlto_indirect_call_promotion.profraw ()
- (modified) llvm/test/Transforms/PGOProfile/comdat_internal.ll (+2-2)
- (modified) llvm/test/tools/llvm-profdata/Inputs/c-general.profraw ()
- (modified) llvm/test/tools/llvm-profdata/Inputs/compressed.profraw ()
- (removed) llvm/test/tools/llvm-profdata/Inputs/thinlto_indirect_call_promotion.profraw ()
- (modified) llvm/test/tools/llvm-profdata/binary-ids-padding.test (+1-5)
- (modified) llvm/test/tools/llvm-profdata/large-binary-id-size.test (+1-3)
- (modified) llvm/test/tools/llvm-profdata/malformed-not-space-for-another-header.test (+1-5)
- (modified) llvm/test/tools/llvm-profdata/malformed-num-counters-zero.test (+1-5)
- (modified) llvm/test/tools/llvm-profdata/malformed-ptr-to-counter-array.test (+1-5)
- (modified) llvm/test/tools/llvm-profdata/misaligned-binary-ids-size.test (+1-3)
- (modified) llvm/test/tools/llvm-profdata/mismatched-raw-profile-header.test (-2)
- (modified) llvm/test/tools/llvm-profdata/raw-32-bits-be.test (+5-6)
- (modified) llvm/test/tools/llvm-profdata/raw-32-bits-le.test (+5-5)
- (modified) llvm/test/tools/llvm-profdata/raw-64-bits-be.test (+5-5)
- (modified) llvm/test/tools/llvm-profdata/raw-64-bits-le.test (+5-5)
- (modified) llvm/test/tools/llvm-profdata/raw-two-profiles.test (+2-6)
``````````diff
diff --git a/compiler-rt/include/profile/InstrProfData.inc b/compiler-rt/include/profile/InstrProfData.inc
index 1f77853bb8baa9..c907a9736f3160 100644
--- a/compiler-rt/include/profile/InstrProfData.inc
+++ b/compiler-rt/include/profile/InstrProfData.inc
@@ -96,25 +96,6 @@ INSTR_PROF_DATA(const uint32_t, llvm::Type::getInt32Ty(Ctx), NumBitmapBytes, \
#undef INSTR_PROF_DATA
/* INSTR_PROF_DATA end. */
-/* For a virtual table object, record the name hash to associate profiled
- * addresses with global variables, and record {starting address, size in bytes}
- * to map the profiled virtual table (which usually have an offset from the
- * starting address) back to a virtual table object. */
-#ifndef INSTR_PROF_VTABLE_DATA
-#define INSTR_PROF_VTABLE_DATA(Type, LLVMType, Name, Initializer)
-#else
-#define INSTR_PROF_VTABLE_DATA_DEFINED
-#endif
-INSTR_PROF_VTABLE_DATA(const uint64_t, llvm::Type::getInt64Ty(Ctx), \
- VTableNameHash, ConstantInt::get(llvm::Type::getInt64Ty(Ctx), \
- IndexedInstrProf::ComputeHash(PGOVTableName)))
-INSTR_PROF_VTABLE_DATA(const IntPtrT, llvm::PointerType::getUnqual(Ctx), \
- VTablePointer, VTableAddr)
-INSTR_PROF_VTABLE_DATA(const uint32_t, llvm::Type::getInt32Ty(Ctx), VTableSize, \
- ConstantInt::get(llvm::Type::getInt32Ty(Ctx), \
- VTableSizeVal))
-#undef INSTR_PROF_VTABLE_DATA
-/* INSTR_PROF_VTABLE_DATA end. */
/* This is an internal data structure used by value profiler. It
* is defined here to allow serialization code sharing by LLVM
@@ -166,8 +147,6 @@ INSTR_PROF_RAW_HEADER(uint64_t, CountersDelta,
INSTR_PROF_RAW_HEADER(uint64_t, BitmapDelta,
(uintptr_t)BitmapBegin - (uintptr_t)DataBegin)
INSTR_PROF_RAW_HEADER(uint64_t, NamesDelta, (uintptr_t)NamesBegin)
-INSTR_PROF_RAW_HEADER(uint64_t, NumVTables, NumVTables)
-INSTR_PROF_RAW_HEADER(uint64_t, VNamesSize, VNamesSize)
INSTR_PROF_RAW_HEADER(uint64_t, ValueKindLast, IPVK_Last)
#undef INSTR_PROF_RAW_HEADER
/* INSTR_PROF_RAW_HEADER end */
@@ -209,26 +188,13 @@ VALUE_PROF_FUNC_PARAM(uint32_t, CounterIndex, Type::getInt32Ty(Ctx))
VALUE_PROF_KIND(IPVK_IndirectCallTarget, 0, "indirect call target")
/* For memory intrinsic functions size profiling. */
VALUE_PROF_KIND(IPVK_MemOPSize, 1, "memory intrinsic functions size")
-/* For virtual table address profiling, the address point of the virtual table
- * (i.e., the address contained in objects pointing to a virtual table) are
- * profiled. Note this may not be the address of the per C++ class virtual table
- * object (e.g., there might be an offset).
- *
- * The profiled addresses are stored in raw profile, together with the following
- * two types of information.
- * 1. The (starting and ending) addresses of per C++ class virtual table objects.
- * 2. The (compressed) virtual table object names.
- * RawInstrProfReader converts profiled virtual table addresses to virtual table
- * objects' MD5 hash.
- */
-VALUE_PROF_KIND(IPVK_VTableTarget, 2, "The profiled address point of the vtable")
/* These two kinds must be the last to be
* declared. This is to make sure the string
* array created with the template can be
* indexed with the kind value.
*/
VALUE_PROF_KIND(IPVK_First, IPVK_IndirectCallTarget, "first")
-VALUE_PROF_KIND(IPVK_Last, IPVK_VTableTarget, "last")
+VALUE_PROF_KIND(IPVK_Last, IPVK_MemOPSize, "last")
#undef VALUE_PROF_KIND
/* VALUE_PROF_KIND end */
@@ -318,18 +284,12 @@ INSTR_PROF_SECT_ENTRY(IPSK_bitmap, \
INSTR_PROF_SECT_ENTRY(IPSK_name, \
INSTR_PROF_QUOTE(INSTR_PROF_NAME_COMMON), \
INSTR_PROF_NAME_COFF, "__DATA,")
-INSTR_PROF_SECT_ENTRY(IPSK_vname, \
- INSTR_PROF_QUOTE(INSTR_PROF_VNAME_COMMON), \
- INSTR_PROF_VNAME_COFF, "__DATA,")
INSTR_PROF_SECT_ENTRY(IPSK_vals, \
INSTR_PROF_QUOTE(INSTR_PROF_VALS_COMMON), \
INSTR_PROF_VALS_COFF, "__DATA,")
INSTR_PROF_SECT_ENTRY(IPSK_vnodes, \
INSTR_PROF_QUOTE(INSTR_PROF_VNODES_COMMON), \
INSTR_PROF_VNODES_COFF, "__DATA,")
-INSTR_PROF_SECT_ENTRY(IPSK_vtab, \
- INSTR_PROF_QUOTE(INSTR_PROF_VTAB_COMMON), \
- INSTR_PROF_VTAB_COFF, "__DATA,")
INSTR_PROF_SECT_ENTRY(IPSK_covmap, \
INSTR_PROF_QUOTE(INSTR_PROF_COVMAP_COMMON), \
INSTR_PROF_COVMAP_COFF, "__LLVM_COV,")
@@ -708,9 +668,9 @@ 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 10
+#define INSTR_PROF_RAW_VERSION 9
/* Indexed profile format version (start from 1). */
-#define INSTR_PROF_INDEX_VERSION 12
+#define INSTR_PROF_INDEX_VERSION 11
/* Coverage mapping format version (start from 0). */
#define INSTR_PROF_COVMAP_VERSION 6
@@ -748,12 +708,10 @@ serializeValueProfDataFrom(ValueProfRecordClosure *Closure,
than WIN32 */
#define INSTR_PROF_DATA_COMMON __llvm_prf_data
#define INSTR_PROF_NAME_COMMON __llvm_prf_names
-#define INSTR_PROF_VNAME_COMMON __llvm_prf_vtabnames
#define INSTR_PROF_CNTS_COMMON __llvm_prf_cnts
#define INSTR_PROF_BITS_COMMON __llvm_prf_bits
#define INSTR_PROF_VALS_COMMON __llvm_prf_vals
#define INSTR_PROF_VNODES_COMMON __llvm_prf_vnds
-#define INSTR_PROF_VTAB_COMMON __llvm_prf_vtab
#define INSTR_PROF_COVMAP_COMMON __llvm_covmap
#define INSTR_PROF_COVFUN_COMMON __llvm_covfun
#define INSTR_PROF_COVDATA_COMMON __llvm_covdata
@@ -764,12 +722,10 @@ serializeValueProfDataFrom(ValueProfRecordClosure *Closure,
*/
#define INSTR_PROF_DATA_COFF ".lprfd$M"
#define INSTR_PROF_NAME_COFF ".lprfn$M"
-#define INSTR_PROF_VNAME_COFF ".lprfvn$M"
#define INSTR_PROF_CNTS_COFF ".lprfc$M"
#define INSTR_PROF_BITS_COFF ".lprfb$M"
#define INSTR_PROF_VALS_COFF ".lprfv$M"
#define INSTR_PROF_VNODES_COFF ".lprfnd$M"
-#define INSTR_PROF_VTAB_COFF ".lprfvt$M"
#define INSTR_PROF_COVMAP_COFF ".lcovmap$M"
#define INSTR_PROF_COVFUN_COFF ".lcovfun$M"
/* Since cov data and cov names sections are not allocated, we don't need to
diff --git a/compiler-rt/lib/profile/InstrProfiling.h b/compiler-rt/lib/profile/InstrProfiling.h
index be694a8d3330ba..01239083369187 100644
--- a/compiler-rt/lib/profile/InstrProfiling.h
+++ b/compiler-rt/lib/profile/InstrProfiling.h
@@ -49,12 +49,6 @@ typedef struct ValueProfNode {
#include "profile/InstrProfData.inc"
} ValueProfNode;
-typedef void *IntPtrT;
-typedef struct COMPILER_RT_ALIGNAS(INSTR_PROF_DATA_ALIGNMENT) VTableProfData {
-#define INSTR_PROF_VTABLE_DATA(Type, LLVMType, Name, Initializer) Type Name;
-#include "profile/InstrProfData.inc"
-} VTableProfData;
-
/*!
* \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
@@ -109,16 +103,12 @@ const __llvm_profile_data *__llvm_profile_begin_data(void);
const __llvm_profile_data *__llvm_profile_end_data(void);
const char *__llvm_profile_begin_names(void);
const char *__llvm_profile_end_names(void);
-const char *__llvm_profile_begin_vtabnames(void);
-const char *__llvm_profile_end_vtabnames(void);
char *__llvm_profile_begin_counters(void);
char *__llvm_profile_end_counters(void);
char *__llvm_profile_begin_bitmap(void);
char *__llvm_profile_end_bitmap(void);
ValueProfNode *__llvm_profile_begin_vnodes();
ValueProfNode *__llvm_profile_end_vnodes();
-VTableProfData *__llvm_profile_begin_vtables();
-VTableProfData *__llvm_profile_end_vtables();
uint32_t *__llvm_profile_begin_orderfile();
/*!
@@ -262,31 +252,20 @@ uint64_t __llvm_profile_get_num_bitmap_bytes(const char *Begin,
/*! \brief Get the size of the profile name section in bytes. */
uint64_t __llvm_profile_get_name_size(const char *Begin, const char *End);
-/*! \brief Get the number of virtual table profile data entries */
-uint64_t __llvm_profile_get_num_vtable(const VTableProfData *Begin,
- const VTableProfData *End);
-
-/*! \brief Get the size of virtual table profile data in bytes. */
-uint64_t __llvm_profile_get_vtable_section_size(const VTableProfData *Begin,
- const VTableProfData *End);
-
-/* ! \brief Given the sizes of the data and counter information, computes the
- * number of padding bytes before and after the counter section, as well as the
- * number of padding bytes after other setions in the raw profile.
- * Returns -1 upon errors and 0 upon success. Output parameters should be used
- * iff return value is 0.
+/* ! \brief Given the sizes of the data and counter information, return the
+ * number of padding bytes before and after the counters, and after the names,
+ * in the raw profile.
*
* Note: When mmap() mode is disabled, no padding bytes before/after counters
* are needed. However, in mmap() mode, the counter section in the raw profile
* must be page-aligned: this API computes the number of padding bytes
* needed to achieve that.
*/
-int __llvm_profile_get_padding_sizes_for_counters(
+void __llvm_profile_get_padding_sizes_for_counters(
uint64_t DataSize, uint64_t CountersSize, uint64_t NumBitmapBytes,
- uint64_t NamesSize, uint64_t VTableSize, uint64_t VNameSize,
- uint64_t *PaddingBytesBeforeCounters, uint64_t *PaddingBytesAfterCounters,
- uint64_t *PaddingBytesAfterBitmap, uint64_t *PaddingBytesAfterNames,
- uint64_t *PaddingBytesAfterVTable, uint64_t *PaddingBytesAfterVNames);
+ uint64_t NamesSize, uint64_t *PaddingBytesBeforeCounters,
+ uint64_t *PaddingBytesAfterCounters, uint64_t *PaddingBytesAfterBitmap,
+ uint64_t *PaddingBytesAfterNames);
/*!
* \brief Set the flag that profile data has been dumped to the file.
diff --git a/compiler-rt/lib/profile/InstrProfilingBuffer.c b/compiler-rt/lib/profile/InstrProfilingBuffer.c
index 7c5c26f4d113b1..af52804b2b532c 100644
--- a/compiler-rt/lib/profile/InstrProfilingBuffer.c
+++ b/compiler-rt/lib/profile/InstrProfilingBuffer.c
@@ -51,29 +51,16 @@ uint64_t __llvm_profile_get_size_for_buffer(void) {
const char *BitmapEnd = __llvm_profile_end_bitmap();
const char *NamesBegin = __llvm_profile_begin_names();
const char *NamesEnd = __llvm_profile_end_names();
- const VTableProfData *VTableBegin = __llvm_profile_begin_vtables();
- const VTableProfData *VTableEnd = __llvm_profile_end_vtables();
- const char *VNamesBegin = __llvm_profile_begin_vtabnames();
- const char *VNamesEnd = __llvm_profile_end_vtabnames();
return __llvm_profile_get_size_for_buffer_internal(
DataBegin, DataEnd, CountersBegin, CountersEnd, BitmapBegin, BitmapEnd,
- NamesBegin, NamesEnd, VTableBegin, VTableEnd, VNamesBegin, VNamesEnd);
+ NamesBegin, NamesEnd);
}
COMPILER_RT_VISIBILITY
uint64_t __llvm_profile_get_num_data(const __llvm_profile_data *Begin,
const __llvm_profile_data *End) {
intptr_t BeginI = (intptr_t)Begin, EndI = (intptr_t)End;
- // `sizeof(__llvm_profile_data) - 1` is required in the numerator when
- // [Begin, End] represents an inclusive range.
- // For ELF, [Begin, End) represents the address of linker-inserted
- // symbols `__start__<elf-section>` and `__stop_<elf-section>`.
- // Thereby, `End` is one byte past the inclusive range, and
- // `sizeof(__llvm_profile_data) - 1` is not necessary in the numerator to get
- // the correct number of profile data.
- // FIXME: Consider removing `sizeof(__llvm_profile_data) - 1` if this is true
- // across platforms.
return ((EndI + sizeof(__llvm_profile_data) - 1) - BeginI) /
sizeof(__llvm_profile_data);
}
@@ -84,26 +71,6 @@ uint64_t __llvm_profile_get_data_size(const __llvm_profile_data *Begin,
return __llvm_profile_get_num_data(Begin, End) * sizeof(__llvm_profile_data);
}
-// Counts the number of `VTableProfData` elements within the range of [Begin,
-// End). Caller should guarantee that End points to one byte past the inclusive
-// range.
-// FIXME: Add a compiler-rt test to make sure the number of vtables in the
-// raw profile is the same as the number of vtable elements in the instrumented
-// binary.
-COMPILER_RT_VISIBILITY
-uint64_t __llvm_profile_get_num_vtable(const VTableProfData *Begin,
- const VTableProfData *End) {
- // Convert pointers to intptr_t to use integer arithmetic.
- intptr_t EndI = (intptr_t)End, BeginI = (intptr_t)Begin;
- return (EndI - BeginI) / sizeof(VTableProfData);
-}
-
-COMPILER_RT_VISIBILITY
-uint64_t __llvm_profile_get_vtable_section_size(const VTableProfData *Begin,
- const VTableProfData *End) {
- return (intptr_t)(End) - (intptr_t)(Begin);
-}
-
COMPILER_RT_VISIBILITY size_t __llvm_profile_counter_entry_size(void) {
if (__llvm_profile_get_version() & VARIANT_MASK_BYTE_COVERAGE)
return sizeof(uint8_t);
@@ -152,13 +119,11 @@ static int needsCounterPadding(void) {
}
COMPILER_RT_VISIBILITY
-int __llvm_profile_get_padding_sizes_for_counters(
+void __llvm_profile_get_padding_sizes_for_counters(
uint64_t DataSize, uint64_t CountersSize, uint64_t NumBitmapBytes,
- uint64_t NamesSize, uint64_t VTableSize, uint64_t VNameSize,
- uint64_t *PaddingBytesBeforeCounters, uint64_t *PaddingBytesAfterCounters,
- uint64_t *PaddingBytesAfterBitmapBytes, uint64_t *PaddingBytesAfterNames,
- uint64_t *PaddingBytesAfterVTable, uint64_t *PaddingBytesAfterVName) {
- // Counter padding is needed only if continuous mode is enabled.
+ uint64_t NamesSize, uint64_t *PaddingBytesBeforeCounters,
+ uint64_t *PaddingBytesAfterCounters, uint64_t *PaddingBytesAfterBitmapBytes,
+ uint64_t *PaddingBytesAfterNames) {
if (!needsCounterPadding()) {
*PaddingBytesBeforeCounters = 0;
*PaddingBytesAfterCounters =
@@ -166,19 +131,9 @@ int __llvm_profile_get_padding_sizes_for_counters(
*PaddingBytesAfterBitmapBytes =
__llvm_profile_get_num_padding_bytes(NumBitmapBytes);
*PaddingBytesAfterNames = __llvm_profile_get_num_padding_bytes(NamesSize);
- if (PaddingBytesAfterVTable != NULL)
- *PaddingBytesAfterVTable =
- __llvm_profile_get_num_padding_bytes(VTableSize);
- if (PaddingBytesAfterVName != NULL)
- *PaddingBytesAfterVName = __llvm_profile_get_num_padding_bytes(VNameSize);
- return 0;
+ return;
}
- // Value profiling not supported in continuous mode at profile-write time.
- // Return -1 to alert the incompatibility.
- if (VTableSize != 0 || VNameSize != 0)
- return -1;
-
// In continuous mode, the file offsets for headers and for the start of
// counter sections need to be page-aligned.
*PaddingBytesBeforeCounters =
@@ -187,22 +142,13 @@ int __llvm_profile_get_padding_sizes_for_counters(
*PaddingBytesAfterBitmapBytes =
calculateBytesNeededToPageAlign(NumBitmapBytes);
*PaddingBytesAfterNames = calculateBytesNeededToPageAlign(NamesSize);
- // Set these two variables to zero to avoid uninitialized variables
- // even if VTableSize and VNameSize are known to be zero.
- if (PaddingBytesAfterVTable != NULL)
- *PaddingBytesAfterVTable = 0;
- if (PaddingBytesAfterVName != NULL)
- *PaddingBytesAfterVName = 0;
- return 0;
}
COMPILER_RT_VISIBILITY
uint64_t __llvm_profile_get_size_for_buffer_internal(
const __llvm_profile_data *DataBegin, const __llvm_profile_data *DataEnd,
const char *CountersBegin, const char *CountersEnd, const char *BitmapBegin,
- const char *BitmapEnd, const char *NamesBegin, const char *NamesEnd,
- const VTableProfData *VTableBegin, const VTableProfData *VTableEnd,
- const char *VNamesBegin, const char *VNamesEnd) {
+ const char *BitmapEnd, const char *NamesBegin, const char *NamesEnd) {
/* Match logic in __llvm_profile_write_buffer(). */
const uint64_t NamesSize = (NamesEnd - NamesBegin) * sizeof(char);
uint64_t DataSize = __llvm_profile_get_data_size(DataBegin, DataEnd);
@@ -210,29 +156,20 @@ uint64_t __llvm_profile_get_size_for_buffer_internal(
__llvm_profile_get_counters_size(CountersBegin, CountersEnd);
const uint64_t NumBitmapBytes =
__llvm_profile_get_num_bitmap_bytes(BitmapBegin, BitmapEnd);
- const uint64_t VTableSize =
- __llvm_profile_get_vtable_section_size(VTableBegin, VTableEnd);
- const uint64_t VNameSize =
- __llvm_profile_get_name_size(VNamesBegin, VNamesEnd);
/* Determine how much padding is needed before/after the counters and after
* the names. */
uint64_t PaddingBytesBeforeCounters, PaddingBytesAfterCounters,
- PaddingBytesAfterNames, PaddingBytesAfterBitmapBytes,
- PaddingBytesAfterVTable, PaddingBytesAfterVNames;
+ PaddingBytesAfterNames, PaddingBytesAfterBitmapBytes;
__llvm_profile_get_padding_sizes_for_counters(
- DataSize, CountersSize, NumBitmapBytes, NamesSize, 0 /* VTableSize */,
- 0 /* VNameSize */, &PaddingBytesBeforeCounters,
- &PaddingBytesAfterCounters, &PaddingBytesAfterBitmapBytes,
- &PaddingBytesAfterNames, &PaddingBytesAfterVTable,
- &PaddingBytesAfterVNames);
+ DataSize, CountersSize, NumBitmapBytes, NamesSize,
+ &PaddingBytesBeforeCounters, &PaddingBytesAfterCounters,
+ &PaddingBytesAfterBitmapBytes, &PaddingBytesAfterNames);
return sizeof(__llvm_profile_header) + __llvm_write_binary_ids(NULL) +
DataSize + PaddingBytesBeforeCounters + CountersSize +
PaddingBytesAfterCounters + NumBitmapBytes +
- PaddingBytesAfterBitmapBytes + NamesSize + PaddingBytesAfterNames +
- VTableSize + PaddingBytesAfterVTable + VNameSize +
- PaddingBytesAfterVNames;
+ PaddingBytesAfterBitmapBytes + NamesSize + PaddingBytesAfterNames;
}
COMPILER_RT_VISIBILITY
@@ -254,10 +191,7 @@ COMPILER_RT_VISIBILITY int __llvm_profile_write_buffer_internal(
const char *NamesBegin, const char *NamesEnd) {
ProfDataWriter BufferWriter;
initBufferWriter(&BufferWriter, Buffer);
- // Set virtual table arguments to NULL since they are not supported yet.
- return lprofWriteDataImpl(
- &BufferWriter, DataBegin, DataEnd, CountersBegin, CountersEnd,
- BitmapBegin, BitmapEnd, /*VPDataReader=*/0, NamesBegin, NamesEnd,
- /*VTableBegin=*/NULL, /*VTableEnd=*/NULL, /*VNamesBegin=*/NULL,
- /*VNamesEnd=*/NULL, /*SkipNameDataWrite=*/0);
+ return lprofWriteDataImpl(&BufferWriter, DataBegin, DataEnd, CountersBegin,
+ CountersEnd, BitmapBegin, BitmapEnd, 0, NamesBegin,
+ NamesEnd, 0);
}
diff --git a/compiler-rt/lib/profile/InstrProfilingInternal.h b/compiler-rt/lib/profile/InstrProfilingInternal.h
index d5bd0e41fb1291..03ed67fcfa766f 100644
--- a/compiler-rt/lib/profile/InstrProfilingInternal.h
+++ b/compiler-rt/lib/profile/InstrProfilingInternal.h
@@ -22,9 +22,7 @@
uint64_t __llvm_profile_get_size_for_buffer_internal(
const __llvm_profile_data *DataBegin, const __llvm_profile_data *DataEnd,
const char *CountersBegin, const char *CountersEnd, const char *BitmapBegin,
- const char *BitmapEnd, const char *NamesBegin, const char *NamesEnd,
- const VTableProfData *VTableBegin, const VTableProfData *VTableEnd,
- const char *VNamesBegin, const char *VNamesEnd);
+ const char *BitmapEnd, const char *NamesBegin, const char *NamesEnd);
/*!
* \brief Write instrumentation data to the given buffer, given explicit
@@ -158,9 +156,7 @@ int lprofWriteDataImpl(ProfDataWriter *Writer,
const char *CountersBegin, const char *CountersEnd,
const char *BitmapBegin, const char *BitmapEnd,
VPDataReaderType *VPDataReader, const char *NamesBegin,
- const char *NamesEnd, const VTableProfData *VTableBegin,
- const VTableProfData *VTableEnd, const char *VNamesBegin,
- const char *VNamesEnd, int SkipNameDataWrite);
+ const char *NamesEnd, int SkipNameDataWrite);
/* Merge value profile data pointed to by SrcValueProfData into
* in-memory profile counters pointed by to DstData. */
diff --git a/compiler-rt/lib/profile/InstrProfilingMerge.c b/compiler-rt/lib/profile/InstrProfilingMerge.c
index c0706b73e16687..b5850e99ee37d8 100644
--- a/compiler-rt/li...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/82583
More information about the llvm-commits
mailing list