1 //=-- InstrProfWriter.cpp - Instrumented profiling writer -------------------=// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file contains support for writing profiling data for clang's 11 // instrumentation based PGO and coverage. 12 // 13 //===----------------------------------------------------------------------===// 14 15 #include "llvm/ProfileData/InstrProfWriter.h" 16 #include "llvm/ADT/StringExtras.h" 17 #include "llvm/Support/EndianStream.h" 18 #include "llvm/Support/OnDiskHashTable.h" 19 20 #include "InstrProfIndexed.h" 21 22 using namespace llvm; 23 24 namespace { 25 class InstrProfRecordTrait { 26 public: 27 typedef StringRef key_type; 28 typedef StringRef key_type_ref; 29 30 typedef const InstrProfWriter::CounterData *const data_type; 31 typedef const InstrProfWriter::CounterData *const data_type_ref; 32 33 typedef uint64_t hash_value_type; 34 typedef uint64_t offset_type; 35 36 static hash_value_type ComputeHash(key_type_ref K) { 37 return IndexedInstrProf::ComputeHash(IndexedInstrProf::HashType, K); 38 } 39 40 static std::pair<offset_type, offset_type> 41 EmitKeyDataLength(raw_ostream &Out, key_type_ref K, data_type_ref V) { 42 using namespace llvm::support; 43 endian::Writer<little> LE(Out); 44 45 offset_type N = K.size(); 46 LE.write<offset_type>(N); 47 48 offset_type M = (1 + V->Counts.size()) * sizeof(uint64_t); 49 LE.write<offset_type>(M); 50 51 return std::make_pair(N, M); 52 } 53 54 static void EmitKey(raw_ostream &Out, key_type_ref K, offset_type N){ 55 Out.write(K.data(), N); 56 } 57 58 static void EmitData(raw_ostream &Out, key_type_ref, data_type_ref V, 59 offset_type) { 60 using namespace llvm::support; 61 endian::Writer<little> LE(Out); 62 LE.write<uint64_t>(V->Hash); 63 for (uint64_t I : V->Counts) 64 LE.write<uint64_t>(I); 65 } 66 }; 67 } 68 69 std::error_code 70 InstrProfWriter::addFunctionCounts(StringRef FunctionName, 71 uint64_t FunctionHash, 72 ArrayRef<uint64_t> Counters) { 73 auto Where = FunctionData.find(FunctionName); 74 if (Where == FunctionData.end()) { 75 // If this is the first time we've seen this function, just add it. 76 auto &Data = FunctionData[FunctionName]; 77 Data.Hash = FunctionHash; 78 Data.Counts = Counters; 79 return instrprof_error::success; 80 } 81 82 auto &Data = Where->getValue(); 83 // We can only add to existing functions if they match, so we check the hash 84 // and number of counters. 85 if (Data.Hash != FunctionHash) 86 return instrprof_error::hash_mismatch; 87 if (Data.Counts.size() != Counters.size()) 88 return instrprof_error::count_mismatch; 89 // These match, add up the counters. 90 for (size_t I = 0, E = Counters.size(); I < E; ++I) { 91 if (Data.Counts[I] + Counters[I] < Data.Counts[I]) 92 return instrprof_error::counter_overflow; 93 Data.Counts[I] += Counters[I]; 94 } 95 return instrprof_error::success; 96 } 97 98 void InstrProfWriter::write(raw_fd_ostream &OS) { 99 OnDiskChainedHashTableGenerator<InstrProfRecordTrait> Generator; 100 uint64_t MaxFunctionCount = 0; 101 102 // Populate the hash table generator. 103 for (const auto &I : FunctionData) { 104 Generator.insert(I.getKey(), &I.getValue()); 105 if (I.getValue().Counts[0] > MaxFunctionCount) 106 MaxFunctionCount = I.getValue().Counts[0]; 107 } 108 109 using namespace llvm::support; 110 endian::Writer<little> LE(OS); 111 112 // Write the header. 113 LE.write<uint64_t>(IndexedInstrProf::Magic); 114 LE.write<uint64_t>(IndexedInstrProf::Version); 115 LE.write<uint64_t>(MaxFunctionCount); 116 LE.write<uint64_t>(static_cast<uint64_t>(IndexedInstrProf::HashType)); 117 118 // Save a space to write the hash table start location. 119 uint64_t HashTableStartLoc = OS.tell(); 120 LE.write<uint64_t>(0); 121 // Write the hash table. 122 uint64_t HashTableStart = Generator.Emit(OS); 123 124 // Go back and fill in the hash table start. 125 OS.seek(HashTableStartLoc); 126 LE.write<uint64_t>(HashTableStart); 127 } 128