#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/StringSet.h"
#include "llvm/IR/GlobalValue.h"
+#include "llvm/ProfileData/InstrProfData.inc"
#include "llvm/Support/Endian.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/ErrorOr.h"
enum class instrprof_error {
success = 0,
eof,
+ unrecognized_format,
bad_magic,
bad_header,
unsupported_version,
}
enum InstrProfValueKind : uint32_t {
- IPVK_IndirectCallTarget = 0,
-
- IPVK_First = IPVK_IndirectCallTarget,
- IPVK_Last = IPVK_IndirectCallTarget
+#define VALUE_PROF_KIND(Enumerator, Value) Enumerator = Value,
+#include "llvm/ProfileData/InstrProfData.inc"
};
struct InstrProfStringTable {
while (I != IE && I->Value < J->Value)
++I;
if (I != IE && I->Value == J->Value) {
- I->Count += J->Count;
+ I->Count = SaturatingAdd(I->Count, J->Count);
++I;
continue;
}
inline void addValueData(uint32_t ValueKind, uint32_t Site,
InstrProfValueData *VData, uint32_t N,
ValueMapType *HashKeys);
- /// Merge Value Profile ddata from Src record to this record for ValueKind.
- inline instrprof_error mergeValueProfData(uint32_t ValueKind,
- InstrProfRecord &Src);
+
+ /// Merge the counts in \p Other into this one.
+ inline instrprof_error merge(InstrProfRecord &Other);
/// Used by InstrProfWriter: update the value strings to commoned strings in
/// the writer instance.
inline void updateStrings(InstrProfStringTable *StrTab);
+ /// Clear value data entries
+ inline void clearValueData() {
+ for (uint32_t Kind = IPVK_First; Kind <= IPVK_Last; ++Kind)
+ getValueSitesForKind(Kind).clear();
+ }
+
private:
std::vector<InstrProfValueSiteRecord> IndirectCallSites;
const std::vector<InstrProfValueSiteRecord> &
const_cast<const InstrProfRecord *>(this)
->getValueSitesForKind(ValueKind));
}
+
// Map indirect call target name hash to name string.
uint64_t remapValue(uint64_t Value, uint32_t ValueKind,
ValueMapType *HashKeys) {
std::lower_bound(HashKeys->begin(), HashKeys->end(), Value,
[](const std::pair<uint64_t, const char *> &LHS,
uint64_t RHS) { return LHS.first < RHS; });
- assert(Result != HashKeys->end() &&
- "Hash does not match any known keys\n");
- Value = (uint64_t)Result->second;
+ if (Result != HashKeys->end())
+ Value = (uint64_t)Result->second;
break;
}
}
return Value;
}
+
+ // Merge Value Profile data from Src record to this record for ValueKind.
+ instrprof_error mergeValueProfData(uint32_t ValueKind, InstrProfRecord &Src) {
+ uint32_t ThisNumValueSites = getNumValueSites(ValueKind);
+ uint32_t OtherNumValueSites = Src.getNumValueSites(ValueKind);
+ if (ThisNumValueSites != OtherNumValueSites)
+ return instrprof_error::value_site_count_mismatch;
+ std::vector<InstrProfValueSiteRecord> &ThisSiteRecords =
+ getValueSitesForKind(ValueKind);
+ std::vector<InstrProfValueSiteRecord> &OtherSiteRecords =
+ Src.getValueSitesForKind(ValueKind);
+ for (uint32_t I = 0; I < ThisNumValueSites; I++)
+ ThisSiteRecords[I].mergeValueData(OtherSiteRecords[I]);
+ return instrprof_error::success;
+ }
};
uint32_t InstrProfRecord::getNumValueKinds() const {
ValueSites.reserve(NumValueSites);
}
-instrprof_error InstrProfRecord::mergeValueProfData(uint32_t ValueKind,
- InstrProfRecord &Src) {
- uint32_t ThisNumValueSites = getNumValueSites(ValueKind);
- uint32_t OtherNumValueSites = Src.getNumValueSites(ValueKind);
- if (ThisNumValueSites != OtherNumValueSites)
- return instrprof_error::value_site_count_mismatch;
- std::vector<InstrProfValueSiteRecord> &ThisSiteRecords =
- getValueSitesForKind(ValueKind);
- std::vector<InstrProfValueSiteRecord> &OtherSiteRecords =
- Src.getValueSitesForKind(ValueKind);
- for (uint32_t I = 0; I < ThisNumValueSites; I++)
- ThisSiteRecords[I].mergeValueData(OtherSiteRecords[I]);
- return instrprof_error::success;
-}
-
void InstrProfRecord::updateStrings(InstrProfStringTable *StrTab) {
if (!StrTab)
return;
VData.Value = (uint64_t)StrTab->insertString((const char *)VData.Value);
}
-namespace IndexedInstrProf {
-enum class HashT : uint32_t {
- MD5,
-
- Last = MD5
-};
-
-static inline uint64_t MD5Hash(StringRef Str) {
- MD5 Hash;
- Hash.update(Str);
- llvm::MD5::MD5Result Result;
- Hash.final(Result);
- // Return the least significant 8 bytes. Our MD5 implementation returns the
- // result in little endian, so we may need to swap bytes.
- using namespace llvm::support;
- return endian::read<uint64_t, little, unaligned>(Result);
-}
+instrprof_error InstrProfRecord::merge(InstrProfRecord &Other) {
+ // If the number of counters doesn't match we either have bad data
+ // or a hash collision.
+ if (Counts.size() != Other.Counts.size())
+ return instrprof_error::count_mismatch;
-static inline uint64_t ComputeHash(HashT Type, StringRef K) {
- switch (Type) {
- case HashT::MD5:
- return IndexedInstrProf::MD5Hash(K);
+ for (size_t I = 0, E = Other.Counts.size(); I < E; ++I) {
+ if (Counts[I] + Other.Counts[I] < Counts[I])
+ return instrprof_error::counter_overflow;
+ Counts[I] += Other.Counts[I];
}
- llvm_unreachable("Unhandled hash type");
-}
-const uint64_t Magic = 0x8169666f72706cff; // "\xfflprofi\x81"
-const uint64_t Version = 3;
-const HashT HashType = HashT::MD5;
+ for (uint32_t Kind = IPVK_First; Kind <= IPVK_Last; ++Kind) {
+ instrprof_error result = mergeValueProfData(Kind, Other);
+ if (result != instrprof_error::success)
+ return result;
+ }
-// This structure defines the file header of the LLVM profile
-// data file in indexed-format.
-struct Header {
- uint64_t Magic;
- uint64_t Version;
- uint64_t MaxFunctionCount;
- uint64_t HashType;
- uint64_t HashOffset;
-};
+ return instrprof_error::success;
+}
inline support::endianness getHostEndianness() {
return sys::IsLittleEndianHost ? support::little : support::big;
// The number of value profile kinds that has value profile data.
// In this implementation, a value profile kind is considered to
// have profile data if the number of value profile sites for the
- // kind is not zero. More aggressively, the implemnetation can
+ // kind is not zero. More aggressively, the implementation can
// choose to check the actual data value: if none of the value sites
// has any profiled values, the kind can be skipped.
uint32_t NumValueKinds;
ValueProfRecord *getFirstValueProfRecord();
};
-} // end namespace IndexedInstrProf
+namespace IndexedInstrProf {
-namespace RawInstrProf {
+enum class HashT : uint32_t {
+ MD5,
-const uint64_t Version = 1;
+ Last = MD5
+};
-// Magic number to detect file format and endianness.
-// Use 255 at one end, since no UTF-8 file can use that character. Avoid 0,
-// so that utilities, like strings, don't grab it as a string. 129 is also
-// invalid UTF-8, and high enough to be interesting.
-// Use "lprofr" in the centre to stand for "LLVM Profile Raw", or "lprofR"
-// for 32-bit platforms.
-// The magic and version need to be kept in sync with
-// projects/compiler-rt/lib/profile/InstrProfiling.c
+static inline uint64_t MD5Hash(StringRef Str) {
+ MD5 Hash;
+ Hash.update(Str);
+ llvm::MD5::MD5Result Result;
+ Hash.final(Result);
+ // Return the least significant 8 bytes. Our MD5 implementation returns the
+ // result in little endian, so we may need to swap bytes.
+ using namespace llvm::support;
+ return endian::read<uint64_t, little, unaligned>(Result);
+}
-template <class IntPtrT>
-inline uint64_t getMagic();
-template <>
-inline uint64_t getMagic<uint64_t>() {
- return uint64_t(255) << 56 | uint64_t('l') << 48 | uint64_t('p') << 40 |
- uint64_t('r') << 32 | uint64_t('o') << 24 | uint64_t('f') << 16 |
- uint64_t('r') << 8 | uint64_t(129);
+static inline uint64_t ComputeHash(HashT Type, StringRef K) {
+ switch (Type) {
+ case HashT::MD5:
+ return IndexedInstrProf::MD5Hash(K);
+ }
+ llvm_unreachable("Unhandled hash type");
}
-template <>
-inline uint64_t getMagic<uint32_t>() {
- return uint64_t(255) << 56 | uint64_t('l') << 48 | uint64_t('p') << 40 |
- uint64_t('r') << 32 | uint64_t('o') << 24 | uint64_t('f') << 16 |
- uint64_t('R') << 8 | uint64_t(129);
+const uint64_t Magic = 0x8169666f72706cff; // "\xfflprofi\x81"
+const uint64_t Version = 3;
+const HashT HashType = HashT::MD5;
+
+// This structure defines the file header of the LLVM profile
+// data file in indexed-format.
+struct Header {
+ uint64_t Magic;
+ uint64_t Version;
+ uint64_t MaxFunctionCount;
+ uint64_t HashType;
+ uint64_t HashOffset;
+};
+
+} // end namespace IndexedInstrProf
+
+namespace RawInstrProf {
+
+const uint64_t Version = INSTR_PROF_RAW_VERSION;
+
+template <class IntPtrT> inline uint64_t getMagic();
+template <> inline uint64_t getMagic<uint64_t>() {
+ return INSTR_PROF_RAW_MAGIC_64;
+}
+
+template <> inline uint64_t getMagic<uint32_t>() {
+ return INSTR_PROF_RAW_MAGIC_32;
}
// Per-function profile data header/control structure.
// compiler-rt/lib/profile/InstrProfiling.h.
// It should also match the synthesized type in
// Transforms/Instrumentation/InstrProfiling.cpp:getOrCreateRegionCounters.
-template <class IntPtrT> struct ProfileData {
+template <class IntPtrT> struct LLVM_ALIGNAS(8) ProfileData {
#define INSTR_PROF_DATA(Type, LLVMType, Name, Init) Type Name;
#include "llvm/ProfileData/InstrProfData.inc"
};
// compiler-rt/lib/profile/InstrProfilingFile.c and
// InstrProfilingBuffer.c.
struct Header {
- const uint64_t Magic;
- const uint64_t Version;
- const uint64_t DataSize;
- const uint64_t CountersSize;
- const uint64_t NamesSize;
- const uint64_t CountersDelta;
- const uint64_t NamesDelta;
+#define INSTR_PROF_RAW_HEADER(Type, Name, Init) Type Name;
+#include "llvm/ProfileData/InstrProfData.inc"
};
} // end namespace RawInstrProf
projects / oota-llvm.git / blobdiff