CoverageMapping.cpp revision 314564
1303231Sdim//=-- CoverageMapping.cpp - Code coverage mapping support ---------*- C++ -*-=// 2303231Sdim// 3303231Sdim// The LLVM Compiler Infrastructure 4303231Sdim// 5303231Sdim// This file is distributed under the University of Illinois Open Source 6303231Sdim// License. See LICENSE.TXT for details. 7303231Sdim// 8303231Sdim//===----------------------------------------------------------------------===// 9303231Sdim// 10303231Sdim// This file contains support for clang's and llvm's instrumentation based 11303231Sdim// code coverage. 12303231Sdim// 13303231Sdim//===----------------------------------------------------------------------===// 14303231Sdim 15303231Sdim#include "llvm/ProfileData/Coverage/CoverageMapping.h" 16303231Sdim#include "llvm/ADT/DenseMap.h" 17303231Sdim#include "llvm/ADT/Optional.h" 18303231Sdim#include "llvm/ADT/SmallBitVector.h" 19303231Sdim#include "llvm/ProfileData/Coverage/CoverageMappingReader.h" 20303231Sdim#include "llvm/ProfileData/InstrProfReader.h" 21303231Sdim#include "llvm/Support/Debug.h" 22303231Sdim#include "llvm/Support/Errc.h" 23303231Sdim#include "llvm/Support/ErrorHandling.h" 24303231Sdim#include "llvm/Support/ManagedStatic.h" 25303231Sdim#include "llvm/Support/Path.h" 26303231Sdim#include "llvm/Support/raw_ostream.h" 27303231Sdim 28303231Sdimusing namespace llvm; 29303231Sdimusing namespace coverage; 30303231Sdim 31303231Sdim#define DEBUG_TYPE "coverage-mapping" 32303231Sdim 33303231SdimCounter CounterExpressionBuilder::get(const CounterExpression &E) { 34303231Sdim auto It = ExpressionIndices.find(E); 35303231Sdim if (It != ExpressionIndices.end()) 36303231Sdim return Counter::getExpression(It->second); 37303231Sdim unsigned I = Expressions.size(); 38303231Sdim Expressions.push_back(E); 39303231Sdim ExpressionIndices[E] = I; 40303231Sdim return Counter::getExpression(I); 41303231Sdim} 42303231Sdim 43303231Sdimvoid CounterExpressionBuilder::extractTerms( 44303231Sdim Counter C, int Sign, SmallVectorImpl<std::pair<unsigned, int>> &Terms) { 45303231Sdim switch (C.getKind()) { 46303231Sdim case Counter::Zero: 47303231Sdim break; 48303231Sdim case Counter::CounterValueReference: 49303231Sdim Terms.push_back(std::make_pair(C.getCounterID(), Sign)); 50303231Sdim break; 51303231Sdim case Counter::Expression: 52303231Sdim const auto &E = Expressions[C.getExpressionID()]; 53303231Sdim extractTerms(E.LHS, Sign, Terms); 54303231Sdim extractTerms(E.RHS, E.Kind == CounterExpression::Subtract ? -Sign : Sign, 55303231Sdim Terms); 56303231Sdim break; 57303231Sdim } 58303231Sdim} 59303231Sdim 60303231SdimCounter CounterExpressionBuilder::simplify(Counter ExpressionTree) { 61303231Sdim // Gather constant terms. 62303231Sdim llvm::SmallVector<std::pair<unsigned, int>, 32> Terms; 63303231Sdim extractTerms(ExpressionTree, +1, Terms); 64303231Sdim 65303231Sdim // If there are no terms, this is just a zero. The algorithm below assumes at 66303231Sdim // least one term. 67303231Sdim if (Terms.size() == 0) 68303231Sdim return Counter::getZero(); 69303231Sdim 70303231Sdim // Group the terms by counter ID. 71303231Sdim std::sort(Terms.begin(), Terms.end(), 72303231Sdim [](const std::pair<unsigned, int> &LHS, 73303231Sdim const std::pair<unsigned, int> &RHS) { 74303231Sdim return LHS.first < RHS.first; 75303231Sdim }); 76303231Sdim 77303231Sdim // Combine terms by counter ID to eliminate counters that sum to zero. 78303231Sdim auto Prev = Terms.begin(); 79303231Sdim for (auto I = Prev + 1, E = Terms.end(); I != E; ++I) { 80303231Sdim if (I->first == Prev->first) { 81303231Sdim Prev->second += I->second; 82303231Sdim continue; 83303231Sdim } 84303231Sdim ++Prev; 85303231Sdim *Prev = *I; 86303231Sdim } 87303231Sdim Terms.erase(++Prev, Terms.end()); 88303231Sdim 89303231Sdim Counter C; 90303231Sdim // Create additions. We do this before subtractions to avoid constructs like 91303231Sdim // ((0 - X) + Y), as opposed to (Y - X). 92303231Sdim for (auto Term : Terms) { 93303231Sdim if (Term.second <= 0) 94303231Sdim continue; 95303231Sdim for (int I = 0; I < Term.second; ++I) 96303231Sdim if (C.isZero()) 97303231Sdim C = Counter::getCounter(Term.first); 98303231Sdim else 99303231Sdim C = get(CounterExpression(CounterExpression::Add, C, 100303231Sdim Counter::getCounter(Term.first))); 101303231Sdim } 102303231Sdim 103303231Sdim // Create subtractions. 104303231Sdim for (auto Term : Terms) { 105303231Sdim if (Term.second >= 0) 106303231Sdim continue; 107303231Sdim for (int I = 0; I < -Term.second; ++I) 108303231Sdim C = get(CounterExpression(CounterExpression::Subtract, C, 109303231Sdim Counter::getCounter(Term.first))); 110303231Sdim } 111303231Sdim return C; 112303231Sdim} 113303231Sdim 114303231SdimCounter CounterExpressionBuilder::add(Counter LHS, Counter RHS) { 115303231Sdim return simplify(get(CounterExpression(CounterExpression::Add, LHS, RHS))); 116303231Sdim} 117303231Sdim 118303231SdimCounter CounterExpressionBuilder::subtract(Counter LHS, Counter RHS) { 119303231Sdim return simplify( 120303231Sdim get(CounterExpression(CounterExpression::Subtract, LHS, RHS))); 121303231Sdim} 122303231Sdim 123303231Sdimvoid CounterMappingContext::dump(const Counter &C, 124303231Sdim llvm::raw_ostream &OS) const { 125303231Sdim switch (C.getKind()) { 126303231Sdim case Counter::Zero: 127303231Sdim OS << '0'; 128303231Sdim return; 129303231Sdim case Counter::CounterValueReference: 130303231Sdim OS << '#' << C.getCounterID(); 131303231Sdim break; 132303231Sdim case Counter::Expression: { 133303231Sdim if (C.getExpressionID() >= Expressions.size()) 134303231Sdim return; 135303231Sdim const auto &E = Expressions[C.getExpressionID()]; 136303231Sdim OS << '('; 137303231Sdim dump(E.LHS, OS); 138303231Sdim OS << (E.Kind == CounterExpression::Subtract ? " - " : " + "); 139303231Sdim dump(E.RHS, OS); 140303231Sdim OS << ')'; 141303231Sdim break; 142303231Sdim } 143303231Sdim } 144303231Sdim if (CounterValues.empty()) 145303231Sdim return; 146303231Sdim Expected<int64_t> Value = evaluate(C); 147303231Sdim if (auto E = Value.takeError()) { 148303231Sdim llvm::consumeError(std::move(E)); 149303231Sdim return; 150303231Sdim } 151303231Sdim OS << '[' << *Value << ']'; 152303231Sdim} 153303231Sdim 154303231SdimExpected<int64_t> CounterMappingContext::evaluate(const Counter &C) const { 155303231Sdim switch (C.getKind()) { 156303231Sdim case Counter::Zero: 157303231Sdim return 0; 158303231Sdim case Counter::CounterValueReference: 159303231Sdim if (C.getCounterID() >= CounterValues.size()) 160303231Sdim return errorCodeToError(errc::argument_out_of_domain); 161303231Sdim return CounterValues[C.getCounterID()]; 162303231Sdim case Counter::Expression: { 163303231Sdim if (C.getExpressionID() >= Expressions.size()) 164303231Sdim return errorCodeToError(errc::argument_out_of_domain); 165303231Sdim const auto &E = Expressions[C.getExpressionID()]; 166303231Sdim Expected<int64_t> LHS = evaluate(E.LHS); 167303231Sdim if (!LHS) 168303231Sdim return LHS; 169303231Sdim Expected<int64_t> RHS = evaluate(E.RHS); 170303231Sdim if (!RHS) 171303231Sdim return RHS; 172303231Sdim return E.Kind == CounterExpression::Subtract ? *LHS - *RHS : *LHS + *RHS; 173303231Sdim } 174303231Sdim } 175303231Sdim llvm_unreachable("Unhandled CounterKind"); 176303231Sdim} 177303231Sdim 178303231Sdimvoid FunctionRecordIterator::skipOtherFiles() { 179303231Sdim while (Current != Records.end() && !Filename.empty() && 180303231Sdim Filename != Current->Filenames[0]) 181303231Sdim ++Current; 182303231Sdim if (Current == Records.end()) 183303231Sdim *this = FunctionRecordIterator(); 184303231Sdim} 185303231Sdim 186314564SdimError CoverageMapping::loadFunctionRecord( 187314564Sdim const CoverageMappingRecord &Record, 188314564Sdim IndexedInstrProfReader &ProfileReader) { 189314564Sdim StringRef OrigFuncName = Record.FunctionName; 190314564Sdim if (Record.Filenames.empty()) 191314564Sdim OrigFuncName = getFuncNameWithoutPrefix(OrigFuncName); 192314564Sdim else 193314564Sdim OrigFuncName = getFuncNameWithoutPrefix(OrigFuncName, Record.Filenames[0]); 194314564Sdim 195314564Sdim // Don't load records for functions we've already seen. 196314564Sdim if (!FunctionNames.insert(OrigFuncName).second) 197314564Sdim return Error::success(); 198314564Sdim 199314564Sdim CounterMappingContext Ctx(Record.Expressions); 200314564Sdim 201314564Sdim std::vector<uint64_t> Counts; 202314564Sdim if (Error E = ProfileReader.getFunctionCounts(Record.FunctionName, 203314564Sdim Record.FunctionHash, Counts)) { 204314564Sdim instrprof_error IPE = InstrProfError::take(std::move(E)); 205314564Sdim if (IPE == instrprof_error::hash_mismatch) { 206314564Sdim MismatchedFunctionCount++; 207314564Sdim return Error::success(); 208314564Sdim } else if (IPE != instrprof_error::unknown_function) 209314564Sdim return make_error<InstrProfError>(IPE); 210314564Sdim Counts.assign(Record.MappingRegions.size(), 0); 211314564Sdim } 212314564Sdim Ctx.setCounts(Counts); 213314564Sdim 214314564Sdim assert(!Record.MappingRegions.empty() && "Function has no regions"); 215314564Sdim 216314564Sdim FunctionRecord Function(OrigFuncName, Record.Filenames); 217314564Sdim for (const auto &Region : Record.MappingRegions) { 218314564Sdim Expected<int64_t> ExecutionCount = Ctx.evaluate(Region.Count); 219314564Sdim if (auto E = ExecutionCount.takeError()) { 220314564Sdim llvm::consumeError(std::move(E)); 221314564Sdim return Error::success(); 222314564Sdim } 223314564Sdim Function.pushRegion(Region, *ExecutionCount); 224314564Sdim } 225314564Sdim if (Function.CountedRegions.size() != Record.MappingRegions.size()) { 226314564Sdim MismatchedFunctionCount++; 227314564Sdim return Error::success(); 228314564Sdim } 229314564Sdim 230314564Sdim Functions.push_back(std::move(Function)); 231314564Sdim return Error::success(); 232314564Sdim} 233314564Sdim 234303231SdimExpected<std::unique_ptr<CoverageMapping>> 235303231SdimCoverageMapping::load(CoverageMappingReader &CoverageReader, 236303231Sdim IndexedInstrProfReader &ProfileReader) { 237303231Sdim auto Coverage = std::unique_ptr<CoverageMapping>(new CoverageMapping()); 238303231Sdim 239314564Sdim for (const auto &Record : CoverageReader) 240314564Sdim if (Error E = Coverage->loadFunctionRecord(Record, ProfileReader)) 241314564Sdim return std::move(E); 242303231Sdim 243314564Sdim return std::move(Coverage); 244314564Sdim} 245303231Sdim 246314564SdimExpected<std::unique_ptr<CoverageMapping>> CoverageMapping::load( 247314564Sdim ArrayRef<std::unique_ptr<CoverageMappingReader>> CoverageReaders, 248314564Sdim IndexedInstrProfReader &ProfileReader) { 249314564Sdim auto Coverage = std::unique_ptr<CoverageMapping>(new CoverageMapping()); 250303231Sdim 251314564Sdim for (const auto &CoverageReader : CoverageReaders) 252314564Sdim for (const auto &Record : *CoverageReader) 253314564Sdim if (Error E = Coverage->loadFunctionRecord(Record, ProfileReader)) 254314564Sdim return std::move(E); 255303231Sdim 256303231Sdim return std::move(Coverage); 257303231Sdim} 258303231Sdim 259303231SdimExpected<std::unique_ptr<CoverageMapping>> 260314564SdimCoverageMapping::load(ArrayRef<StringRef> ObjectFilenames, 261314564Sdim StringRef ProfileFilename, StringRef Arch) { 262303231Sdim auto ProfileReaderOrErr = IndexedInstrProfReader::create(ProfileFilename); 263303231Sdim if (Error E = ProfileReaderOrErr.takeError()) 264303231Sdim return std::move(E); 265303231Sdim auto ProfileReader = std::move(ProfileReaderOrErr.get()); 266314564Sdim 267314564Sdim SmallVector<std::unique_ptr<CoverageMappingReader>, 4> Readers; 268314564Sdim SmallVector<std::unique_ptr<MemoryBuffer>, 4> Buffers; 269314564Sdim for (StringRef ObjectFilename : ObjectFilenames) { 270314564Sdim auto CovMappingBufOrErr = MemoryBuffer::getFileOrSTDIN(ObjectFilename); 271314564Sdim if (std::error_code EC = CovMappingBufOrErr.getError()) 272314564Sdim return errorCodeToError(EC); 273314564Sdim auto CoverageReaderOrErr = 274314564Sdim BinaryCoverageReader::create(CovMappingBufOrErr.get(), Arch); 275314564Sdim if (Error E = CoverageReaderOrErr.takeError()) 276314564Sdim return std::move(E); 277314564Sdim Readers.push_back(std::move(CoverageReaderOrErr.get())); 278314564Sdim Buffers.push_back(std::move(CovMappingBufOrErr.get())); 279314564Sdim } 280314564Sdim return load(Readers, *ProfileReader); 281303231Sdim} 282303231Sdim 283303231Sdimnamespace { 284303231Sdim/// \brief Distributes functions into instantiation sets. 285303231Sdim/// 286303231Sdim/// An instantiation set is a collection of functions that have the same source 287303231Sdim/// code, ie, template functions specializations. 288303231Sdimclass FunctionInstantiationSetCollector { 289303231Sdim typedef DenseMap<std::pair<unsigned, unsigned>, 290303231Sdim std::vector<const FunctionRecord *>> MapT; 291303231Sdim MapT InstantiatedFunctions; 292303231Sdim 293303231Sdimpublic: 294303231Sdim void insert(const FunctionRecord &Function, unsigned FileID) { 295303231Sdim auto I = Function.CountedRegions.begin(), E = Function.CountedRegions.end(); 296303231Sdim while (I != E && I->FileID != FileID) 297303231Sdim ++I; 298303231Sdim assert(I != E && "function does not cover the given file"); 299303231Sdim auto &Functions = InstantiatedFunctions[I->startLoc()]; 300303231Sdim Functions.push_back(&Function); 301303231Sdim } 302303231Sdim 303303231Sdim MapT::iterator begin() { return InstantiatedFunctions.begin(); } 304303231Sdim 305303231Sdim MapT::iterator end() { return InstantiatedFunctions.end(); } 306303231Sdim}; 307303231Sdim 308303231Sdimclass SegmentBuilder { 309303231Sdim std::vector<CoverageSegment> &Segments; 310303231Sdim SmallVector<const CountedRegion *, 8> ActiveRegions; 311303231Sdim 312303231Sdim SegmentBuilder(std::vector<CoverageSegment> &Segments) : Segments(Segments) {} 313303231Sdim 314303231Sdim /// Start a segment with no count specified. 315303231Sdim void startSegment(unsigned Line, unsigned Col) { 316303231Sdim DEBUG(dbgs() << "Top level segment at " << Line << ":" << Col << "\n"); 317303231Sdim Segments.emplace_back(Line, Col, /*IsRegionEntry=*/false); 318303231Sdim } 319303231Sdim 320303231Sdim /// Start a segment with the given Region's count. 321303231Sdim void startSegment(unsigned Line, unsigned Col, bool IsRegionEntry, 322303231Sdim const CountedRegion &Region) { 323303231Sdim // Avoid creating empty regions. 324303231Sdim if (!Segments.empty() && Segments.back().Line == Line && 325303231Sdim Segments.back().Col == Col) 326303231Sdim Segments.pop_back(); 327303231Sdim DEBUG(dbgs() << "Segment at " << Line << ":" << Col); 328303231Sdim // Set this region's count. 329303231Sdim if (Region.Kind != coverage::CounterMappingRegion::SkippedRegion) { 330303231Sdim DEBUG(dbgs() << " with count " << Region.ExecutionCount); 331303231Sdim Segments.emplace_back(Line, Col, Region.ExecutionCount, IsRegionEntry); 332303231Sdim } else 333303231Sdim Segments.emplace_back(Line, Col, IsRegionEntry); 334303231Sdim DEBUG(dbgs() << "\n"); 335303231Sdim } 336303231Sdim 337303231Sdim /// Start a segment for the given region. 338303231Sdim void startSegment(const CountedRegion &Region) { 339303231Sdim startSegment(Region.LineStart, Region.ColumnStart, true, Region); 340303231Sdim } 341303231Sdim 342303231Sdim /// Pop the top region off of the active stack, starting a new segment with 343303231Sdim /// the containing Region's count. 344303231Sdim void popRegion() { 345303231Sdim const CountedRegion *Active = ActiveRegions.back(); 346303231Sdim unsigned Line = Active->LineEnd, Col = Active->ColumnEnd; 347303231Sdim ActiveRegions.pop_back(); 348303231Sdim if (ActiveRegions.empty()) 349303231Sdim startSegment(Line, Col); 350303231Sdim else 351303231Sdim startSegment(Line, Col, false, *ActiveRegions.back()); 352303231Sdim } 353303231Sdim 354303231Sdim void buildSegmentsImpl(ArrayRef<CountedRegion> Regions) { 355303231Sdim for (const auto &Region : Regions) { 356303231Sdim // Pop any regions that end before this one starts. 357303231Sdim while (!ActiveRegions.empty() && 358303231Sdim ActiveRegions.back()->endLoc() <= Region.startLoc()) 359303231Sdim popRegion(); 360303231Sdim // Add this region to the stack. 361303231Sdim ActiveRegions.push_back(&Region); 362303231Sdim startSegment(Region); 363303231Sdim } 364303231Sdim // Pop any regions that are left in the stack. 365303231Sdim while (!ActiveRegions.empty()) 366303231Sdim popRegion(); 367303231Sdim } 368303231Sdim 369303231Sdim /// Sort a nested sequence of regions from a single file. 370303231Sdim static void sortNestedRegions(MutableArrayRef<CountedRegion> Regions) { 371303231Sdim std::sort(Regions.begin(), Regions.end(), [](const CountedRegion &LHS, 372303231Sdim const CountedRegion &RHS) { 373303231Sdim if (LHS.startLoc() != RHS.startLoc()) 374303231Sdim return LHS.startLoc() < RHS.startLoc(); 375303231Sdim if (LHS.endLoc() != RHS.endLoc()) 376303231Sdim // When LHS completely contains RHS, we sort LHS first. 377303231Sdim return RHS.endLoc() < LHS.endLoc(); 378303231Sdim // If LHS and RHS cover the same area, we need to sort them according 379303231Sdim // to their kinds so that the most suitable region will become "active" 380303231Sdim // in combineRegions(). Because we accumulate counter values only from 381303231Sdim // regions of the same kind as the first region of the area, prefer 382303231Sdim // CodeRegion to ExpansionRegion and ExpansionRegion to SkippedRegion. 383303231Sdim static_assert(coverage::CounterMappingRegion::CodeRegion < 384303231Sdim coverage::CounterMappingRegion::ExpansionRegion && 385303231Sdim coverage::CounterMappingRegion::ExpansionRegion < 386303231Sdim coverage::CounterMappingRegion::SkippedRegion, 387303231Sdim "Unexpected order of region kind values"); 388303231Sdim return LHS.Kind < RHS.Kind; 389303231Sdim }); 390303231Sdim } 391303231Sdim 392303231Sdim /// Combine counts of regions which cover the same area. 393303231Sdim static ArrayRef<CountedRegion> 394303231Sdim combineRegions(MutableArrayRef<CountedRegion> Regions) { 395303231Sdim if (Regions.empty()) 396303231Sdim return Regions; 397303231Sdim auto Active = Regions.begin(); 398303231Sdim auto End = Regions.end(); 399303231Sdim for (auto I = Regions.begin() + 1; I != End; ++I) { 400303231Sdim if (Active->startLoc() != I->startLoc() || 401303231Sdim Active->endLoc() != I->endLoc()) { 402303231Sdim // Shift to the next region. 403303231Sdim ++Active; 404303231Sdim if (Active != I) 405303231Sdim *Active = *I; 406303231Sdim continue; 407303231Sdim } 408303231Sdim // Merge duplicate region. 409303231Sdim // If CodeRegions and ExpansionRegions cover the same area, it's probably 410303231Sdim // a macro which is fully expanded to another macro. In that case, we need 411303231Sdim // to accumulate counts only from CodeRegions, or else the area will be 412303231Sdim // counted twice. 413303231Sdim // On the other hand, a macro may have a nested macro in its body. If the 414303231Sdim // outer macro is used several times, the ExpansionRegion for the nested 415303231Sdim // macro will also be added several times. These ExpansionRegions cover 416303231Sdim // the same source locations and have to be combined to reach the correct 417303231Sdim // value for that area. 418303231Sdim // We add counts of the regions of the same kind as the active region 419303231Sdim // to handle the both situations. 420303231Sdim if (I->Kind == Active->Kind) 421303231Sdim Active->ExecutionCount += I->ExecutionCount; 422303231Sdim } 423303231Sdim return Regions.drop_back(std::distance(++Active, End)); 424303231Sdim } 425303231Sdim 426303231Sdimpublic: 427303231Sdim /// Build a list of CoverageSegments from a list of Regions. 428303231Sdim static std::vector<CoverageSegment> 429303231Sdim buildSegments(MutableArrayRef<CountedRegion> Regions) { 430303231Sdim std::vector<CoverageSegment> Segments; 431303231Sdim SegmentBuilder Builder(Segments); 432303231Sdim 433303231Sdim sortNestedRegions(Regions); 434303231Sdim ArrayRef<CountedRegion> CombinedRegions = combineRegions(Regions); 435303231Sdim 436303231Sdim Builder.buildSegmentsImpl(CombinedRegions); 437303231Sdim return Segments; 438303231Sdim } 439303231Sdim}; 440303231Sdim} 441303231Sdim 442303231Sdimstd::vector<StringRef> CoverageMapping::getUniqueSourceFiles() const { 443303231Sdim std::vector<StringRef> Filenames; 444303231Sdim for (const auto &Function : getCoveredFunctions()) 445303231Sdim Filenames.insert(Filenames.end(), Function.Filenames.begin(), 446303231Sdim Function.Filenames.end()); 447303231Sdim std::sort(Filenames.begin(), Filenames.end()); 448303231Sdim auto Last = std::unique(Filenames.begin(), Filenames.end()); 449303231Sdim Filenames.erase(Last, Filenames.end()); 450303231Sdim return Filenames; 451303231Sdim} 452303231Sdim 453303231Sdimstatic SmallBitVector gatherFileIDs(StringRef SourceFile, 454303231Sdim const FunctionRecord &Function) { 455303231Sdim SmallBitVector FilenameEquivalence(Function.Filenames.size(), false); 456303231Sdim for (unsigned I = 0, E = Function.Filenames.size(); I < E; ++I) 457303231Sdim if (SourceFile == Function.Filenames[I]) 458303231Sdim FilenameEquivalence[I] = true; 459303231Sdim return FilenameEquivalence; 460303231Sdim} 461303231Sdim 462303231Sdim/// Return the ID of the file where the definition of the function is located. 463303231Sdimstatic Optional<unsigned> findMainViewFileID(const FunctionRecord &Function) { 464303231Sdim SmallBitVector IsNotExpandedFile(Function.Filenames.size(), true); 465303231Sdim for (const auto &CR : Function.CountedRegions) 466303231Sdim if (CR.Kind == CounterMappingRegion::ExpansionRegion) 467303231Sdim IsNotExpandedFile[CR.ExpandedFileID] = false; 468303231Sdim int I = IsNotExpandedFile.find_first(); 469303231Sdim if (I == -1) 470303231Sdim return None; 471303231Sdim return I; 472303231Sdim} 473303231Sdim 474303231Sdim/// Check if SourceFile is the file that contains the definition of 475303231Sdim/// the Function. Return the ID of the file in that case or None otherwise. 476303231Sdimstatic Optional<unsigned> findMainViewFileID(StringRef SourceFile, 477303231Sdim const FunctionRecord &Function) { 478303231Sdim Optional<unsigned> I = findMainViewFileID(Function); 479303231Sdim if (I && SourceFile == Function.Filenames[*I]) 480303231Sdim return I; 481303231Sdim return None; 482303231Sdim} 483303231Sdim 484303231Sdimstatic bool isExpansion(const CountedRegion &R, unsigned FileID) { 485303231Sdim return R.Kind == CounterMappingRegion::ExpansionRegion && R.FileID == FileID; 486303231Sdim} 487303231Sdim 488303231SdimCoverageData CoverageMapping::getCoverageForFile(StringRef Filename) const { 489303231Sdim CoverageData FileCoverage(Filename); 490303231Sdim std::vector<coverage::CountedRegion> Regions; 491303231Sdim 492303231Sdim for (const auto &Function : Functions) { 493303231Sdim auto MainFileID = findMainViewFileID(Filename, Function); 494303231Sdim auto FileIDs = gatherFileIDs(Filename, Function); 495303231Sdim for (const auto &CR : Function.CountedRegions) 496303231Sdim if (FileIDs.test(CR.FileID)) { 497303231Sdim Regions.push_back(CR); 498303231Sdim if (MainFileID && isExpansion(CR, *MainFileID)) 499303231Sdim FileCoverage.Expansions.emplace_back(CR, Function); 500303231Sdim } 501303231Sdim } 502303231Sdim 503303231Sdim DEBUG(dbgs() << "Emitting segments for file: " << Filename << "\n"); 504303231Sdim FileCoverage.Segments = SegmentBuilder::buildSegments(Regions); 505303231Sdim 506303231Sdim return FileCoverage; 507303231Sdim} 508303231Sdim 509303231Sdimstd::vector<const FunctionRecord *> 510303231SdimCoverageMapping::getInstantiations(StringRef Filename) const { 511303231Sdim FunctionInstantiationSetCollector InstantiationSetCollector; 512303231Sdim for (const auto &Function : Functions) { 513303231Sdim auto MainFileID = findMainViewFileID(Filename, Function); 514303231Sdim if (!MainFileID) 515303231Sdim continue; 516303231Sdim InstantiationSetCollector.insert(Function, *MainFileID); 517303231Sdim } 518303231Sdim 519303231Sdim std::vector<const FunctionRecord *> Result; 520303231Sdim for (const auto &InstantiationSet : InstantiationSetCollector) { 521303231Sdim if (InstantiationSet.second.size() < 2) 522303231Sdim continue; 523303231Sdim Result.insert(Result.end(), InstantiationSet.second.begin(), 524303231Sdim InstantiationSet.second.end()); 525303231Sdim } 526303231Sdim return Result; 527303231Sdim} 528303231Sdim 529303231SdimCoverageData 530303231SdimCoverageMapping::getCoverageForFunction(const FunctionRecord &Function) const { 531303231Sdim auto MainFileID = findMainViewFileID(Function); 532303231Sdim if (!MainFileID) 533303231Sdim return CoverageData(); 534303231Sdim 535303231Sdim CoverageData FunctionCoverage(Function.Filenames[*MainFileID]); 536303231Sdim std::vector<coverage::CountedRegion> Regions; 537303231Sdim for (const auto &CR : Function.CountedRegions) 538303231Sdim if (CR.FileID == *MainFileID) { 539303231Sdim Regions.push_back(CR); 540303231Sdim if (isExpansion(CR, *MainFileID)) 541303231Sdim FunctionCoverage.Expansions.emplace_back(CR, Function); 542303231Sdim } 543303231Sdim 544303231Sdim DEBUG(dbgs() << "Emitting segments for function: " << Function.Name << "\n"); 545303231Sdim FunctionCoverage.Segments = SegmentBuilder::buildSegments(Regions); 546303231Sdim 547303231Sdim return FunctionCoverage; 548303231Sdim} 549303231Sdim 550303231SdimCoverageData CoverageMapping::getCoverageForExpansion( 551303231Sdim const ExpansionRecord &Expansion) const { 552303231Sdim CoverageData ExpansionCoverage( 553303231Sdim Expansion.Function.Filenames[Expansion.FileID]); 554303231Sdim std::vector<coverage::CountedRegion> Regions; 555303231Sdim for (const auto &CR : Expansion.Function.CountedRegions) 556303231Sdim if (CR.FileID == Expansion.FileID) { 557303231Sdim Regions.push_back(CR); 558303231Sdim if (isExpansion(CR, Expansion.FileID)) 559303231Sdim ExpansionCoverage.Expansions.emplace_back(CR, Expansion.Function); 560303231Sdim } 561303231Sdim 562303231Sdim DEBUG(dbgs() << "Emitting segments for expansion of file " << Expansion.FileID 563303231Sdim << "\n"); 564303231Sdim ExpansionCoverage.Segments = SegmentBuilder::buildSegments(Regions); 565303231Sdim 566303231Sdim return ExpansionCoverage; 567303231Sdim} 568303231Sdim 569303231Sdimnamespace { 570303231Sdimstd::string getCoverageMapErrString(coveragemap_error Err) { 571303231Sdim switch (Err) { 572303231Sdim case coveragemap_error::success: 573303231Sdim return "Success"; 574303231Sdim case coveragemap_error::eof: 575303231Sdim return "End of File"; 576303231Sdim case coveragemap_error::no_data_found: 577303231Sdim return "No coverage data found"; 578303231Sdim case coveragemap_error::unsupported_version: 579303231Sdim return "Unsupported coverage format version"; 580303231Sdim case coveragemap_error::truncated: 581303231Sdim return "Truncated coverage data"; 582303231Sdim case coveragemap_error::malformed: 583303231Sdim return "Malformed coverage data"; 584303231Sdim } 585303231Sdim llvm_unreachable("A value of coveragemap_error has no message."); 586303231Sdim} 587303231Sdim 588303231Sdim// FIXME: This class is only here to support the transition to llvm::Error. It 589303231Sdim// will be removed once this transition is complete. Clients should prefer to 590303231Sdim// deal with the Error value directly, rather than converting to error_code. 591303231Sdimclass CoverageMappingErrorCategoryType : public std::error_category { 592314564Sdim const char *name() const noexcept override { return "llvm.coveragemap"; } 593303231Sdim std::string message(int IE) const override { 594303231Sdim return getCoverageMapErrString(static_cast<coveragemap_error>(IE)); 595303231Sdim } 596303231Sdim}; 597303231Sdim} // end anonymous namespace 598303231Sdim 599303231Sdimstd::string CoverageMapError::message() const { 600303231Sdim return getCoverageMapErrString(Err); 601303231Sdim} 602303231Sdim 603303231Sdimstatic ManagedStatic<CoverageMappingErrorCategoryType> ErrorCategory; 604303231Sdim 605303231Sdimconst std::error_category &llvm::coverage::coveragemap_category() { 606303231Sdim return *ErrorCategory; 607303231Sdim} 608303231Sdim 609303231Sdimchar CoverageMapError::ID = 0; 610