void CodeCoverageTool::createExpansionSubView(
const MappingRegion &ExpandedRegion,
const FunctionCoverageMapping &Function, SourceCoverageView &Parent) {
auto ExpandedLines = findExpandedFileInterestingLineRange(
ExpandedRegion.ExpandedFileID, Function);
if (ViewOpts.Debug)
llvm::outs() << "Expansion of " << ExpandedRegion.ExpandedFileID << ":"
<< ExpandedLines.first << " -> " << ExpandedLines.second
<< " @ " << ExpandedRegion.FileID << ", "
<< ExpandedRegion.LineStart << ":"
<< ExpandedRegion.ColumnStart << "\n";
auto SourceBuffer =
getSourceFile(Function.Filenames[ExpandedRegion.ExpandedFileID]);
if (!SourceBuffer)
return;
auto SubView = llvm::make_unique<SourceCoverageView>(
SourceBuffer.get(), Parent.getOptions(), ExpandedLines.first,
ExpandedLines.second, ExpandedRegion);
SourceCoverageDataManager RegionManager;
for (const auto &Region : Function.MappingRegions) {
if (Region.FileID == ExpandedRegion.ExpandedFileID)
RegionManager.insert(Region);
}
SubView->load(RegionManager);
createExpansionSubViews(*SubView, ExpandedRegion.ExpandedFileID, Function);
Parent.addChild(std::move(SubView));
}
bool CodeCoverageTool::createSourceFileView(
StringRef SourceFile, SourceCoverageView &View,
ArrayRef<FunctionCoverageMapping> FunctionMappingRecords,
bool UseOnlyRegionsInMainFile) {
SourceCoverageDataManager RegionManager;
FunctionInstantiationSetCollector InstantiationSetCollector;
for (const auto &Function : FunctionMappingRecords) {
unsigned MainFileID;
if (findMainViewFileID(SourceFile, Function, MainFileID))
continue;
SmallSet<unsigned, 8> InterestingFileIDs;
if (UseOnlyRegionsInMainFile) {
InterestingFileIDs.insert(MainFileID);
} else if (!gatherInterestingFileIDs(SourceFile, Function,
InterestingFileIDs))
continue;
// Get the interesting regions
for (const auto &Region : Function.MappingRegions) {
if (InterestingFileIDs.count(Region.FileID))
RegionManager.insert(Region);
}
InstantiationSetCollector.insert(Function, MainFileID);
createExpansionSubViews(View, MainFileID, Function);
}
if (RegionManager.getSourceRegions().empty())
return true;
View.load(RegionManager);
// Show instantiations
if (!ViewOpts.ShowFunctionInstantiations)
return false;
for (const auto &InstantiationSet : InstantiationSetCollector) {
if (InstantiationSet.second.size() < 2)
continue;
auto InterestingRange = findExpandedFileInterestingLineRange(
InstantiationSet.second.front()->MappingRegions.front().FileID,
*InstantiationSet.second.front());
for (auto Function : InstantiationSet.second) {
auto SubView = llvm::make_unique<SourceCoverageView>(
View, InterestingRange.first, InterestingRange.second,
Function->PrettyName);
createInstantiationSubView(SourceFile, *Function, *SubView);
View.addChild(std::move(SubView));
}
}
return false;
}
void CodeCoverageTool::createInstantiationSubView(
StringRef SourceFile, const FunctionCoverageMapping &Function,
SourceCoverageView &View) {
SourceCoverageDataManager RegionManager;
SmallSet<unsigned, 8> InterestingFileIDs;
if (!gatherInterestingFileIDs(SourceFile, Function, InterestingFileIDs))
return;
// Get the interesting regions
for (const auto &Region : Function.MappingRegions) {
if (InterestingFileIDs.count(Region.FileID))
RegionManager.insert(Region);
}
View.load(RegionManager);
unsigned MainFileID;
if (findMainViewFileID(SourceFile, Function, MainFileID))
return;
createExpansionSubViews(View, MainFileID, Function);
}
void SourceCoverageView::setUpVisibleRange(SourceCoverageDataManager &Data) {
auto CountedRegions = Data.getSourceRegions();
if (!CountedRegions.size())
return;
unsigned Start = CountedRegions.front().LineStart, End = 0;
for (const auto &CR : CountedRegions) {
Start = std::min(Start, CR.LineStart);
End = std::max(End, CR.LineEnd);
}
LineOffset = Start;
LineStats.resize(End - Start + 1);
}
void
SourceCoverageView::createLineCoverageInfo(SourceCoverageDataManager &Data) {
auto CountedRegions = Data.getSourceRegions();
for (const auto &CR : CountedRegions) {
if (CR.Kind == coverage::CounterMappingRegion::SkippedRegion) {
// Reset the line stats for skipped regions.
for (unsigned Line = CR.LineStart; Line <= CR.LineEnd;
++Line)
LineStats[Line - LineOffset] = LineCoverageInfo();
continue;
}
LineStats[CR.LineStart - LineOffset].addRegionStartCount(CR.ExecutionCount);
for (unsigned Line = CR.LineStart + 1; Line <= CR.LineEnd; ++Line)
LineStats[Line - LineOffset].addRegionCount(CR.ExecutionCount);
}
}
void
SourceCoverageView::createHighlightRanges(SourceCoverageDataManager &Data) {
auto CountedRegions = Data.getSourceRegions();
std::vector<bool> AlreadyHighlighted;
AlreadyHighlighted.resize(CountedRegions.size(), false);
for (size_t I = 0, S = CountedRegions.size(); I < S; ++I) {
const auto &CR = CountedRegions[I];
if (CR.Kind == coverage::CounterMappingRegion::SkippedRegion ||
CR.ExecutionCount != 0)
continue;
if (AlreadyHighlighted[I])
continue;
for (size_t J = 0; J < S; ++J) {
if (CR.contains(CountedRegions[J])) {
AlreadyHighlighted[J] = true;
}
}
if (CR.LineStart == CR.LineEnd) {
HighlightRanges.push_back(HighlightRange(
CR.LineStart, CR.ColumnStart, CR.ColumnEnd));
continue;
}
HighlightRanges.push_back(
HighlightRange(CR.LineStart, CR.ColumnStart,
std::numeric_limits<unsigned>::max()));
HighlightRanges.push_back(
HighlightRange(CR.LineEnd, 1, CR.ColumnEnd));
for (unsigned Line = CR.LineStart + 1; Line < CR.LineEnd;
++Line) {
HighlightRanges.push_back(
HighlightRange(Line, 1, std::numeric_limits<unsigned>::max()));
}
}
std::sort(HighlightRanges.begin(), HighlightRanges.end());
}
void SourceCoverageView::createRegionMarkers(SourceCoverageDataManager &Data) {
for (const auto &CR : Data.getSourceRegions())
if (CR.Kind != coverage::CounterMappingRegion::SkippedRegion)
Markers.push_back(
RegionMarker(CR.LineStart, CR.ColumnStart, CR.ExecutionCount));
}
