llvm-3.9.0_threads.patch
From d1cc48989b13780f21c408fef17dceb104a09c9d Mon Sep 17 00:00:00 2001
From: Alex Crichton <alex@alexcrichton.com>
Date: Thu, 28 Jan 2016 20:44:50 -0800
Subject: [PATCH] Don't compile usage of std::thread
As of the time of this writing it's not actually used anywhere meaningfullly
throughout the LLVM repo that we need, and it unfortunately uses `std::thread`
which isn't available in mingw-w64 toolchains with the win32 threading model
(the one that we use).
The change made to achive this was to just always use the single-threaded
support in `include/llvm/Support/thread.h`, and hopefuly that'll be enough...
For reference, the upstream LLVM bug has been reported [1]
[1]: https://llvm.org/bugs/show_bug.cgi?id=26365
---
include/llvm/ExecutionEngine/Orc/RPCChannel.h | 13 -
include/llvm/ExecutionEngine/Orc/RPCUtils.h | 16 +-
include/llvm/Support/ThreadPool.h | 4 +
include/llvm/Support/thread.h | 2 +-
lib/CodeGen/ParallelCG.cpp | 2 +
lib/LTO/ThinLTOCodeGenerator.cpp | 4 +-
lib/Support/ThreadPool.cpp | 6 +-
test/CMakeLists.txt | 1 -
tools/lli/CMakeLists.txt | 5 -
tools/lli/ChildTarget/CMakeLists.txt | 10 -
tools/lli/ChildTarget/ChildTarget.cpp | 78 --
tools/lli/ChildTarget/LLVMBuild.txt | 21 -
tools/lli/LLVMBuild.txt | 3 -
tools/lli/OrcLazyJIT.cpp | 158 ----
tools/lli/OrcLazyJIT.h | 163 ----
tools/lli/RemoteJITUtils.h | 152 ---
tools/lli/lli.cpp | 7 +
tools/llvm-cov/CMakeLists.txt | 18 +-
tools/llvm-cov/CodeCoverage.cpp | 727 ---------------
tools/llvm-cov/CoverageFilters.cpp | 59 --
tools/llvm-cov/CoverageFilters.h | 127 ---
tools/llvm-cov/CoverageReport.cpp | 235 -----
tools/llvm-cov/CoverageReport.h | 41 -
tools/llvm-cov/CoverageSummaryInfo.cpp | 71 --
tools/llvm-cov/CoverageSummaryInfo.h | 162 ----
tools/llvm-cov/CoverageViewOptions.h | 52 --
tools/llvm-cov/RenderingSupport.h | 61 --
tools/llvm-cov/SourceCoverageView.cpp | 233 -----
tools/llvm-cov/SourceCoverageView.h | 285 ------
tools/llvm-cov/SourceCoverageViewHTML.cpp | 436 ---------
tools/llvm-cov/SourceCoverageViewHTML.h | 83 --
tools/llvm-cov/SourceCoverageViewText.cpp | 213 -----
tools/llvm-cov/SourceCoverageViewText.h | 83 --
tools/llvm-cov/TestingSupport.cpp | 92 --
tools/llvm-cov/gcov.cpp | 145 ---
tools/llvm-cov/llvm-cov.cpp | 79 --
tools/sancov/sancov.cc | 1244 +------------------------
37 files changed, 43 insertions(+), 5048 deletions(-)
delete mode 100644 tools/lli/ChildTarget/CMakeLists.txt
delete mode 100644 tools/lli/ChildTarget/ChildTarget.cpp
delete mode 100644 tools/lli/ChildTarget/LLVMBuild.txt
delete mode 100644 tools/lli/OrcLazyJIT.cpp
delete mode 100644 tools/lli/OrcLazyJIT.h
delete mode 100644 tools/lli/RemoteJITUtils.h
delete mode 100644 tools/llvm-cov/CodeCoverage.cpp
delete mode 100644 tools/llvm-cov/CoverageFilters.cpp
delete mode 100644 tools/llvm-cov/CoverageFilters.h
delete mode 100644 tools/llvm-cov/CoverageReport.cpp
delete mode 100644 tools/llvm-cov/CoverageReport.h
delete mode 100644 tools/llvm-cov/CoverageSummaryInfo.cpp
delete mode 100644 tools/llvm-cov/CoverageSummaryInfo.h
delete mode 100644 tools/llvm-cov/CoverageViewOptions.h
delete mode 100644 tools/llvm-cov/RenderingSupport.h
delete mode 100644 tools/llvm-cov/SourceCoverageView.cpp
delete mode 100644 tools/llvm-cov/SourceCoverageView.h
delete mode 100644 tools/llvm-cov/SourceCoverageViewHTML.cpp
delete mode 100644 tools/llvm-cov/SourceCoverageViewHTML.h
delete mode 100644 tools/llvm-cov/SourceCoverageViewText.cpp
delete mode 100644 tools/llvm-cov/SourceCoverageViewText.h
delete mode 100644 tools/llvm-cov/TestingSupport.cpp
delete mode 100644 tools/llvm-cov/gcov.cpp
diff --git a/include/llvm/ExecutionEngine/Orc/RPCChannel.h b/include/llvm/ExecutionEngine/Orc/RPCChannel.h
index c569e3c..9fb0141 100644
--- a/include/llvm/ExecutionEngine/Orc/RPCChannel.h
+++ b/include/llvm/ExecutionEngine/Orc/RPCChannel.h
@@ -40,42 +40,29 @@ class RPCChannel {
/// Flush the stream if possible.
virtual Error send() = 0;
-
- /// Get the lock for stream reading.
- std::mutex &getReadLock() { return readLock; }
-
- /// Get the lock for stream writing.
- std::mutex &getWriteLock() { return writeLock; }
-
-private:
- std::mutex readLock, writeLock;
};
/// Notify the channel that we're starting a message send.
/// Locks the channel for writing.
inline Error startSendMessage(RPCChannel &C) {
- C.getWriteLock().lock();
return Error::success();
}
/// Notify the channel that we're ending a message send.
/// Unlocks the channel for writing.
inline Error endSendMessage(RPCChannel &C) {
- C.getWriteLock().unlock();
return Error::success();
}
/// Notify the channel that we're starting a message receive.
/// Locks the channel for reading.
inline Error startReceiveMessage(RPCChannel &C) {
- C.getReadLock().lock();
return Error::success();
}
/// Notify the channel that we're ending a message receive.
/// Unlocks the channel for reading.
inline Error endReceiveMessage(RPCChannel &C) {
- C.getReadLock().unlock();
return Error::success();
}
diff --git a/include/llvm/ExecutionEngine/Orc/RPCUtils.h b/include/llvm/ExecutionEngine/Orc/RPCUtils.h
index 966a496..b6c8ebd 100644
--- a/include/llvm/ExecutionEngine/Orc/RPCUtils.h
+++ b/include/llvm/ExecutionEngine/Orc/RPCUtils.h
@@ -102,6 +102,7 @@ class RPCBase {
template <typename ChannelT>
static Error readResult(ChannelT &C, std::promise<OptionalReturn> &P) {
+#if 0
RetT Val;
auto Err = deserialize(C, Val);
auto Err2 = endReceiveMessage(C);
@@ -112,11 +113,14 @@ class RPCBase {
return Err;
}
P.set_value(std::move(Val));
+#endif
return Error::success();
}
static void abandon(std::promise<OptionalReturn> &P) {
+#if 0
P.set_value(OptionalReturn());
+#endif
}
template <typename ChannelT, typename SequenceNumberT>
@@ -159,11 +163,17 @@ class RPCBase {
template <typename ChannelT>
static Error readResult(ChannelT &C, std::promise<OptionalReturn> &P) {
// Void functions don't have anything to deserialize, so we're good.
+#if 0
P.set_value(true);
+#endif
return endReceiveMessage(C);
}
- static void abandon(std::promise<OptionalReturn> &P) { P.set_value(false); }
+ static void abandon(std::promise<OptionalReturn> &P) {
+#if 0
+ P.set_value(false);
+#endif
+ }
template <typename ChannelT, typename SequenceNumberT>
static Error respond(ChannelT &C, SequenceNumberT SeqNo,
@@ -617,13 +627,11 @@ class RPC : public RPCBase {
}
void reset() {
- std::lock_guard<std::mutex> Lock(SeqNoLock);
NextSequenceNumber = 0;
FreeSequenceNumbers.clear();
}
SequenceNumberT getSequenceNumber() {
- std::lock_guard<std::mutex> Lock(SeqNoLock);
if (FreeSequenceNumbers.empty())
return NextSequenceNumber++;
auto SequenceNumber = FreeSequenceNumbers.back();
@@ -632,12 +640,10 @@ class RPC : public RPCBase {
}
void releaseSequenceNumber(SequenceNumberT SequenceNumber) {
- std::lock_guard<std::mutex> Lock(SeqNoLock);
FreeSequenceNumbers.push_back(SequenceNumber);
}
private:
- std::mutex SeqNoLock;
SequenceNumberT NextSequenceNumber = 0;
std::vector<SequenceNumberT> FreeSequenceNumbers;
};
diff --git a/include/llvm/Support/ThreadPool.h b/include/llvm/Support/ThreadPool.h
index 665cec2..c3aa64d 100644
--- a/include/llvm/Support/ThreadPool.h
+++ b/include/llvm/Support/ThreadPool.h
@@ -16,6 +16,8 @@
#include "llvm/Support/thread.h"
+# if 0
+
#ifdef _MSC_VER
// concrt.h depends on eh.h for __uncaught_exception declaration
// even if we disable exceptions.
@@ -134,4 +136,6 @@ class ThreadPool {
};
}
+# endif
+
#endif // LLVM_SUPPORT_THREAD_POOL_H
diff --git a/include/llvm/Support/thread.h b/include/llvm/Support/thread.h
index 9c45418..27d42d2 100644
--- a/include/llvm/Support/thread.h
+++ b/include/llvm/Support/thread.h
@@ -19,7 +19,7 @@
#include "llvm/Config/llvm-config.h"
-#if LLVM_ENABLE_THREADS
+#if LLVM_ENABLE_THREADS && 0
#ifdef _MSC_VER
// concrt.h depends on eh.h for __uncaught_exception declaration
diff --git a/lib/CodeGen/ParallelCG.cpp b/lib/CodeGen/ParallelCG.cpp
index ccdaec1..1f35590 100644
--- a/lib/CodeGen/ParallelCG.cpp
+++ b/lib/CodeGen/ParallelCG.cpp
@@ -49,6 +49,7 @@ std::unique_ptr<Module> llvm::splitCodeGen(
return M;
}
+#if 0
// Create ThreadPool in nested scope so that threads will be joined
// on destruction.
{
@@ -95,5 +96,6 @@ std::unique_ptr<Module> llvm::splitCodeGen(
PreserveLocals);
}
+#endif
return {};
}
diff --git a/lib/LTO/ThinLTOCodeGenerator.cpp b/lib/LTO/ThinLTOCodeGenerator.cpp
index bfb0980..e4f9977 100644
--- a/lib/LTO/ThinLTOCodeGenerator.cpp
+++ b/lib/LTO/ThinLTOCodeGenerator.cpp
@@ -64,7 +64,7 @@ extern cl::opt<bool> LTODiscardValueNames;
namespace {
static cl::opt<int> ThreadCount("threads",
- cl::init(std::thread::hardware_concurrency()));
+ cl::init(1));
static void diagnosticHandler(const DiagnosticInfo &DI) {
DiagnosticPrinterRawOStream DP(errs());
@@ -667,6 +667,7 @@ std::unique_ptr<MemoryBuffer> ThinLTOCodeGenerator::codegen(Module &TheModule) {
// Main entry point for the ThinLTO processing
void ThinLTOCodeGenerator::run() {
+#if 0
if (CodeGenOnly) {
// Perform only parallel codegen and return.
ThreadPool Pool;
@@ -832,4 +833,5 @@ void ThinLTOCodeGenerator::run() {
// If statistics were requested, print them out now.
if (llvm::AreStatisticsEnabled())
llvm::PrintStatistics();
+#endif
}
diff --git a/lib/Support/ThreadPool.cpp b/lib/Support/ThreadPool.cpp
index db03a4d..71f4933 100644
--- a/lib/Support/ThreadPool.cpp
+++ b/lib/Support/ThreadPool.cpp
@@ -11,6 +11,8 @@
//
//===----------------------------------------------------------------------===//
+#if 0
+
#include "llvm/Support/ThreadPool.h"
#include "llvm/Config/llvm-config.h"
@@ -18,7 +20,7 @@
using namespace llvm;
-#if LLVM_ENABLE_THREADS
+#if LLVM_ENABLE_THREADS && 0
// Default to std::thread::hardware_concurrency
ThreadPool::ThreadPool() : ThreadPool(std::thread::hardware_concurrency()) {}
@@ -156,3 +158,5 @@ ThreadPool::~ThreadPool() {
}
#endif
+
+#endif
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index e5773bd..40122bd 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -27,7 +27,6 @@ set(LLVM_TEST_DEPENDS
count
llc
lli
- lli-child-target
llvm-ar
llvm-as
llvm-bcanalyzer
diff --git a/tools/lli/CMakeLists.txt b/tools/lli/CMakeLists.txt
index 2bdd066..8a4c9d0 100644
--- a/tools/lli/CMakeLists.txt
+++ b/tools/lli/CMakeLists.txt
@@ -1,7 +1,3 @@
-if ( LLVM_INCLUDE_UTILS )
- add_subdirectory(ChildTarget)
-endif()
-
set(LLVM_LINK_COMPONENTS
CodeGen
Core
diff --git a/tools/lli/ChildTarget/CMakeLists.txt b/tools/lli/ChildTarget/CMakeLists.txt
deleted file mode 100644
index e4fe0c7..0000000
--- a/tools/lli/ChildTarget/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-set(LLVM_LINK_COMPONENTS
- OrcJIT
- RuntimeDyld
- Support
- )
-
-add_llvm_utility(lli-child-target
- ChildTarget.cpp
-)
-
diff --git a/tools/lli/ChildTarget/ChildTarget.cpp b/tools/lli/ChildTarget/ChildTarget.cpp
deleted file mode 100644
index f6d2413..0000000
--- a/tools/lli/ChildTarget/ChildTarget.cpp
+++ /dev/null
@@ -1,78 +0,0 @@
-#include "llvm/ExecutionEngine/Orc/OrcABISupport.h"
-#include "llvm/ExecutionEngine/Orc/OrcRemoteTargetServer.h"
-#include "llvm/Support/Debug.h"
-#include "llvm/Support/DynamicLibrary.h"
-#include "llvm/Support/Process.h"
-#include <sstream>
-
-#include "../RemoteJITUtils.h"
-
-using namespace llvm;
-using namespace llvm::orc;
-using namespace llvm::sys;
-
-#ifdef __x86_64__
-typedef OrcX86_64_SysV HostOrcArch;
-#else
-typedef OrcGenericABI HostOrcArch;
-#endif
-
-ExitOnError ExitOnErr;
-
-int main(int argc, char *argv[]) {
-
- if (argc != 3) {
- errs() << "Usage: " << argv[0] << " <input fd> <output fd>\n";
- return 1;
- }
-
- ExitOnErr.setBanner(std::string(argv[0]) + ":");
-
- int InFD;
- int OutFD;
- {
- std::istringstream InFDStream(argv[1]), OutFDStream(argv[2]);
- InFDStream >> InFD;
- OutFDStream >> OutFD;
- }
-
- if (sys::DynamicLibrary::LoadLibraryPermanently(nullptr)) {
- errs() << "Error loading program symbols.\n";
- return 1;
- }
-
- auto SymbolLookup = [](const std::string &Name) {
- return RTDyldMemoryManager::getSymbolAddressInProcess(Name);
- };
-
- auto RegisterEHFrames = [](uint8_t *Addr, uint32_t Size) {
- RTDyldMemoryManager::registerEHFramesInProcess(Addr, Size);
- };
-
- auto DeregisterEHFrames = [](uint8_t *Addr, uint32_t Size) {
- RTDyldMemoryManager::deregisterEHFramesInProcess(Addr, Size);
- };
-
- FDRPCChannel Channel(InFD, OutFD);
- typedef remote::OrcRemoteTargetServer<FDRPCChannel, HostOrcArch> JITServer;
- JITServer Server(Channel, SymbolLookup, RegisterEHFrames, DeregisterEHFrames);
-
- while (1) {
- uint32_t RawId;
- ExitOnErr(Server.startReceivingFunction(Channel, RawId));
- auto Id = static_cast<JITServer::JITFuncId>(RawId);
- switch (Id) {
- case JITServer::TerminateSessionId:
- ExitOnErr(Server.handleTerminateSession());
- return 0;
- default:
- ExitOnErr(Server.handleKnownFunction(Id));
- break;
- }
- }
-
- close(InFD);
- close(OutFD);
-
- return 0;
-}
diff --git a/tools/lli/ChildTarget/LLVMBuild.txt b/tools/lli/ChildTarget/LLVMBuild.txt
deleted file mode 100644
index daf6df1..0000000
--- a/tools/lli/ChildTarget/LLVMBuild.txt
+++ /dev/null
@@ -1,21 +0,0 @@
-;===- ./tools/lli/ChildTarget/LLVMBuild.txt --------------------*- Conf -*--===;
-;
-; The LLVM Compiler Infrastructure
-;
-; This file is distributed under the University of Illinois Open Source
-; License. See LICENSE.TXT for details.
-;
-;===------------------------------------------------------------------------===;
-;
-; This is an LLVMBuild description file for the components in this subdirectory.
-;
-; For more information on the LLVMBuild system, please see:
-;
-; http://llvm.org/docs/LLVMBuild.html
-;
-;===------------------------------------------------------------------------===;
-
-[component_0]
-type = Tool
-name = lli-child-target
-parent = lli
diff --git a/tools/lli/LLVMBuild.txt b/tools/lli/LLVMBuild.txt
index 9d889bf..4738504 100644
--- a/tools/lli/LLVMBuild.txt
+++ b/tools/lli/LLVMBuild.txt
@@ -15,9 +15,6 @@
;
;===------------------------------------------------------------------------===;
-[common]
-subdirectories = ChildTarget
-
[component_0]
type = Tool
name = lli
diff --git a/tools/lli/OrcLazyJIT.cpp b/tools/lli/OrcLazyJIT.cpp
index b13e769..8b13789 100644
--- a/tools/lli/OrcLazyJIT.cpp
+++ b/tools/lli/OrcLazyJIT.cpp
@@ -1,158 +1 @@
-//===------ OrcLazyJIT.cpp - Basic Orc-based JIT for lazy execution -------===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "OrcLazyJIT.h"
-#include "llvm/ExecutionEngine/Orc/OrcABISupport.h"
-#include "llvm/Support/Debug.h"
-#include "llvm/Support/DynamicLibrary.h"
-#include <cstdio>
-#include <system_error>
-
-using namespace llvm;
-
-namespace {
-
- enum class DumpKind { NoDump, DumpFuncsToStdOut, DumpModsToStdErr,
- DumpModsToDisk };
-
- cl::opt<DumpKind> OrcDumpKind("orc-lazy-debug",
- cl::desc("Debug dumping for the orc-lazy JIT."),
- cl::init(DumpKind::NoDump),
- cl::values(
- clEnumValN(DumpKind::NoDump, "no-dump",
- "Don't dump anything."),
- clEnumValN(DumpKind::DumpFuncsToStdOut,
- "funcs-to-stdout",
- "Dump function names to stdout."),
- clEnumValN(DumpKind::DumpModsToStdErr,
- "mods-to-stderr",
- "Dump modules to stderr."),
- clEnumValN(DumpKind::DumpModsToDisk,
- "mods-to-disk",
- "Dump modules to the current "
- "working directory. (WARNING: "
- "will overwrite existing files)."),
- clEnumValEnd),
- cl::Hidden);
-
- cl::opt<bool> OrcInlineStubs("orc-lazy-inline-stubs",
- cl::desc("Try to inline stubs"),
- cl::init(true), cl::Hidden);
-}
-
-OrcLazyJIT::TransformFtor OrcLazyJIT::createDebugDumper() {
-
- switch (OrcDumpKind) {
- case DumpKind::NoDump:
- return [](std::unique_ptr<Module> M) { return M; };
-
- case DumpKind::DumpFuncsToStdOut:
- return [](std::unique_ptr<Module> M) {
- printf("[ ");
-
- for (const auto &F : *M) {
- if (F.isDeclaration())
- continue;
-
- if (F.hasName()) {
- std::string Name(F.getName());
- printf("%s ", Name.c_str());
- } else
- printf("<anon> ");
- }
-
- printf("]\n");
- return M;
- };
-
- case DumpKind::DumpModsToStdErr:
- return [](std::unique_ptr<Module> M) {
- dbgs() << "----- Module Start -----\n" << *M
- << "----- Module End -----\n";
-
- return M;
- };
-
- case DumpKind::DumpModsToDisk:
- return [](std::unique_ptr<Module> M) {
- std::error_code EC;
- raw_fd_ostream Out(M->getModuleIdentifier() + ".ll", EC,
- sys::fs::F_Text);
- if (EC) {
- errs() << "Couldn't open " << M->getModuleIdentifier()
- << " for dumping.\nError:" << EC.message() << "\n";
- exit(1);
- }
- Out << *M;
- return M;
- };
- }
- llvm_unreachable("Unknown DumpKind");
-}
-
-// Defined in lli.cpp.
-CodeGenOpt::Level getOptLevel();
-
-
-template <typename PtrTy>
-static PtrTy fromTargetAddress(orc::TargetAddress Addr) {
- return reinterpret_cast<PtrTy>(static_cast<uintptr_t>(Addr));
-}
-
-int llvm::runOrcLazyJIT(std::unique_ptr<Module> M, int ArgC, char* ArgV[]) {
- // Add the program's symbols into the JIT's search space.
- if (sys::DynamicLibrary::LoadLibraryPermanently(nullptr)) {
- errs() << "Error loading program symbols.\n";
- return 1;
- }
-
- // Grab a target machine and try to build a factory function for the
- // target-specific Orc callback manager.
- EngineBuilder EB;
- EB.setOptLevel(getOptLevel());
- auto TM = std::unique_ptr<TargetMachine>(EB.selectTarget());
- Triple T(TM->getTargetTriple());
- auto CompileCallbackMgr = orc::createLocalCompileCallbackManager(T, 0);
-
- // If we couldn't build the factory function then there must not be a callback
- // manager for this target. Bail out.
- if (!CompileCallbackMgr) {
- errs() << "No callback manager available for target '"
- << TM->getTargetTriple().str() << "'.\n";
- return 1;
- }
-
- auto IndirectStubsMgrBuilder = orc::createLocalIndirectStubsManagerBuilder(T);
-
- // If we couldn't build a stubs-manager-builder for this target then bail out.
- if (!IndirectStubsMgrBuilder) {
- errs() << "No indirect stubs manager available for target '"
- << TM->getTargetTriple().str() << "'.\n";
- return 1;
- }
-
- // Everything looks good. Build the JIT.
- OrcLazyJIT J(std::move(TM), std::move(CompileCallbackMgr),
- std::move(IndirectStubsMgrBuilder),
- OrcInlineStubs);
-
- // Add the module, look up main and run it.
- auto MainHandle = J.addModule(std::move(M));
- auto MainSym = J.findSymbolIn(MainHandle, "main");
-
- if (!MainSym) {
- errs() << "Could not find main function.\n";
- return 1;
- }
-
- typedef int (*MainFnPtr)(int, char*[]);
- auto Main = fromTargetAddress<MainFnPtr>(MainSym.getAddress());
- return Main(ArgC, ArgV);
-}
diff --git a/tools/lli/OrcLazyJIT.h b/tools/lli/OrcLazyJIT.h
deleted file mode 100644
index 733bdd8..0000000
--- a/tools/lli/OrcLazyJIT.h
+++ /dev/null
@@ -1,163 +0,0 @@
-//===--- OrcLazyJIT.h - Basic Orc-based JIT for lazy execution --*- C++ -*-===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// Simple Orc-based JIT. Uses the compile-on-demand layer to break up and
-// lazily compile modules.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_TOOLS_LLI_ORCLAZYJIT_H
-#define LLVM_TOOLS_LLI_ORCLAZYJIT_H
-
-#include "llvm/ADT/Triple.h"
-#include "llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h"
-#include "llvm/ExecutionEngine/Orc/CompileUtils.h"
-#include "llvm/ExecutionEngine/Orc/ExecutionUtils.h"
-#include "llvm/ExecutionEngine/Orc/IRCompileLayer.h"
-#include "llvm/ExecutionEngine/Orc/IRTransformLayer.h"
-#include "llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h"
-#include "llvm/ExecutionEngine/RTDyldMemoryManager.h"
-
-namespace llvm {
-
-class OrcLazyJIT {
-public:
-
- typedef orc::JITCompileCallbackManager CompileCallbackMgr;
- typedef orc::ObjectLinkingLayer<> ObjLayerT;
- typedef orc::IRCompileLayer<ObjLayerT> CompileLayerT;
- typedef std::function<std::unique_ptr<Module>(std::unique_ptr<Module>)>
- TransformFtor;
- typedef orc::IRTransformLayer<CompileLayerT, TransformFtor> IRDumpLayerT;
- typedef orc::CompileOnDemandLayer<IRDumpLayerT, CompileCallbackMgr> CODLayerT;
- typedef CODLayerT::IndirectStubsManagerBuilderT
- IndirectStubsManagerBuilder;
- typedef CODLayerT::ModuleSetHandleT ModuleHandleT;
-
- OrcLazyJIT(std::unique_ptr<TargetMachine> TM,
- std::unique_ptr<CompileCallbackMgr> CCMgr,
- IndirectStubsManagerBuilder IndirectStubsMgrBuilder,
- bool InlineStubs)
- : TM(std::move(TM)), DL(this->TM->createDataLayout()),
- CCMgr(std::move(CCMgr)),
- ObjectLayer(),
- CompileLayer(ObjectLayer, orc::SimpleCompiler(*this->TM)),
- IRDumpLayer(CompileLayer, createDebugDumper()),
- CODLayer(IRDumpLayer, extractSingleFunction, *this->CCMgr,
- std::move(IndirectStubsMgrBuilder), InlineStubs),
- CXXRuntimeOverrides(
- [this](const std::string &S) { return mangle(S); }) {}
-
- ~OrcLazyJIT() {
- // Run any destructors registered with __cxa_atexit.
- CXXRuntimeOverrides.runDestructors();
- // Run any IR destructors.
- for (auto &DtorRunner : IRStaticDestructorRunners)
- DtorRunner.runViaLayer(CODLayer);
- }
-
- ModuleHandleT addModule(std::unique_ptr<Module> M) {
- // Attach a data-layout if one isn't already present.
- if (M->getDataLayout().isDefault())
- M->setDataLayout(DL);
-
- // Record the static constructors and destructors. We have to do this before
- // we hand over ownership of the module to the JIT.
- std::vector<std::string> CtorNames, DtorNames;
- for (auto Ctor : orc::getConstructors(*M))
- CtorNames.push_back(mangle(Ctor.Func->getName()));
- for (auto Dtor : orc::getDestructors(*M))
- DtorNames.push_back(mangle(Dtor.Func->getName()));
-
- // Symbol resolution order:
- // 1) Search the JIT symbols.
- // 2) Check for C++ runtime overrides.
- // 3) Search the host process (LLI)'s symbol table.
- auto Resolver =
- orc::createLambdaResolver(
- [this](const std::string &Name) {
- if (auto Sym = CODLayer.findSymbol(Name, true))
- return Sym.toRuntimeDyldSymbol();
- if (auto Sym = CXXRuntimeOverrides.searchOverrides(Name))
- return Sym;
-
- if (auto Addr =
- RTDyldMemoryManager::getSymbolAddressInProcess(Name))
- return RuntimeDyld::SymbolInfo(Addr, JITSymbolFlags::Exported);
-
- return RuntimeDyld::SymbolInfo(nullptr);
- },
- [](const std::string &Name) {
- return RuntimeDyld::SymbolInfo(nullptr);
- }
- );
-
- // Add the module to the JIT.
- std::vector<std::unique_ptr<Module>> S;
- S.push_back(std::move(M));
- auto H = CODLayer.addModuleSet(std::move(S),
- llvm::make_unique<SectionMemoryManager>(),
- std::move(Resolver));
-
- // Run the static constructors, and save the static destructor runner for
- // execution when the JIT is torn down.
- orc::CtorDtorRunner<CODLayerT> CtorRunner(std::move(CtorNames), H);
- CtorRunner.runViaLayer(CODLayer);
-
- IRStaticDestructorRunners.emplace_back(std::move(DtorNames), H);
-
- return H;
- }
-
- orc::JITSymbol findSymbol(const std::string &Name) {
- return CODLayer.findSymbol(mangle(Name), true);
- }
-
- orc::JITSymbol findSymbolIn(ModuleHandleT H, const std::string &Name) {
- return CODLayer.findSymbolIn(H, mangle(Name), true);
- }
-
-private:
-
- std::string mangle(const std::string &Name) {
- std::string MangledName;
- {
- raw_string_ostream MangledNameStream(MangledName);
- Mangler::getNameWithPrefix(MangledNameStream, Name, DL);
- }
- return MangledName;
- }
-
- static std::set<Function*> extractSingleFunction(Function &F) {
- std::set<Function*> Partition;
- Partition.insert(&F);
- return Partition;
- }
-
- static TransformFtor createDebugDumper();
-
- std::unique_ptr<TargetMachine> TM;
- DataLayout DL;
- SectionMemoryManager CCMgrMemMgr;
-
- std::unique_ptr<CompileCallbackMgr> CCMgr;
- ObjLayerT ObjectLayer;
- CompileLayerT CompileLayer;
- IRDumpLayerT IRDumpLayer;
- CODLayerT CODLayer;
-
- orc::LocalCXXRuntimeOverrides CXXRuntimeOverrides;
- std::vector<orc::CtorDtorRunner<CODLayerT>> IRStaticDestructorRunners;
-};
-
-int runOrcLazyJIT(std::unique_ptr<Module> M, int ArgC, char* ArgV[]);
-
-} // end namespace llvm
-
-#endif
diff --git a/tools/lli/RemoteJITUtils.h b/tools/lli/RemoteJITUtils.h
deleted file mode 100644
index 15068d2..0000000
--- a/tools/lli/RemoteJITUtils.h
+++ /dev/null
@@ -1,152 +0,0 @@
-//===-- RemoteJITUtils.h - Utilities for remote-JITing with LLI -*- C++ -*-===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// Utilities for remote-JITing with LLI.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_TOOLS_LLI_REMOTEJITUTILS_H
-#define LLVM_TOOLS_LLI_REMOTEJITUTILS_H
-
-#include "llvm/ExecutionEngine/Orc/RPCChannel.h"
-#include "llvm/ExecutionEngine/RTDyldMemoryManager.h"
-#include <mutex>
-
-#if !defined(_MSC_VER) && !defined(__MINGW32__)
-#include <unistd.h>
-#else
-#include <io.h>
-#endif
-
-/// RPC channel that reads from and writes from file descriptors.
-class FDRPCChannel final : public llvm::orc::remote::RPCChannel {
-public:
- FDRPCChannel(int InFD, int OutFD) : InFD(InFD), OutFD(OutFD) {}
-
- llvm::Error readBytes(char *Dst, unsigned Size) override {
- assert(Dst && "Attempt to read into null.");
- ssize_t Completed = 0;
- while (Completed < static_cast<ssize_t>(Size)) {
- ssize_t Read = ::read(InFD, Dst + Completed, Size - Completed);
- if (Read <= 0) {
- auto ErrNo = errno;
- if (ErrNo == EAGAIN || ErrNo == EINTR)
- continue;
- else
- return llvm::errorCodeToError(
- std::error_code(errno, std::generic_category()));
- }
- Completed += Read;
- }
- return llvm::Error::success();
- }
-
- llvm::Error appendBytes(const char *Src, unsigned Size) override {
- assert(Src && "Attempt to append from null.");
- ssize_t Completed = 0;
- while (Completed < static_cast<ssize_t>(Size)) {
- ssize_t Written = ::write(OutFD, Src + Completed, Size - Completed);
- if (Written < 0) {
- auto ErrNo = errno;
- if (ErrNo == EAGAIN || ErrNo == EINTR)
- continue;
- else
- return llvm::errorCodeToError(
- std::error_code(errno, std::generic_category()));
- }
- Completed += Written;
- }
- return llvm::Error::success();
- }
-
- llvm::Error send() override { return llvm::Error::success(); }
-
-private:
- int InFD, OutFD;
-};
-
-// launch the remote process (see lli.cpp) and return a channel to it.
-std::unique_ptr<FDRPCChannel> launchRemote();
-
-namespace llvm {
-
-// ForwardingMM - Adapter to connect MCJIT to Orc's Remote memory manager.
-class ForwardingMemoryManager : public llvm::RTDyldMemoryManager {
-public:
- void setMemMgr(std::unique_ptr<RuntimeDyld::MemoryManager> MemMgr) {
- this->MemMgr = std::move(MemMgr);
- }
-
- void setResolver(std::unique_ptr<RuntimeDyld::SymbolResolver> Resolver) {
- this->Resolver = std::move(Resolver);
- }
-
- uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment,
- unsigned SectionID,
- StringRef SectionName) override {
- return MemMgr->allocateCodeSection(Size, Alignment, SectionID, SectionName);
- }
-
- uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment,
- unsigned SectionID, StringRef SectionName,
- bool IsReadOnly) override {
- return MemMgr->allocateDataSection(Size, Alignment, SectionID, SectionName,
- IsReadOnly);
- }
-
- void reserveAllocationSpace(uintptr_t CodeSize, uint32_t CodeAlign,
- uintptr_t RODataSize, uint32_t RODataAlign,
- uintptr_t RWDataSize,
- uint32_t RWDataAlign) override {
- MemMgr->reserveAllocationSpace(CodeSize, CodeAlign, RODataSize, RODataAlign,
- RWDataSize, RWDataAlign);
- }
-
- bool needsToReserveAllocationSpace() override {
- return MemMgr->needsToReserveAllocationSpace();
- }
-
- void registerEHFrames(uint8_t *Addr, uint64_t LoadAddr,
- size_t Size) override {
- MemMgr->registerEHFrames(Addr, LoadAddr, Size);
- }
-
- void deregisterEHFrames(uint8_t *Addr, uint64_t LoadAddr,
- size_t Size) override {
- MemMgr->deregisterEHFrames(Addr, LoadAddr, Size);
- }
-
- bool finalizeMemory(std::string *ErrMsg = nullptr) override {
- return MemMgr->finalizeMemory(ErrMsg);
- }
-
- void notifyObjectLoaded(RuntimeDyld &RTDyld,
- const object::ObjectFile &Obj) override {
- MemMgr->notifyObjectLoaded(RTDyld, Obj);
- }
-
- // Don't hide the sibling notifyObjectLoaded from RTDyldMemoryManager.
- using RTDyldMemoryManager::notifyObjectLoaded;
-
- RuntimeDyld::SymbolInfo findSymbol(const std::string &Name) override {
- return Resolver->findSymbol(Name);
- }
-
- RuntimeDyld::SymbolInfo
- findSymbolInLogicalDylib(const std::string &Name) override {
- return Resolver->findSymbolInLogicalDylib(Name);
- }
-
-private:
- std::unique_ptr<RuntimeDyld::MemoryManager> MemMgr;
- std::unique_ptr<RuntimeDyld::SymbolResolver> Resolver;
-};
-}
-
-#endif
diff --git a/tools/lli/lli.cpp b/tools/lli/lli.cpp
index 92de5da..7203af2 100644
--- a/tools/lli/lli.cpp
+++ b/tools/lli/lli.cpp
@@ -13,6 +13,8 @@
//
//===----------------------------------------------------------------------===//
+#if 0
+
#include "OrcLazyJIT.h"
#include "RemoteJITUtils.h"
#include "llvm/IR/LLVMContext.h"
@@ -751,3 +753,8 @@ std::unique_ptr<FDRPCChannel> launchRemote() {
return llvm::make_unique<FDRPCChannel>(PipeFD[1][0], PipeFD[0][1]);
#endif
}
+#endif
+
+int main(int argc, char **argv, char * const *envp) {
+ return 0;
+}
diff --git a/tools/llvm-cov/CodeCoverage.cpp b/tools/llvm-cov/CodeCoverage.cpp
index 0a4d1a6..8b13789 100644
--- a/tools/llvm-cov/CodeCoverage.cpp
+++ b/tools/llvm-cov/CodeCoverage.cpp
@@ -1,727 +1 @@
-//===- CodeCoverage.cpp - Coverage tool based on profiling instrumentation-===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// The 'CodeCoverageTool' class implements a command line tool to analyze and
-// report coverage information using the profiling instrumentation and code
-// coverage mapping.
-//
-//===----------------------------------------------------------------------===//
-#include "CoverageFilters.h"
-#include "CoverageReport.h"
-#include "CoverageViewOptions.h"
-#include "RenderingSupport.h"
-#include "SourceCoverageView.h"
-#include "llvm/ADT/SmallString.h"
-#include "llvm/ADT/StringRef.h"
-#include "llvm/ADT/Triple.h"
-#include "llvm/ProfileData/Coverage/CoverageMapping.h"
-#include "llvm/ProfileData/InstrProfReader.h"
-#include "llvm/Support/CommandLine.h"
-#include "llvm/Support/FileSystem.h"
-#include "llvm/Support/Format.h"
-#include "llvm/Support/MemoryBuffer.h"
-#include "llvm/Support/Path.h"
-#include "llvm/Support/Process.h"
-#include "llvm/Support/Program.h"
-#include "llvm/Support/ThreadPool.h"
-#include "llvm/Support/ToolOutputFile.h"
-#include <functional>
-#include <system_error>
-
-using namespace llvm;
-using namespace coverage;
-
-namespace {
-/// \brief The implementation of the coverage tool.
-class CodeCoverageTool {
-public:
- enum Command {
- /// \brief The show command.
- Show,
- /// \brief The report command.
- Report
- };
-
- /// \brief Print the error message to the error output stream.
- void error(const Twine &Message, StringRef Whence = "");
-
- /// \brief Record (but do not print) an error message in a thread-safe way.
- void deferError(const Twine &Message, StringRef Whence = "");
-
- /// \brief Record (but do not print) a warning message in a thread-safe way.
- void deferWarning(const Twine &Message, StringRef Whence = "");
-
- /// \brief Print (and then clear) all deferred error and warning messages.
- void consumeDeferredMessages();
-
- /// \brief Append a reference to a private copy of \p Path into SourceFiles.
- void addCollectedPath(const std::string &Path);
-
- /// \brief Return a memory buffer for the given source file.
- ErrorOr<const MemoryBuffer &> getSourceFile(StringRef SourceFile);
-
- /// \brief Create source views for the expansions of the view.
- void attachExpansionSubViews(SourceCoverageView &View,
- ArrayRef<ExpansionRecord> Expansions,
- const CoverageMapping &Coverage);
-
- /// \brief Create the source view of a particular function.
- std::unique_ptr<SourceCoverageView>
- createFunctionView(const FunctionRecord &Function,
- const CoverageMapping &Coverage);
-
- /// \brief Create the main source view of a particular source file.
- std::unique_ptr<SourceCoverageView>
- createSourceFileView(StringRef SourceFile, const CoverageMapping &Coverage);
-
- /// \brief Load the coverage mapping data. Return nullptr if an error occured.
- std::unique_ptr<CoverageMapping> load();
-
- /// \brief If a demangler is available, demangle all symbol names.
- void demangleSymbols(const CoverageMapping &Coverage);
-
- /// \brief Demangle \p Sym if possible. Otherwise, just return \p Sym.
- StringRef getSymbolForHumans(StringRef Sym) const;
-
- int run(Command Cmd, int argc, const char **argv);
-
- typedef llvm::function_ref<int(int, const char **)> CommandLineParserType;
-
- int show(int argc, const char **argv,
- CommandLineParserType commandLineParser);
-
- int report(int argc, const char **argv,
- CommandLineParserType commandLineParser);
-
- std::string ObjectFilename;
- CoverageViewOptions ViewOpts;
- std::string PGOFilename;
- CoverageFiltersMatchAll Filters;
- std::vector<StringRef> SourceFiles;
- bool CompareFilenamesOnly;
- StringMap<std::string> RemappedFilenames;
- std::string CoverageArch;
-
-private:
- /// A cache for demangled symbol names.
- StringMap<std::string> DemangledNames;
-
- /// File paths (absolute, or otherwise) to input source files.
- std::vector<std::string> CollectedPaths;
-
- /// Errors and warnings which have not been printed.
- std::mutex DeferredMessagesLock;
- std::vector<std::string> DeferredMessages;
-
- /// A container for input source file buffers.
- std::mutex LoadedSourceFilesLock;
- std::vector<std::pair<std::string, std::unique_ptr<MemoryBuffer>>>
- LoadedSourceFiles;
-};
-}
-
-static std::string getErrorString(const Twine &Message, StringRef Whence,
- bool Warning) {
- std::string Str = (Warning ? "warning" : "error");
- Str += ": ";
- if (!Whence.empty())
- Str += Whence.str() + ": ";
- Str += Message.str() + "\n";
- return Str;
-}
-
-void CodeCoverageTool::error(const Twine &Message, StringRef Whence) {
- errs() << getErrorString(Message, Whence, false);
-}
-
-void CodeCoverageTool::deferError(const Twine &Message, StringRef Whence) {
- std::unique_lock<std::mutex> Guard{DeferredMessagesLock};
- DeferredMessages.emplace_back(getErrorString(Message, Whence, false));
-}
-
-void CodeCoverageTool::deferWarning(const Twine &Message, StringRef Whence) {
- std::unique_lock<std::mutex> Guard{DeferredMessagesLock};
- DeferredMessages.emplace_back(getErrorString(Message, Whence, true));
-}
-
-void CodeCoverageTool::consumeDeferredMessages() {
- std::unique_lock<std::mutex> Guard{DeferredMessagesLock};
- for (const std::string &Message : DeferredMessages)
- ViewOpts.colored_ostream(errs(), raw_ostream::RED) << Message;
- DeferredMessages.clear();
-}
-
-void CodeCoverageTool::addCollectedPath(const std::string &Path) {
- CollectedPaths.push_back(Path);
- SourceFiles.emplace_back(CollectedPaths.back());
-}
-
-ErrorOr<const MemoryBuffer &>
-CodeCoverageTool::getSourceFile(StringRef SourceFile) {
- // If we've remapped filenames, look up the real location for this file.
- std::unique_lock<std::mutex> Guard{LoadedSourceFilesLock};
- if (!RemappedFilenames.empty()) {
- auto Loc = RemappedFilenames.find(SourceFile);
- if (Loc != RemappedFilenames.end())
- SourceFile = Loc->second;
- }
- for (const auto &Files : LoadedSourceFiles)
- if (sys::fs::equivalent(SourceFile, Files.first))
- return *Files.second;
- auto Buffer = MemoryBuffer::getFile(SourceFile);
- if (auto EC = Buffer.getError()) {
- deferError(EC.message(), SourceFile);
- return EC;
- }
- LoadedSourceFiles.emplace_back(SourceFile, std::move(Buffer.get()));
- return *LoadedSourceFiles.back().second;
-}
-
-void CodeCoverageTool::attachExpansionSubViews(
- SourceCoverageView &View, ArrayRef<ExpansionRecord> Expansions,
- const CoverageMapping &Coverage) {
- if (!ViewOpts.ShowExpandedRegions)
- return;
- for (const auto &Expansion : Expansions) {
- auto ExpansionCoverage = Coverage.getCoverageForExpansion(Expansion);
- if (ExpansionCoverage.empty())
- continue;
- auto SourceBuffer = getSourceFile(ExpansionCoverage.getFilename());
- if (!SourceBuffer)
- continue;
-
- auto SubViewExpansions = ExpansionCoverage.getExpansions();
- auto SubView =
- SourceCoverageView::create(Expansion.Function.Name, SourceBuffer.get(),
- ViewOpts, std::move(ExpansionCoverage));
- attachExpansionSubViews(*SubView, SubViewExpansions, Coverage);
- View.addExpansion(Expansion.Region, std::move(SubView));
- }
-}
-
-std::unique_ptr<SourceCoverageView>
-CodeCoverageTool::createFunctionView(const FunctionRecord &Function,
- const CoverageMapping &Coverage) {
- auto FunctionCoverage = Coverage.getCoverageForFunction(Function);
- if (FunctionCoverage.empty())
- return nullptr;
- auto SourceBuffer = getSourceFile(FunctionCoverage.getFilename());
- if (!SourceBuffer)
- return nullptr;
-
- auto Expansions = FunctionCoverage.getExpansions();
- auto View = SourceCoverageView::create(getSymbolForHumans(Function.Name),
- SourceBuffer.get(), ViewOpts,
- std::move(FunctionCoverage));
- attachExpansionSubViews(*View, Expansions, Coverage);
-
- return View;
-}
-
-std::unique_ptr<SourceCoverageView>
-CodeCoverageTool::createSourceFileView(StringRef SourceFile,
- const CoverageMapping &Coverage) {
- auto SourceBuffer = getSourceFile(SourceFile);
- if (!SourceBuffer)
- return nullptr;
- auto FileCoverage = Coverage.getCoverageForFile(SourceFile);
- if (FileCoverage.empty())
- return nullptr;
-
- auto Expansions = FileCoverage.getExpansions();
- auto View = SourceCoverageView::create(SourceFile, SourceBuffer.get(),
- ViewOpts, std::move(FileCoverage));
- attachExpansionSubViews(*View, Expansions, Coverage);
-
- for (const auto *Function : Coverage.getInstantiations(SourceFile)) {
- auto SubViewCoverage = Coverage.getCoverageForFunction(*Function);
- auto SubViewExpansions = SubViewCoverage.getExpansions();
- auto SubView = SourceCoverageView::create(
- getSymbolForHumans(Function->Name), SourceBuffer.get(), ViewOpts,
- std::move(SubViewCoverage));
- attachExpansionSubViews(*SubView, SubViewExpansions, Coverage);
-
- if (SubView) {
- unsigned FileID = Function->CountedRegions.front().FileID;
- unsigned Line = 0;
- for (const auto &CR : Function->CountedRegions)
- if (CR.FileID == FileID)
- Line = std::max(CR.LineEnd, Line);
- View->addInstantiation(Function->Name, Line, std::move(SubView));
- }
- }
- return View;
-}
-
-static bool modifiedTimeGT(StringRef LHS, StringRef RHS) {
- sys::fs::file_status Status;
- if (sys::fs::status(LHS, Status))
- return false;
- auto LHSTime = Status.getLastModificationTime();
- if (sys::fs::status(RHS, Status))
- return false;
- auto RHSTime = Status.getLastModificationTime();
- return LHSTime > RHSTime;
-}
-
-std::unique_ptr<CoverageMapping> CodeCoverageTool::load() {
- if (modifiedTimeGT(ObjectFilename, PGOFilename))
- errs() << "warning: profile data may be out of date - object is newer\n";
- auto CoverageOrErr = CoverageMapping::load(ObjectFilename, PGOFilename,
- CoverageArch);
- if (Error E = CoverageOrErr.takeError()) {
- colored_ostream(errs(), raw_ostream::RED)
- << "error: Failed to load coverage: " << toString(std::move(E)) << "\n";
- return nullptr;
- }
- auto Coverage = std::move(CoverageOrErr.get());
- unsigned Mismatched = Coverage->getMismatchedCount();
- if (Mismatched) {
- colored_ostream(errs(), raw_ostream::RED)
- << "warning: " << Mismatched << " functions have mismatched data. ";
- errs() << "\n";
- }
-
- if (CompareFilenamesOnly) {
- auto CoveredFiles = Coverage.get()->getUniqueSourceFiles();
- for (auto &SF : SourceFiles) {
- StringRef SFBase = sys::path::filename(SF);
- for (const auto &CF : CoveredFiles)
- if (SFBase == sys::path::filename(CF)) {
- RemappedFilenames[CF] = SF;
- SF = CF;
- break;
- }
- }
- }
-
- demangleSymbols(*Coverage);
-
- return Coverage;
-}
-
-void CodeCoverageTool::demangleSymbols(const CoverageMapping &Coverage) {
- if (!ViewOpts.hasDemangler())
- return;
-
- // Pass function names to the demangler in a temporary file.
- int InputFD;
- SmallString<256> InputPath;
- std::error_code EC =
- sys::fs::createTemporaryFile("demangle-in", "list", InputFD, InputPath);
- if (EC) {
- error(InputPath, EC.message());
- return;
- }
- tool_output_file InputTOF{InputPath, InputFD};
-
- unsigned NumSymbols = 0;
- for (const auto &Function : Coverage.getCoveredFunctions()) {
- InputTOF.os() << Function.Name << '\n';
- ++NumSymbols;
- }
- InputTOF.os().close();
-
- // Use another temporary file to store the demangler's output.
- int OutputFD;
- SmallString<256> OutputPath;
- EC = sys::fs::createTemporaryFile("demangle-out", "list", OutputFD,
- OutputPath);
- if (EC) {
- error(OutputPath, EC.message());
- return;
- }
- tool_output_file OutputTOF{OutputPath, OutputFD};
- OutputTOF.os().close();
-
- // Invoke the demangler.
- std::vector<const char *> ArgsV;
- for (const std::string &Arg : ViewOpts.DemanglerOpts)
- ArgsV.push_back(Arg.c_str());
- ArgsV.push_back(nullptr);
- StringRef InputPathRef = InputPath.str();
- StringRef OutputPathRef = OutputPath.str();
- StringRef StderrRef;
- const StringRef *Redirects[] = {&InputPathRef, &OutputPathRef, &StderrRef};
- std::string ErrMsg;
- int RC = sys::ExecuteAndWait(ViewOpts.DemanglerOpts[0], ArgsV.data(),
- /*env=*/nullptr, Redirects, /*secondsToWait=*/0,
- /*memoryLimit=*/0, &ErrMsg);
- if (RC) {
- error(ErrMsg, ViewOpts.DemanglerOpts[0]);
- return;
- }
-
- // Parse the demangler's output.
- auto BufOrError = MemoryBuffer::getFile(OutputPath);
- if (!BufOrError) {
- error(OutputPath, BufOrError.getError().message());
- return;
- }
-
- std::unique_ptr<MemoryBuffer> DemanglerBuf = std::move(*BufOrError);
-
- SmallVector<StringRef, 8> Symbols;
- StringRef DemanglerData = DemanglerBuf->getBuffer();
- DemanglerData.split(Symbols, '\n', /*MaxSplit=*/NumSymbols,
- /*KeepEmpty=*/false);
- if (Symbols.size() != NumSymbols) {
- error("Demangler did not provide expected number of symbols");
- return;
- }
-
- // Cache the demangled names.
- unsigned I = 0;
- for (const auto &Function : Coverage.getCoveredFunctions())
- DemangledNames[Function.Name] = Symbols[I++];
-}
-
-StringRef CodeCoverageTool::getSymbolForHumans(StringRef Sym) const {
- const auto DemangledName = DemangledNames.find(Sym);
- if (DemangledName == DemangledNames.end())
- return Sym;
- return DemangledName->getValue();
-}
-
-int CodeCoverageTool::run(Command Cmd, int argc, const char **argv) {
- cl::opt<std::string, true> ObjectFilename(
- cl::Positional, cl::Required, cl::location(this->ObjectFilename),
- cl::desc("Covered executable or object file."));
-
- cl::list<std::string> InputSourceFiles(
- cl::Positional, cl::desc("<Source files>"), cl::ZeroOrMore);
-
- cl::opt<std::string, true> PGOFilename(
- "instr-profile", cl::Required, cl::location(this->PGOFilename),
- cl::desc(
- "File with the profile data obtained after an instrumented run"));
-
- cl::opt<std::string> Arch(
- "arch", cl::desc("architecture of the coverage mapping binary"));
-
- cl::opt<bool> DebugDump("dump", cl::Optional,
- cl::desc("Show internal debug dump"));
-
- cl::opt<CoverageViewOptions::OutputFormat> Format(
- "format", cl::desc("Output format for line-based coverage reports"),
- cl::values(clEnumValN(CoverageViewOptions::OutputFormat::Text, "text",
- "Text output"),
- clEnumValN(CoverageViewOptions::OutputFormat::HTML, "html",
- "HTML output"),
- clEnumValEnd),
- cl::init(CoverageViewOptions::OutputFormat::Text));
-
- cl::opt<bool> FilenameEquivalence(
- "filename-equivalence", cl::Optional,
- cl::desc("Treat source files as equivalent to paths in the coverage data "
- "when the file names match, even if the full paths do not"));
-
- cl::OptionCategory FilteringCategory("Function filtering options");
-
- cl::list<std::string> NameFilters(
- "name", cl::Optional,
- cl::desc("Show code coverage only for functions with the given name"),
- cl::ZeroOrMore, cl::cat(FilteringCategory));
-
- cl::list<std::string> NameRegexFilters(
- "name-regex", cl::Optional,
- cl::desc("Show code coverage only for functions that match the given "
- "regular expression"),
- cl::ZeroOrMore, cl::cat(FilteringCategory));
-
- cl::opt<double> RegionCoverageLtFilter(
- "region-coverage-lt", cl::Optional,
- cl::desc("Show code coverage only for functions with region coverage "
- "less than the given threshold"),
- cl::cat(FilteringCategory));
-
- cl::opt<double> RegionCoverageGtFilter(
- "region-coverage-gt", cl::Optional,
- cl::desc("Show code coverage only for functions with region coverage "
- "greater than the given threshold"),
- cl::cat(FilteringCategory));
-
- cl::opt<double> LineCoverageLtFilter(
- "line-coverage-lt", cl::Optional,
- cl::desc("Show code coverage only for functions with line coverage less "
- "than the given threshold"),
- cl::cat(FilteringCategory));
-
- cl::opt<double> LineCoverageGtFilter(
- "line-coverage-gt", cl::Optional,
- cl::desc("Show code coverage only for functions with line coverage "
- "greater than the given threshold"),
- cl::cat(FilteringCategory));
-
- cl::opt<cl::boolOrDefault> UseColor(
- "use-color", cl::desc("Emit colored output (default=autodetect)"),
- cl::init(cl::BOU_UNSET));
-
- cl::list<std::string> DemanglerOpts(
- "Xdemangler", cl::desc("<demangler-path>|<demangler-option>"));
-
- auto commandLineParser = [&, this](int argc, const char **argv) -> int {
- cl::ParseCommandLineOptions(argc, argv, "LLVM code coverage tool\n");
- ViewOpts.Debug = DebugDump;
- CompareFilenamesOnly = FilenameEquivalence;
-
- ViewOpts.Format = Format;
- switch (ViewOpts.Format) {
- case CoverageViewOptions::OutputFormat::Text:
- ViewOpts.Colors = UseColor == cl::BOU_UNSET
- ? sys::Process::StandardOutHasColors()
- : UseColor == cl::BOU_TRUE;
- break;
- case CoverageViewOptions::OutputFormat::HTML:
- if (UseColor == cl::BOU_FALSE)
- error("Color output cannot be disabled when generating html.");
- ViewOpts.Colors = true;
- break;
- }
-
- // If a demangler is supplied, check if it exists and register it.
- if (DemanglerOpts.size()) {
- auto DemanglerPathOrErr = sys::findProgramByName(DemanglerOpts[0]);
- if (!DemanglerPathOrErr) {
- error("Could not find the demangler!",
- DemanglerPathOrErr.getError().message());
- return 1;
- }
- DemanglerOpts[0] = *DemanglerPathOrErr;
- ViewOpts.DemanglerOpts.swap(DemanglerOpts);
- }
-
- // Create the function filters
- if (!NameFilters.empty() || !NameRegexFilters.empty()) {
- auto NameFilterer = new CoverageFilters;
- for (const auto &Name : NameFilters)
- NameFilterer->push_back(llvm::make_unique<NameCoverageFilter>(Name));
- for (const auto &Regex : NameRegexFilters)
- NameFilterer->push_back(
- llvm::make_unique<NameRegexCoverageFilter>(Regex));
- Filters.push_back(std::unique_ptr<CoverageFilter>(NameFilterer));
- }
- if (RegionCoverageLtFilter.getNumOccurrences() ||
- RegionCoverageGtFilter.getNumOccurrences() ||
- LineCoverageLtFilter.getNumOccurrences() ||
- LineCoverageGtFilter.getNumOccurrences()) {
- auto StatFilterer = new CoverageFilters;
- if (RegionCoverageLtFilter.getNumOccurrences())
- StatFilterer->push_back(llvm::make_unique<RegionCoverageFilter>(
- RegionCoverageFilter::LessThan, RegionCoverageLtFilter));
- if (RegionCoverageGtFilter.getNumOccurrences())
- StatFilterer->push_back(llvm::make_unique<RegionCoverageFilter>(
- RegionCoverageFilter::GreaterThan, RegionCoverageGtFilter));
- if (LineCoverageLtFilter.getNumOccurrences())
- StatFilterer->push_back(llvm::make_unique<LineCoverageFilter>(
- LineCoverageFilter::LessThan, LineCoverageLtFilter));
- if (LineCoverageGtFilter.getNumOccurrences())
- StatFilterer->push_back(llvm::make_unique<LineCoverageFilter>(
- RegionCoverageFilter::GreaterThan, LineCoverageGtFilter));
- Filters.push_back(std::unique_ptr<CoverageFilter>(StatFilterer));
- }
-
- if (!Arch.empty() &&
- Triple(Arch).getArch() == llvm::Triple::ArchType::UnknownArch) {
- errs() << "error: Unknown architecture: " << Arch << "\n";
- return 1;
- }
- CoverageArch = Arch;
-
- for (const auto &File : InputSourceFiles) {
- SmallString<128> Path(File);
- if (!CompareFilenamesOnly)
- if (std::error_code EC = sys::fs::make_absolute(Path)) {
- errs() << "error: " << File << ": " << EC.message();
- return 1;
- }
- addCollectedPath(Path.str());
- }
- return 0;
- };
-
- switch (Cmd) {
- case Show:
- return show(argc, argv, commandLineParser);
- case Report:
- return report(argc, argv, commandLineParser);
- }
- return 0;
-}
-
-int CodeCoverageTool::show(int argc, const char **argv,
- CommandLineParserType commandLineParser) {
-
- cl::OptionCategory ViewCategory("Viewing options");
-
- cl::opt<bool> ShowLineExecutionCounts(
- "show-line-counts", cl::Optional,
- cl::desc("Show the execution counts for each line"), cl::init(true),
- cl::cat(ViewCategory));
-
- cl::opt<bool> ShowRegions(
- "show-regions", cl::Optional,
- cl::desc("Show the execution counts for each region"),
- cl::cat(ViewCategory));
-
- cl::opt<bool> ShowBestLineRegionsCounts(
- "show-line-counts-or-regions", cl::Optional,
- cl::desc("Show the execution counts for each line, or the execution "
- "counts for each region on lines that have multiple regions"),
- cl::cat(ViewCategory));
-
- cl::opt<bool> ShowExpansions("show-expansions", cl::Optional,
- cl::desc("Show expanded source regions"),
- cl::cat(ViewCategory));
-
- cl::opt<bool> ShowInstantiations("show-instantiations", cl::Optional,
- cl::desc("Show function instantiations"),
- cl::cat(ViewCategory));
-
- cl::opt<std::string> ShowOutputDirectory(
- "output-dir", cl::init(""),
- cl::desc("Directory in which coverage information is written out"));
- cl::alias ShowOutputDirectoryA("o", cl::desc("Alias for --output-dir"),
- cl::aliasopt(ShowOutputDirectory));
-
- auto Err = commandLineParser(argc, argv);
- if (Err)
- return Err;
-
- ViewOpts.ShowLineNumbers = true;
- ViewOpts.ShowLineStats = ShowLineExecutionCounts.getNumOccurrences() != 0 ||
- !ShowRegions || ShowBestLineRegionsCounts;
- ViewOpts.ShowRegionMarkers = ShowRegions || ShowBestLineRegionsCounts;
- ViewOpts.ShowLineStatsOrRegionMarkers = ShowBestLineRegionsCounts;
- ViewOpts.ShowExpandedRegions = ShowExpansions;
- ViewOpts.ShowFunctionInstantiations = ShowInstantiations;
- ViewOpts.ShowOutputDirectory = ShowOutputDirectory;
-
- if (ViewOpts.hasOutputDirectory()) {
- if (auto E = sys::fs::create_directories(ViewOpts.ShowOutputDirectory)) {
- error("Could not create output directory!", E.message());
- return 1;
- }
- }
-
- auto Coverage = load();
- if (!Coverage)
- return 1;
-
- auto Printer = CoveragePrinter::create(ViewOpts);
-
- if (!Filters.empty()) {
- auto OSOrErr = Printer->createViewFile("functions", /*InToplevel=*/true);
- if (Error E = OSOrErr.takeError()) {
- error("Could not create view file!", toString(std::move(E)));
- return 1;
- }
- auto OS = std::move(OSOrErr.get());
-
- // Show functions.
- for (const auto &Function : Coverage->getCoveredFunctions()) {
- if (!Filters.matches(Function))
- continue;
-
- auto mainView = createFunctionView(Function, *Coverage);
- if (!mainView) {
- ViewOpts.colored_ostream(errs(), raw_ostream::RED)
- << "warning: Could not read coverage for '" << Function.Name << "'."
- << "\n";
- continue;
- }
-
- mainView->print(*OS.get(), /*WholeFile=*/false, /*ShowSourceName=*/true);
- }
-
- Printer->closeViewFile(std::move(OS));
- return 0;
- }
-
- // Show files
- bool ShowFilenames = SourceFiles.size() != 1;
-
- if (SourceFiles.empty())
- // Get the source files from the function coverage mapping.
- for (StringRef Filename : Coverage->getUniqueSourceFiles())
- SourceFiles.push_back(Filename);
-
- // Create an index out of the source files.
- if (ViewOpts.hasOutputDirectory()) {
- if (Error E = Printer->createIndexFile(SourceFiles)) {
- error("Could not create index file!", toString(std::move(E)));
- return 1;
- }
- }
-
- // In -output-dir mode, it's safe to use multiple threads to print files.
- unsigned ThreadCount = 1;
- if (ViewOpts.hasOutputDirectory())
- ThreadCount = std::thread::hardware_concurrency();
- ThreadPool Pool(ThreadCount);
-
- for (StringRef SourceFile : SourceFiles) {
- Pool.async([this, SourceFile, &Coverage, &Printer, ShowFilenames] {
- auto View = createSourceFileView(SourceFile, *Coverage);
- if (!View) {
- deferWarning("The file '" + SourceFile.str() + "' isn't covered.");
- return;
- }
-
- auto OSOrErr = Printer->createViewFile(SourceFile, /*InToplevel=*/false);
- if (Error E = OSOrErr.takeError()) {
- deferError("Could not create view file!", toString(std::move(E)));
- return;
- }
- auto OS = std::move(OSOrErr.get());
-
- View->print(*OS.get(), /*Wholefile=*/true,
- /*ShowSourceName=*/ShowFilenames);
- Printer->closeViewFile(std::move(OS));
- });
- }
-
- Pool.wait();
-
- consumeDeferredMessages();
-
- return 0;
-}
-
-int CodeCoverageTool::report(int argc, const char **argv,
- CommandLineParserType commandLineParser) {
- auto Err = commandLineParser(argc, argv);
- if (Err)
- return Err;
-
- if (ViewOpts.Format == CoverageViewOptions::OutputFormat::HTML)
- error("HTML output for summary reports is not yet supported.");
-
- auto Coverage = load();
- if (!Coverage)
- return 1;
-
- CoverageReport Report(ViewOpts, std::move(Coverage));
- if (SourceFiles.empty())
- Report.renderFileReports(llvm::outs());
- else
- Report.renderFunctionReports(SourceFiles, llvm::outs());
- return 0;
-}
-
-int showMain(int argc, const char *argv[]) {
- CodeCoverageTool Tool;
- return Tool.run(CodeCoverageTool::Show, argc, argv);
-}
-
-int reportMain(int argc, const char *argv[]) {
- CodeCoverageTool Tool;
- return Tool.run(CodeCoverageTool::Report, argc, argv);
-}
diff --git a/tools/llvm-cov/CoverageFilters.cpp b/tools/llvm-cov/CoverageFilters.cpp
index 325dd72..8b13789 100644
--- a/tools/llvm-cov/CoverageFilters.cpp
+++ b/tools/llvm-cov/CoverageFilters.cpp
@@ -1,59 +1 @@
-//===- CoverageFilters.cpp - Function coverage mapping filters ------------===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// These classes provide filtering for function coverage mapping records.
-//
-//===----------------------------------------------------------------------===//
-#include "CoverageFilters.h"
-#include "CoverageSummaryInfo.h"
-#include "llvm/Support/Regex.h"
-
-using namespace llvm;
-
-bool NameCoverageFilter::matches(const coverage::FunctionRecord &Function) {
- StringRef FuncName = Function.Name;
- return FuncName.find(Name) != StringRef::npos;
-}
-
-bool
-NameRegexCoverageFilter::matches(const coverage::FunctionRecord &Function) {
- return llvm::Regex(Regex).match(Function.Name);
-}
-
-bool RegionCoverageFilter::matches(const coverage::FunctionRecord &Function) {
- return PassesThreshold(FunctionCoverageSummary::get(Function)
- .RegionCoverage.getPercentCovered());
-}
-
-bool LineCoverageFilter::matches(const coverage::FunctionRecord &Function) {
- return PassesThreshold(
- FunctionCoverageSummary::get(Function).LineCoverage.getPercentCovered());
-}
-
-void CoverageFilters::push_back(std::unique_ptr<CoverageFilter> Filter) {
- Filters.push_back(std::move(Filter));
-}
-
-bool CoverageFilters::matches(const coverage::FunctionRecord &Function) {
- for (const auto &Filter : Filters) {
- if (Filter->matches(Function))
- return true;
- }
- return false;
-}
-
-bool
-CoverageFiltersMatchAll::matches(const coverage::FunctionRecord &Function) {
- for (const auto &Filter : Filters) {
- if (!Filter->matches(Function))
- return false;
- }
- return true;
-}
diff --git a/tools/llvm-cov/CoverageFilters.h b/tools/llvm-cov/CoverageFilters.h
deleted file mode 100644
index 756c4b4..0000000
--- a/tools/llvm-cov/CoverageFilters.h
+++ /dev/null
@@ -1,127 +0,0 @@
-//===- CoverageFilters.h - Function coverage mapping filters --------------===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// These classes provide filtering for function coverage mapping records.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_COV_COVERAGEFILTERS_H
-#define LLVM_COV_COVERAGEFILTERS_H
-
-#include "llvm/ProfileData/Coverage/CoverageMapping.h"
-#include <memory>
-#include <vector>
-
-namespace llvm {
-
-/// \brief Matches specific functions that pass the requirement of this filter.
-class CoverageFilter {
-public:
- virtual ~CoverageFilter() {}
-
- /// \brief Return true if the function passes the requirements of this filter.
- virtual bool matches(const coverage::FunctionRecord &Function) {
- return true;
- }
-};
-
-/// \brief Matches functions that contain a specific string in their name.
-class NameCoverageFilter : public CoverageFilter {
- StringRef Name;
-
-public:
- NameCoverageFilter(StringRef Name) : Name(Name) {}
-
- bool matches(const coverage::FunctionRecord &Function) override;
-};
-
-/// \brief Matches functions whose name matches a certain regular expression.
-class NameRegexCoverageFilter : public CoverageFilter {
- StringRef Regex;
-
-public:
- NameRegexCoverageFilter(StringRef Regex) : Regex(Regex) {}
-
- bool matches(const coverage::FunctionRecord &Function) override;
-};
-
-/// \brief Matches numbers that pass a certain threshold.
-template <typename T> class StatisticThresholdFilter {
-public:
- enum Operation { LessThan, GreaterThan };
-
-protected:
- Operation Op;
- T Threshold;
-
- StatisticThresholdFilter(Operation Op, T Threshold)
- : Op(Op), Threshold(Threshold) {}
-
- /// \brief Return true if the given number is less than
- /// or greater than the certain threshold.
- bool PassesThreshold(T Value) const {
- switch (Op) {
- case LessThan:
- return Value < Threshold;
- case GreaterThan:
- return Value > Threshold;
- }
- return false;
- }
-};
-
-/// \brief Matches functions whose region coverage percentage
-/// is above/below a certain percentage.
-class RegionCoverageFilter : public CoverageFilter,
- public StatisticThresholdFilter<double> {
-public:
- RegionCoverageFilter(Operation Op, double Threshold)
- : StatisticThresholdFilter(Op, Threshold) {}
-
- bool matches(const coverage::FunctionRecord &Function) override;
-};
-
-/// \brief Matches functions whose line coverage percentage
-/// is above/below a certain percentage.
-class LineCoverageFilter : public CoverageFilter,
- public StatisticThresholdFilter<double> {
-public:
- LineCoverageFilter(Operation Op, double Threshold)
- : StatisticThresholdFilter(Op, Threshold) {}
-
- bool matches(const coverage::FunctionRecord &Function) override;
-};
-
-/// \brief A collection of filters.
-/// Matches functions that match any filters contained
-/// in an instance of this class.
-class CoverageFilters : public CoverageFilter {
-protected:
- std::vector<std::unique_ptr<CoverageFilter>> Filters;
-
-public:
- /// \brief Append a filter to this collection.
- void push_back(std::unique_ptr<CoverageFilter> Filter);
-
- bool empty() const { return Filters.empty(); }
-
- bool matches(const coverage::FunctionRecord &Function) override;
-};
-
-/// \brief A collection of filters.
-/// Matches functions that match all of the filters contained
-/// in an instance of this class.
-class CoverageFiltersMatchAll : public CoverageFilters {
-public:
- bool matches(const coverage::FunctionRecord &Function) override;
-};
-
-} // namespace llvm
-
-#endif // LLVM_COV_COVERAGEFILTERS_H
diff --git a/tools/llvm-cov/CoverageReport.cpp b/tools/llvm-cov/CoverageReport.cpp
index 10e53b3..8b13789 100644
--- a/tools/llvm-cov/CoverageReport.cpp
+++ b/tools/llvm-cov/CoverageReport.cpp
@@ -1,235 +1 @@
-//===- CoverageReport.cpp - Code coverage report -------------------------===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This class implements rendering of a code coverage report.
-//
-//===----------------------------------------------------------------------===//
-#include "CoverageReport.h"
-#include "RenderingSupport.h"
-#include "llvm/Support/FileSystem.h"
-#include "llvm/Support/Format.h"
-
-using namespace llvm;
-namespace {
-/// \brief Helper struct which prints trimmed and aligned columns.
-struct Column {
- enum TrimKind { NoTrim, WidthTrim, LeftTrim, RightTrim };
-
- enum AlignmentKind { LeftAlignment, RightAlignment };
-
- StringRef Str;
- unsigned Width;
- TrimKind Trim;
- AlignmentKind Alignment;
-
- Column(StringRef Str, unsigned Width)
- : Str(Str), Width(Width), Trim(WidthTrim), Alignment(LeftAlignment) {}
-
- Column &set(TrimKind Value) {
- Trim = Value;
- return *this;
- }
-
- Column &set(AlignmentKind Value) {
- Alignment = Value;
- return *this;
- }
-
- void render(raw_ostream &OS) const;
-};
-
-raw_ostream &operator<<(raw_ostream &OS, const Column &Value) {
- Value.render(OS);
- return OS;
-}
-}
-
-void Column::render(raw_ostream &OS) const {
- if (Str.size() <= Width) {
- if (Alignment == RightAlignment) {
- OS.indent(Width - Str.size());
- OS << Str;
- return;
- }
- OS << Str;
- OS.indent(Width - Str.size());
- return;
- }
-
- switch (Trim) {
- case NoTrim:
- OS << Str;
- break;
- case WidthTrim:
- OS << Str.substr(0, Width);
- break;
- case LeftTrim:
- OS << "..." << Str.substr(Str.size() - Width + 3);
- break;
- case RightTrim:
- OS << Str.substr(0, Width - 3) << "...";
- break;
- }
-}
-
-static Column column(StringRef Str, unsigned Width) {
- return Column(Str, Width);
-}
-
-template <typename T>
-static Column column(StringRef Str, unsigned Width, const T &Value) {
- return Column(Str, Width).set(Value);
-}
-
-static size_t FileReportColumns[] = {25, 10, 8, 8, 10, 10};
-static size_t FunctionReportColumns[] = {25, 10, 8, 8, 10, 8, 8};
-
-/// \brief Adjust column widths to fit long file paths and function names.
-static void adjustColumnWidths(coverage::CoverageMapping *CM) {
- for (StringRef Filename : CM->getUniqueSourceFiles()) {
- FileReportColumns[0] = std::max(FileReportColumns[0], Filename.size());
- for (const auto &F : CM->getCoveredFunctions(Filename)) {
- FunctionReportColumns[0] =
- std::max(FunctionReportColumns[0], F.Name.size());
- }
- }
-}
-
-/// \brief Prints a horizontal divider which spans across the given columns.
-template <typename T, size_t N>
-static void renderDivider(T (&Columns)[N], raw_ostream &OS) {
- unsigned Length = 0;
- for (unsigned I = 0; I < N; ++I)
- Length += Columns[I];
- for (unsigned I = 0; I < Length; ++I)
- OS << '-';
-}
-
-/// \brief Return the color which correponds to the coverage
-/// percentage of a certain metric.
-template <typename T>
-static raw_ostream::Colors determineCoveragePercentageColor(const T &Info) {
- if (Info.isFullyCovered())
- return raw_ostream::GREEN;
- return Info.getPercentCovered() >= 80.0 ? raw_ostream::YELLOW
- : raw_ostream::RED;
-}
-
-void CoverageReport::render(const FileCoverageSummary &File, raw_ostream &OS) {
- OS << column(File.Name, FileReportColumns[0], Column::NoTrim)
- << format("%*u", FileReportColumns[1],
- (unsigned)File.RegionCoverage.NumRegions);
- Options.colored_ostream(OS, File.RegionCoverage.isFullyCovered()
- ? raw_ostream::GREEN
- : raw_ostream::RED)
- << format("%*u", FileReportColumns[2], (unsigned)File.RegionCoverage.NotCovered);
- Options.colored_ostream(OS,
- determineCoveragePercentageColor(File.RegionCoverage))
- << format("%*.2f", FileReportColumns[3] - 1,
- File.RegionCoverage.getPercentCovered()) << '%';
- OS << format("%*u", FileReportColumns[4],
- (unsigned)File.FunctionCoverage.NumFunctions);
- Options.colored_ostream(
- OS, determineCoveragePercentageColor(File.FunctionCoverage))
- << format("%*.2f", FileReportColumns[5] - 1,
- File.FunctionCoverage.getPercentCovered()) << '%';
- OS << "\n";
-}
-
-void CoverageReport::render(const FunctionCoverageSummary &Function,
- raw_ostream &OS) {
- OS << column(Function.Name, FunctionReportColumns[0], Column::RightTrim)
- << format("%*u", FunctionReportColumns[1],
- (unsigned)Function.RegionCoverage.NumRegions);
- Options.colored_ostream(OS, Function.RegionCoverage.isFullyCovered()
- ? raw_ostream::GREEN
- : raw_ostream::RED)
- << format("%*u", FunctionReportColumns[2],
- (unsigned)Function.RegionCoverage.NotCovered);
- Options.colored_ostream(
- OS, determineCoveragePercentageColor(Function.RegionCoverage))
- << format("%*.2f", FunctionReportColumns[3] - 1,
- Function.RegionCoverage.getPercentCovered()) << '%';
- OS << format("%*u", FunctionReportColumns[4],
- (unsigned)Function.LineCoverage.NumLines);
- Options.colored_ostream(OS, Function.LineCoverage.isFullyCovered()
- ? raw_ostream::GREEN
- : raw_ostream::RED)
- << format("%*u", FunctionReportColumns[5],
- (unsigned)Function.LineCoverage.NotCovered);
- Options.colored_ostream(
- OS, determineCoveragePercentageColor(Function.LineCoverage))
- << format("%*.2f", FunctionReportColumns[6] - 1,
- Function.LineCoverage.getPercentCovered()) << '%';
- OS << "\n";
-}
-
-void CoverageReport::renderFunctionReports(ArrayRef<StringRef> Files,
- raw_ostream &OS) {
- adjustColumnWidths(Coverage.get());
- bool isFirst = true;
- for (StringRef Filename : Files) {
- if (isFirst)
- isFirst = false;
- else
- OS << "\n";
- OS << "File '" << Filename << "':\n";
- OS << column("Name", FunctionReportColumns[0])
- << column("Regions", FunctionReportColumns[1], Column::RightAlignment)
- << column("Miss", FunctionReportColumns[2], Column::RightAlignment)
- << column("Cover", FunctionReportColumns[3], Column::RightAlignment)
- << column("Lines", FunctionReportColumns[4], Column::RightAlignment)
- << column("Miss", FunctionReportColumns[5], Column::RightAlignment)
- << column("Cover", FunctionReportColumns[6], Column::RightAlignment);
- OS << "\n";
- renderDivider(FunctionReportColumns, OS);
- OS << "\n";
- FunctionCoverageSummary Totals("TOTAL");
- for (const auto &F : Coverage->getCoveredFunctions(Filename)) {
- FunctionCoverageSummary Function = FunctionCoverageSummary::get(F);
- ++Totals.ExecutionCount;
- Totals.RegionCoverage += Function.RegionCoverage;
- Totals.LineCoverage += Function.LineCoverage;
- render(Function, OS);
- }
- if (Totals.ExecutionCount) {
- renderDivider(FunctionReportColumns, OS);
- OS << "\n";
- render(Totals, OS);
- }
- }
-}
-
-void CoverageReport::renderFileReports(raw_ostream &OS) {
- adjustColumnWidths(Coverage.get());
- OS << column("Filename", FileReportColumns[0])
- << column("Regions", FileReportColumns[1], Column::RightAlignment)
- << column("Miss", FileReportColumns[2], Column::RightAlignment)
- << column("Cover", FileReportColumns[3], Column::RightAlignment)
- << column("Functions", FileReportColumns[4], Column::RightAlignment)
- << column("Executed", FileReportColumns[5], Column::RightAlignment)
- << "\n";
- renderDivider(FileReportColumns, OS);
- OS << "\n";
-
- FileCoverageSummary Totals("TOTAL");
- for (StringRef Filename : Coverage->getUniqueSourceFiles()) {
- FileCoverageSummary Summary(Filename);
- for (const auto &F : Coverage->getCoveredFunctions(Filename)) {
- FunctionCoverageSummary Function = FunctionCoverageSummary::get(F);
- Summary.addFunction(Function);
- Totals.addFunction(Function);
- }
- render(Summary, OS);
- }
- renderDivider(FileReportColumns, OS);
- OS << "\n";
- render(Totals, OS);
-}
diff --git a/tools/llvm-cov/CoverageReport.h b/tools/llvm-cov/CoverageReport.h
deleted file mode 100644
index bb3d734..0000000
--- a/tools/llvm-cov/CoverageReport.h
+++ /dev/null
@@ -1,41 +0,0 @@
-//===- CoverageReport.h - Code coverage report ---------------------------===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This class implements rendering of a code coverage report.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_COV_COVERAGEREPORT_H
-#define LLVM_COV_COVERAGEREPORT_H
-
-#include "CoverageSummaryInfo.h"
-#include "CoverageViewOptions.h"
-
-namespace llvm {
-
-/// \brief Displays the code coverage report.
-class CoverageReport {
- const CoverageViewOptions &Options;
- std::unique_ptr<coverage::CoverageMapping> Coverage;
-
- void render(const FileCoverageSummary &File, raw_ostream &OS);
- void render(const FunctionCoverageSummary &Function, raw_ostream &OS);
-
-public:
- CoverageReport(const CoverageViewOptions &Options,
- std::unique_ptr<coverage::CoverageMapping> Coverage)
- : Options(Options), Coverage(std::move(Coverage)) {}
-
- void renderFunctionReports(ArrayRef<StringRef> Files, raw_ostream &OS);
-
- void renderFileReports(raw_ostream &OS);
-};
-}
-
-#endif // LLVM_COV_COVERAGEREPORT_H
diff --git a/tools/llvm-cov/CoverageSummaryInfo.cpp b/tools/llvm-cov/CoverageSummaryInfo.cpp
index de89750..8b13789 100644
--- a/tools/llvm-cov/CoverageSummaryInfo.cpp
+++ b/tools/llvm-cov/CoverageSummaryInfo.cpp
@@ -1,71 +1 @@
-//===- CoverageSummaryInfo.cpp - Coverage summary for function/file -------===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// These structures are used to represent code coverage metrics
-// for functions/files.
-//
-//===----------------------------------------------------------------------===//
-#include "CoverageSummaryInfo.h"
-
-using namespace llvm;
-using namespace coverage;
-
-FunctionCoverageSummary
-FunctionCoverageSummary::get(const coverage::FunctionRecord &Function) {
- // Compute the region coverage
- size_t NumCodeRegions = 0, CoveredRegions = 0;
- for (auto &CR : Function.CountedRegions) {
- if (CR.Kind != CounterMappingRegion::CodeRegion)
- continue;
- ++NumCodeRegions;
- if (CR.ExecutionCount != 0)
- ++CoveredRegions;
- }
-
- // Compute the line coverage
- size_t NumLines = 0, CoveredLines = 0;
- for (unsigned FileID = 0, E = Function.Filenames.size(); FileID < E;
- ++FileID) {
- // Find the line start and end of the function's source code
- // in that particular file
- unsigned LineStart = std::numeric_limits<unsigned>::max();
- unsigned LineEnd = 0;
- for (auto &CR : Function.CountedRegions) {
- if (CR.FileID != FileID)
- continue;
- LineStart = std::min(LineStart, CR.LineStart);
- LineEnd = std::max(LineEnd, CR.LineEnd);
- }
- unsigned LineCount = LineEnd - LineStart + 1;
-
- // Get counters
- llvm::SmallVector<uint64_t, 16> ExecutionCounts;
- ExecutionCounts.resize(LineCount, 0);
- for (auto &CR : Function.CountedRegions) {
- if (CR.FileID != FileID)
- continue;
- // Ignore the lines that were skipped by the preprocessor.
- auto ExecutionCount = CR.ExecutionCount;
- if (CR.Kind == CounterMappingRegion::SkippedRegion) {
- LineCount -= CR.LineEnd - CR.LineStart + 1;
- ExecutionCount = 1;
- }
- for (unsigned I = CR.LineStart; I <= CR.LineEnd; ++I)
- ExecutionCounts[I - LineStart] = ExecutionCount;
- }
- CoveredLines += LineCount - std::count(ExecutionCounts.begin(),
- ExecutionCounts.end(), 0);
- NumLines += LineCount;
- }
- return FunctionCoverageSummary(
- Function.Name, Function.ExecutionCount,
- RegionCoverageInfo(CoveredRegions, NumCodeRegions),
- LineCoverageInfo(CoveredLines, 0, NumLines));
-}
diff --git a/tools/llvm-cov/CoverageSummaryInfo.h b/tools/llvm-cov/CoverageSummaryInfo.h
deleted file mode 100644
index 822742b..0000000
--- a/tools/llvm-cov/CoverageSummaryInfo.h
+++ /dev/null
@@ -1,162 +0,0 @@
-//===- CoverageSummaryInfo.h - Coverage summary for function/file ---------===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// These structures are used to represent code coverage metrics
-// for functions/files.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_COV_COVERAGESUMMARYINFO_H
-#define LLVM_COV_COVERAGESUMMARYINFO_H
-
-#include "llvm/ProfileData/Coverage/CoverageMapping.h"
-#include "llvm/Support/raw_ostream.h"
-
-namespace llvm {
-
-/// \brief Provides information about region coverage for a function/file.
-struct RegionCoverageInfo {
- /// \brief The number of regions that were executed at least once.
- size_t Covered;
-
- /// \brief The number of regions that weren't executed.
- size_t NotCovered;
-
- /// \brief The total number of regions in a function/file.
- size_t NumRegions;
-
- RegionCoverageInfo() : Covered(0), NotCovered(0), NumRegions(0) {}
-
- RegionCoverageInfo(size_t Covered, size_t NumRegions)
- : Covered(Covered), NotCovered(NumRegions - Covered),
- NumRegions(NumRegions) {}
-
- RegionCoverageInfo &operator+=(const RegionCoverageInfo &RHS) {
- Covered += RHS.Covered;
- NotCovered += RHS.NotCovered;
- NumRegions += RHS.NumRegions;
- return *this;
- }
-
- bool isFullyCovered() const { return Covered == NumRegions; }
-
- double getPercentCovered() const {
- if (NumRegions == 0)
- return 0.0;
- return double(Covered) / double(NumRegions) * 100.0;
- }
-};
-
-/// \brief Provides information about line coverage for a function/file.
-struct LineCoverageInfo {
- /// \brief The number of lines that were executed at least once.
- size_t Covered;
-
- /// \brief The number of lines that weren't executed.
- size_t NotCovered;
-
- /// \brief The number of lines that aren't code.
- size_t NonCodeLines;
-
- /// \brief The total number of lines in a function/file.
- size_t NumLines;
-
- LineCoverageInfo()
- : Covered(0), NotCovered(0), NonCodeLines(0), NumLines(0) {}
-
- LineCoverageInfo(size_t Covered, size_t NumNonCodeLines, size_t NumLines)
- : Covered(Covered), NotCovered(NumLines - NumNonCodeLines - Covered),
- NonCodeLines(NumNonCodeLines), NumLines(NumLines) {}
-
- LineCoverageInfo &operator+=(const LineCoverageInfo &RHS) {
- Covered += RHS.Covered;
- NotCovered += RHS.NotCovered;
- NonCodeLines += RHS.NonCodeLines;
- NumLines += RHS.NumLines;
- return *this;
- }
-
- bool isFullyCovered() const { return Covered == (NumLines - NonCodeLines); }
-
- double getPercentCovered() const {
- if (NumLines - NonCodeLines == 0)
- return 0.0;
- return double(Covered) / double(NumLines - NonCodeLines) * 100.0;
- }
-};
-
-/// \brief Provides information about function coverage for a file.
-struct FunctionCoverageInfo {
- /// \brief The number of functions that were executed.
- size_t Executed;
-
- /// \brief The total number of functions in this file.
- size_t NumFunctions;
-
- FunctionCoverageInfo() : Executed(0), NumFunctions(0) {}
-
- FunctionCoverageInfo(size_t Executed, size_t NumFunctions)
- : Executed(Executed), NumFunctions(NumFunctions) {}
-
- void addFunction(bool Covered) {
- if (Covered)
- ++Executed;
- ++NumFunctions;
- }
-
- bool isFullyCovered() const { return Executed == NumFunctions; }
-
- double getPercentCovered() const {
- if (NumFunctions == 0)
- return 0.0;
- return double(Executed) / double(NumFunctions) * 100.0;
- }
-};
-
-/// \brief A summary of function's code coverage.
-struct FunctionCoverageSummary {
- StringRef Name;
- uint64_t ExecutionCount;
- RegionCoverageInfo RegionCoverage;
- LineCoverageInfo LineCoverage;
-
- FunctionCoverageSummary(StringRef Name) : Name(Name), ExecutionCount(0) {}
-
- FunctionCoverageSummary(StringRef Name, uint64_t ExecutionCount,
- const RegionCoverageInfo &RegionCoverage,
- const LineCoverageInfo &LineCoverage)
- : Name(Name), ExecutionCount(ExecutionCount),
- RegionCoverage(RegionCoverage), LineCoverage(LineCoverage) {
- }
-
- /// \brief Compute the code coverage summary for the given function coverage
- /// mapping record.
- static FunctionCoverageSummary
- get(const coverage::FunctionRecord &Function);
-};
-
-/// \brief A summary of file's code coverage.
-struct FileCoverageSummary {
- StringRef Name;
- RegionCoverageInfo RegionCoverage;
- LineCoverageInfo LineCoverage;
- FunctionCoverageInfo FunctionCoverage;
-
- FileCoverageSummary(StringRef Name) : Name(Name) {}
-
- void addFunction(const FunctionCoverageSummary &Function) {
- RegionCoverage += Function.RegionCoverage;
- LineCoverage += Function.LineCoverage;
- FunctionCoverage.addFunction(/*Covered=*/Function.ExecutionCount > 0);
- }
-};
-
-} // namespace llvm
-
-#endif // LLVM_COV_COVERAGESUMMARYINFO_H
diff --git a/tools/llvm-cov/CoverageViewOptions.h b/tools/llvm-cov/CoverageViewOptions.h
deleted file mode 100644
index 350c264..0000000
--- a/tools/llvm-cov/CoverageViewOptions.h
+++ /dev/null
@@ -1,52 +0,0 @@
-//===- CoverageViewOptions.h - Code coverage display options -------------===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_COV_COVERAGEVIEWOPTIONS_H
-#define LLVM_COV_COVERAGEVIEWOPTIONS_H
-
-#include "RenderingSupport.h"
-#include <vector>
-
-namespace llvm {
-
-/// \brief The options for displaying the code coverage information.
-struct CoverageViewOptions {
- enum class OutputFormat {
- Text,
- HTML
- };
-
- bool Debug;
- bool Colors;
- bool ShowLineNumbers;
- bool ShowLineStats;
- bool ShowRegionMarkers;
- bool ShowLineStatsOrRegionMarkers;
- bool ShowExpandedRegions;
- bool ShowFunctionInstantiations;
- bool ShowFullFilenames;
- OutputFormat Format;
- std::string ShowOutputDirectory;
- std::vector<std::string> DemanglerOpts;
-
- /// \brief Change the output's stream color if the colors are enabled.
- ColoredRawOstream colored_ostream(raw_ostream &OS,
- raw_ostream::Colors Color) const {
- return llvm::colored_ostream(OS, Color, Colors);
- }
-
- /// \brief Check if an output directory has been specified.
- bool hasOutputDirectory() const { return !ShowOutputDirectory.empty(); }
-
- /// \brief Check if a demangler has been specified.
- bool hasDemangler() const { return !DemanglerOpts.empty(); }
-};
-}
-
-#endif // LLVM_COV_COVERAGEVIEWOPTIONS_H
diff --git a/tools/llvm-cov/RenderingSupport.h b/tools/llvm-cov/RenderingSupport.h
deleted file mode 100644
index aa70fbc..0000000
--- a/tools/llvm-cov/RenderingSupport.h
+++ /dev/null
@@ -1,61 +0,0 @@
-//===- RenderingSupport.h - output stream rendering support functions ----===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_COV_RENDERINGSUPPORT_H
-#define LLVM_COV_RENDERINGSUPPORT_H
-
-#include "llvm/Support/raw_ostream.h"
-#include <utility>
-
-namespace llvm {
-
-/// \brief A helper class that resets the output stream's color if needed
-/// when destroyed.
-class ColoredRawOstream {
- ColoredRawOstream(const ColoredRawOstream &OS) = delete;
-
-public:
- raw_ostream &OS;
- bool IsColorUsed;
-
- ColoredRawOstream(raw_ostream &OS, bool IsColorUsed)
- : OS(OS), IsColorUsed(IsColorUsed) {}
-
- ColoredRawOstream(ColoredRawOstream &&Other)
- : OS(Other.OS), IsColorUsed(Other.IsColorUsed) {
- // Reset the other IsColorUsed so that the other object won't reset the
- // color when destroyed.
- Other.IsColorUsed = false;
- }
-
- ~ColoredRawOstream() {
- if (IsColorUsed)
- OS.resetColor();
- }
-};
-
-template <typename T>
-inline raw_ostream &operator<<(const ColoredRawOstream &OS, T &&Value) {
- return OS.OS << std::forward<T>(Value);
-}
-
-/// \brief Change the color of the output stream if the `IsColorUsed` flag
-/// is true. Returns an object that resets the color when destroyed.
-inline ColoredRawOstream colored_ostream(raw_ostream &OS,
- raw_ostream::Colors Color,
- bool IsColorUsed = true,
- bool Bold = false, bool BG = false) {
- if (IsColorUsed)
- OS.changeColor(Color, Bold, BG);
- return ColoredRawOstream(OS, IsColorUsed);
-}
-
-} // namespace llvm
-
-#endif // LLVM_COV_RENDERINGSUPPORT_H
diff --git a/tools/llvm-cov/SourceCoverageView.cpp b/tools/llvm-cov/SourceCoverageView.cpp
index baf7c14..8b13789 100644
--- a/tools/llvm-cov/SourceCoverageView.cpp
+++ b/tools/llvm-cov/SourceCoverageView.cpp
@@ -1,233 +1 @@
-//===- SourceCoverageView.cpp - Code coverage view for source code --------===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-///
-/// \file This class implements rendering for code coverage of source code.
-///
-//===----------------------------------------------------------------------===//
-#include "SourceCoverageView.h"
-#include "SourceCoverageViewHTML.h"
-#include "SourceCoverageViewText.h"
-#include "llvm/ADT/SmallString.h"
-#include "llvm/ADT/StringExtras.h"
-#include "llvm/Support/FileSystem.h"
-#include "llvm/Support/LineIterator.h"
-#include "llvm/Support/Path.h"
-
-using namespace llvm;
-
-void CoveragePrinter::StreamDestructor::operator()(raw_ostream *OS) const {
- if (OS == &outs())
- return;
- delete OS;
-}
-
-std::string CoveragePrinter::getOutputPath(StringRef Path, StringRef Extension,
- bool InToplevel, bool Relative) {
- assert(Extension.size() && "The file extension may not be empty");
-
- SmallString<256> FullPath;
-
- if (!Relative)
- FullPath.append(Opts.ShowOutputDirectory);
-
- if (!InToplevel)
- sys::path::append(FullPath, getCoverageDir());
-
- SmallString<256> ParentPath = sys::path::parent_path(Path);
- sys::path::remove_dots(ParentPath, /*remove_dot_dots=*/true);
- sys::path::append(FullPath, sys::path::relative_path(ParentPath));
-
- auto PathFilename = (sys::path::filename(Path) + "." + Extension).str();
- sys::path::append(FullPath, PathFilename);
-
- return FullPath.str();
-}
-
-Expected<CoveragePrinter::OwnedStream>
-CoveragePrinter::createOutputStream(StringRef Path, StringRef Extension,
- bool InToplevel) {
- if (!Opts.hasOutputDirectory())
- return OwnedStream(&outs());
-
- std::string FullPath = getOutputPath(Path, Extension, InToplevel, false);
-
- auto ParentDir = sys::path::parent_path(FullPath);
- if (auto E = sys::fs::create_directories(ParentDir))
- return errorCodeToError(E);
-
- std::error_code E;
- raw_ostream *RawStream = new raw_fd_ostream(FullPath, E, sys::fs::F_RW);
- auto OS = CoveragePrinter::OwnedStream(RawStream);
- if (E)
- return errorCodeToError(E);
- return std::move(OS);
-}
-
-std::unique_ptr<CoveragePrinter>
-CoveragePrinter::create(const CoverageViewOptions &Opts) {
- switch (Opts.Format) {
- case CoverageViewOptions::OutputFormat::Text:
- return llvm::make_unique<CoveragePrinterText>(Opts);
- case CoverageViewOptions::OutputFormat::HTML:
- return llvm::make_unique<CoveragePrinterHTML>(Opts);
- }
- llvm_unreachable("Unknown coverage output format!");
-}
-
-std::string SourceCoverageView::formatCount(uint64_t N) {
- std::string Number = utostr(N);
- int Len = Number.size();
- if (Len <= 3)
- return Number;
- int IntLen = Len % 3 == 0 ? 3 : Len % 3;
- std::string Result(Number.data(), IntLen);
- if (IntLen != 3) {
- Result.push_back('.');
- Result += Number.substr(IntLen, 3 - IntLen);
- }
- Result.push_back(" kMGTPEZY"[(Len - 1) / 3]);
- return Result;
-}
-
-bool SourceCoverageView::shouldRenderRegionMarkers(
- bool LineHasMultipleRegions) const {
- return getOptions().ShowRegionMarkers &&
- (!getOptions().ShowLineStatsOrRegionMarkers || LineHasMultipleRegions);
-}
-
-bool SourceCoverageView::hasSubViews() const {
- return !ExpansionSubViews.empty() || !InstantiationSubViews.empty();
-}
-
-std::unique_ptr<SourceCoverageView>
-SourceCoverageView::create(StringRef SourceName, const MemoryBuffer &File,
- const CoverageViewOptions &Options,
- coverage::CoverageData &&CoverageInfo) {
- switch (Options.Format) {
- case CoverageViewOptions::OutputFormat::Text:
- return llvm::make_unique<SourceCoverageViewText>(SourceName, File, Options,
- std::move(CoverageInfo));
- case CoverageViewOptions::OutputFormat::HTML:
- return llvm::make_unique<SourceCoverageViewHTML>(SourceName, File, Options,
- std::move(CoverageInfo));
- }
- llvm_unreachable("Unknown coverage output format!");
-}
-
-void SourceCoverageView::addExpansion(
- const coverage::CounterMappingRegion &Region,
- std::unique_ptr<SourceCoverageView> View) {
- ExpansionSubViews.emplace_back(Region, std::move(View));
-}
-
-void SourceCoverageView::addInstantiation(
- StringRef FunctionName, unsigned Line,
- std::unique_ptr<SourceCoverageView> View) {
- InstantiationSubViews.emplace_back(FunctionName, Line, std::move(View));
-}
-
-void SourceCoverageView::print(raw_ostream &OS, bool WholeFile,
- bool ShowSourceName, unsigned ViewDepth) {
- if (ShowSourceName)
- renderSourceName(OS);
-
- renderViewHeader(OS);
-
- // We need the expansions and instantiations sorted so we can go through them
- // while we iterate lines.
- std::sort(ExpansionSubViews.begin(), ExpansionSubViews.end());
- std::sort(InstantiationSubViews.begin(), InstantiationSubViews.end());
- auto NextESV = ExpansionSubViews.begin();
- auto EndESV = ExpansionSubViews.end();
- auto NextISV = InstantiationSubViews.begin();
- auto EndISV = InstantiationSubViews.end();
-
- // Get the coverage information for the file.
- auto NextSegment = CoverageInfo.begin();
- auto EndSegment = CoverageInfo.end();
-
- unsigned FirstLine = NextSegment != EndSegment ? NextSegment->Line : 0;
- const coverage::CoverageSegment *WrappedSegment = nullptr;
- SmallVector<const coverage::CoverageSegment *, 8> LineSegments;
- for (line_iterator LI(File, /*SkipBlanks=*/false); !LI.is_at_eof(); ++LI) {
- // If we aren't rendering the whole file, we need to filter out the prologue
- // and epilogue.
- if (!WholeFile) {
- if (NextSegment == EndSegment)
- break;
- else if (LI.line_number() < FirstLine)
- continue;
- }
-
- // Collect the coverage information relevant to this line.
- if (LineSegments.size())
- WrappedSegment = LineSegments.back();
- LineSegments.clear();
- while (NextSegment != EndSegment && NextSegment->Line == LI.line_number())
- LineSegments.push_back(&*NextSegment++);
-
- // Calculate a count to be for the line as a whole.
- LineCoverageStats LineCount;
- if (WrappedSegment && WrappedSegment->HasCount)
- LineCount.addRegionCount(WrappedSegment->Count);
- for (const auto *S : LineSegments)
- if (S->HasCount && S->IsRegionEntry)
- LineCount.addRegionStartCount(S->Count);
-
- renderLinePrefix(OS, ViewDepth);
- if (getOptions().ShowLineStats)
- renderLineCoverageColumn(OS, LineCount);
- if (getOptions().ShowLineNumbers)
- renderLineNumberColumn(OS, LI.line_number());
-
- // If there are expansion subviews, we want to highlight the first one.
- unsigned ExpansionColumn = 0;
- if (NextESV != EndESV && NextESV->getLine() == LI.line_number() &&
- getOptions().Colors)
- ExpansionColumn = NextESV->getStartCol();
-
- // Display the source code for the current line.
- renderLine(OS, {*LI, LI.line_number()}, WrappedSegment, LineSegments,
- ExpansionColumn, ViewDepth);
-
- // Show the region markers.
- if (shouldRenderRegionMarkers(LineCount.hasMultipleRegions()))
- renderRegionMarkers(OS, LineSegments, ViewDepth);
-
- // Show the expansions and instantiations for this line.
- bool RenderedSubView = false;
- for (; NextESV != EndESV && NextESV->getLine() == LI.line_number();
- ++NextESV) {
- renderViewDivider(OS, ViewDepth + 1);
-
- // Re-render the current line and highlight the expansion range for
- // this subview.
- if (RenderedSubView) {
- ExpansionColumn = NextESV->getStartCol();
- renderExpansionSite(OS, {*LI, LI.line_number()}, WrappedSegment,
- LineSegments, ExpansionColumn, ViewDepth);
- renderViewDivider(OS, ViewDepth + 1);
- }
-
- renderExpansionView(OS, *NextESV, ViewDepth + 1);
- RenderedSubView = true;
- }
- for (; NextISV != EndISV && NextISV->Line == LI.line_number(); ++NextISV) {
- renderViewDivider(OS, ViewDepth + 1);
- renderInstantiationView(OS, *NextISV, ViewDepth + 1);
- RenderedSubView = true;
- }
- if (RenderedSubView)
- renderViewDivider(OS, ViewDepth + 1);
- renderLineSuffix(OS, ViewDepth);
- }
-
- renderViewFooter(OS);
-}
diff --git a/tools/llvm-cov/SourceCoverageView.h b/tools/llvm-cov/SourceCoverageView.h
deleted file mode 100644
index feef959..0000000
--- a/tools/llvm-cov/SourceCoverageView.h
+++ /dev/null
@@ -1,285 +0,0 @@
-//===- SourceCoverageView.h - Code coverage view for source code ----------===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-///
-/// \file This class implements rendering for code coverage of source code.
-///
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_COV_SOURCECOVERAGEVIEW_H
-#define LLVM_COV_SOURCECOVERAGEVIEW_H
-
-#include "CoverageViewOptions.h"
-#include "llvm/ProfileData/Coverage/CoverageMapping.h"
-#include "llvm/Support/MemoryBuffer.h"
-#include <vector>
-
-namespace llvm {
-
-class SourceCoverageView;
-
-/// \brief A view that represents a macro or include expansion.
-struct ExpansionView {
- coverage::CounterMappingRegion Region;
- std::unique_ptr<SourceCoverageView> View;
-
- ExpansionView(const coverage::CounterMappingRegion &Region,
- std::unique_ptr<SourceCoverageView> View)
- : Region(Region), View(std::move(View)) {}
- ExpansionView(ExpansionView &&RHS)
- : Region(std::move(RHS.Region)), View(std::move(RHS.View)) {}
- ExpansionView &operator=(ExpansionView &&RHS) {
- Region = std::move(RHS.Region);
- View = std::move(RHS.View);
- return *this;
- }
-
- unsigned getLine() const { return Region.LineStart; }
- unsigned getStartCol() const { return Region.ColumnStart; }
- unsigned getEndCol() const { return Region.ColumnEnd; }
-
- friend bool operator<(const ExpansionView &LHS, const ExpansionView &RHS) {
- return LHS.Region.startLoc() < RHS.Region.startLoc();
- }
-};
-
-/// \brief A view that represents a function instantiation.
-struct InstantiationView {
- StringRef FunctionName;
- unsigned Line;
- std::unique_ptr<SourceCoverageView> View;
-
- InstantiationView(StringRef FunctionName, unsigned Line,
- std::unique_ptr<SourceCoverageView> View)
- : FunctionName(FunctionName), Line(Line), View(std::move(View)) {}
- InstantiationView(InstantiationView &&RHS)
- : FunctionName(std::move(RHS.FunctionName)), Line(std::move(RHS.Line)),
- View(std::move(RHS.View)) {}
- InstantiationView &operator=(InstantiationView &&RHS) {
- FunctionName = std::move(RHS.FunctionName);
- Line = std::move(RHS.Line);
- View = std::move(RHS.View);
- return *this;
- }
-
- friend bool operator<(const InstantiationView &LHS,
- const InstantiationView &RHS) {
- return LHS.Line < RHS.Line;
- }
-};
-
-/// \brief Coverage statistics for a single line.
-struct LineCoverageStats {
- uint64_t ExecutionCount;
- unsigned RegionCount;
- bool Mapped;
-
- LineCoverageStats() : ExecutionCount(0), RegionCount(0), Mapped(false) {}
-
- bool isMapped() const { return Mapped; }
-
- bool hasMultipleRegions() const { return RegionCount > 1; }
-
- void addRegionStartCount(uint64_t Count) {
- // The max of all region starts is the most interesting value.
- addRegionCount(RegionCount ? std::max(ExecutionCount, Count) : Count);
- ++RegionCount;
- }
-
- void addRegionCount(uint64_t Count) {
- Mapped = true;
- ExecutionCount = Count;
- }
-};
-
-/// \brief A file manager that handles format-aware file creation.
-class CoveragePrinter {
- const CoverageViewOptions &Opts;
-
-public:
- struct StreamDestructor {
- void operator()(raw_ostream *OS) const;
- };
-
- using OwnedStream = std::unique_ptr<raw_ostream, StreamDestructor>;
-
-protected:
- CoveragePrinter(const CoverageViewOptions &Opts) : Opts(Opts) {}
-
- /// \brief Return `OutputDir/ToplevelDir/Path.Extension`. If \p InToplevel is
- /// false, skip the ToplevelDir component. If \p Relative is false, skip the
- /// OutputDir component.
- std::string getOutputPath(StringRef Path, StringRef Extension,
- bool InToplevel, bool Relative = true);
-
- /// \brief If directory output is enabled, create a file in that directory
- /// at the path given by getOutputPath(). Otherwise, return stdout.
- Expected<OwnedStream> createOutputStream(StringRef Path, StringRef Extension,
- bool InToplevel);
-
- /// \brief Return the sub-directory name for file coverage reports.
- static StringRef getCoverageDir() { return "coverage"; }
-
-public:
- static std::unique_ptr<CoveragePrinter>
- create(const CoverageViewOptions &Opts);
-
- virtual ~CoveragePrinter() {}
-
- /// @name File Creation Interface
- /// @{
-
- /// \brief Create a file to print a coverage view into.
- virtual Expected<OwnedStream> createViewFile(StringRef Path,
- bool InToplevel) = 0;
-
- /// \brief Close a file which has been used to print a coverage view.
- virtual void closeViewFile(OwnedStream OS) = 0;
-
- /// \brief Create an index which lists reports for the given source files.
- virtual Error createIndexFile(ArrayRef<StringRef> SourceFiles) = 0;
-
- /// @}
-};
-
-/// \brief A code coverage view of a source file or function.
-///
-/// A source coverage view and its nested sub-views form a file-oriented
-/// representation of code coverage data. This view can be printed out by a
-/// renderer which implements the Rendering Interface.
-class SourceCoverageView {
- /// A function or file name.
- StringRef SourceName;
-
- /// A memory buffer backing the source on display.
- const MemoryBuffer &File;
-
- /// Various options to guide the coverage renderer.
- const CoverageViewOptions &Options;
-
- /// Complete coverage information about the source on display.
- coverage::CoverageData CoverageInfo;
-
- /// A container for all expansions (e.g macros) in the source on display.
- std::vector<ExpansionView> ExpansionSubViews;
-
- /// A container for all instantiations (e.g template functions) in the source
- /// on display.
- std::vector<InstantiationView> InstantiationSubViews;
-
-protected:
- struct LineRef {
- StringRef Line;
- int64_t LineNo;
-
- LineRef(StringRef Line, int64_t LineNo) : Line(Line), LineNo(LineNo) {}
- };
-
- using CoverageSegmentArray = ArrayRef<const coverage::CoverageSegment *>;
-
- /// @name Rendering Interface
- /// @{
-
- /// \brief Render a header for the view.
- virtual void renderViewHeader(raw_ostream &OS) = 0;
-
- /// \brief Render a footer for the view.
- virtual void renderViewFooter(raw_ostream &OS) = 0;
-
- /// \brief Render the source name for the view.
- virtual void renderSourceName(raw_ostream &OS) = 0;
-
- /// \brief Render the line prefix at the given \p ViewDepth.
- virtual void renderLinePrefix(raw_ostream &OS, unsigned ViewDepth) = 0;
-
- /// \brief Render the line suffix at the given \p ViewDepth.
- virtual void renderLineSuffix(raw_ostream &OS, unsigned ViewDepth) = 0;
-
- /// \brief Render a view divider at the given \p ViewDepth.
- virtual void renderViewDivider(raw_ostream &OS, unsigned ViewDepth) = 0;
-
- /// \brief Render a source line with highlighting.
- virtual void renderLine(raw_ostream &OS, LineRef L,
- const coverage::CoverageSegment *WrappedSegment,
- CoverageSegmentArray Segments, unsigned ExpansionCol,
- unsigned ViewDepth) = 0;
-
- /// \brief Render the line's execution count column.
- virtual void renderLineCoverageColumn(raw_ostream &OS,
- const LineCoverageStats &Line) = 0;
-
- /// \brief Render the line number column.
- virtual void renderLineNumberColumn(raw_ostream &OS, unsigned LineNo) = 0;
-
- /// \brief Render all the region's execution counts on a line.
- virtual void renderRegionMarkers(raw_ostream &OS,
- CoverageSegmentArray Segments,
- unsigned ViewDepth) = 0;
-
- /// \brief Render the site of an expansion.
- virtual void
- renderExpansionSite(raw_ostream &OS, LineRef L,
- const coverage::CoverageSegment *WrappedSegment,
- CoverageSegmentArray Segments, unsigned ExpansionCol,
- unsigned ViewDepth) = 0;
-
- /// \brief Render an expansion view and any nested views.
- virtual void renderExpansionView(raw_ostream &OS, ExpansionView &ESV,
- unsigned ViewDepth) = 0;
-
- /// \brief Render an instantiation view and any nested views.
- virtual void renderInstantiationView(raw_ostream &OS, InstantiationView &ISV,
- unsigned ViewDepth) = 0;
-
- /// @}
-
- /// \brief Format a count using engineering notation with 3 significant
- /// digits.
- static std::string formatCount(uint64_t N);
-
- /// \brief Check if region marker output is expected for a line.
- bool shouldRenderRegionMarkers(bool LineHasMultipleRegions) const;
-
- /// \brief Check if there are any sub-views attached to this view.
- bool hasSubViews() const;
-
- SourceCoverageView(StringRef SourceName, const MemoryBuffer &File,
- const CoverageViewOptions &Options,
- coverage::CoverageData &&CoverageInfo)
- : SourceName(SourceName), File(File), Options(Options),
- CoverageInfo(std::move(CoverageInfo)) {}
-
-public:
- static std::unique_ptr<SourceCoverageView>
- create(StringRef SourceName, const MemoryBuffer &File,
- const CoverageViewOptions &Options,
- coverage::CoverageData &&CoverageInfo);
-
- virtual ~SourceCoverageView() {}
-
- StringRef getSourceName() const { return SourceName; }
-
- const CoverageViewOptions &getOptions() const { return Options; }
-
- /// \brief Add an expansion subview to this view.
- void addExpansion(const coverage::CounterMappingRegion &Region,
- std::unique_ptr<SourceCoverageView> View);
-
- /// \brief Add a function instantiation subview to this view.
- void addInstantiation(StringRef FunctionName, unsigned Line,
- std::unique_ptr<SourceCoverageView> View);
-
- /// \brief Print the code coverage information for a specific portion of a
- /// source file to the output stream.
- void print(raw_ostream &OS, bool WholeFile, bool ShowSourceName,
- unsigned ViewDepth = 0);
-};
-
-} // namespace llvm
-
-#endif // LLVM_COV_SOURCECOVERAGEVIEW_H
diff --git a/tools/llvm-cov/SourceCoverageViewHTML.cpp b/tools/llvm-cov/SourceCoverageViewHTML.cpp
index 81963e5..8b13789 100644
--- a/tools/llvm-cov/SourceCoverageViewHTML.cpp
+++ b/tools/llvm-cov/SourceCoverageViewHTML.cpp
@@ -1,436 +1 @@
-//===- SourceCoverageViewHTML.cpp - A html code coverage view -------------===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-///
-/// \file This file implements the html coverage renderer.
-///
-//===----------------------------------------------------------------------===//
-#include "SourceCoverageViewHTML.h"
-#include "llvm/ADT/Optional.h"
-#include "llvm/ADT/SmallString.h"
-#include "llvm/ADT/StringExtras.h"
-#include "llvm/Support/Path.h"
-
-using namespace llvm;
-
-namespace {
-
-const char *BeginHeader =
- "<head>"
- "<meta name='viewport' content='width=device-width,initial-scale=1'>"
- "<meta charset='UTF-8'>";
-
-const char *CSSForCoverage =
- "<style>"
-R"(
-
-.red {
- background-color: #FFD0D0;
-}
-.cyan {
- background-color: cyan;
-}
-.black {
- background-color: black;
- color: white;
-}
-.green {
- background-color: #98FFA6;
- color: white;
-}
-.magenta {
- background-color: #F998FF;
- color: white;
-}
-body {
- font-family: -apple-system, sans-serif;
-}
-pre {
- margin-top: 0px !important;
- margin-bottom: 0px !important;
-}
-.source-name-title {
- padding: 5px 10px;
- border-bottom: 1px solid #dbdbdb;
- background-color: #eee;
-}
-.centered {
- display: table;
- margin-left: auto;
- margin-right: auto;
- border: 1px solid #dbdbdb;
- border-radius: 3px;
-}
-.expansion-view {
- background-color: rgba(0, 0, 0, 0);
- margin-left: 0px;
- margin-top: 5px;
- margin-right: 5px;
- margin-bottom: 5px;
- border: 1px solid #dbdbdb;
- border-radius: 3px;
-}
-table {
- border-collapse: collapse;
-}
-.line-number {
- text-align: right;
- color: #aaa;
-}
-.covered-line {
- text-align: right;
- color: #0080ff;
-}
-.uncovered-line {
- text-align: right;
- color: #ff3300;
-}
-.tooltip {
- position: relative;
- display: inline;
- background-color: #b3e6ff;
- text-decoration: none;
-}
-.tooltip span.tooltip-content {
- position: absolute;
- width: 100px;
- margin-left: -50px;
- color: #FFFFFF;
- background: #000000;
- height: 30px;
- line-height: 30px;
- text-align: center;
- visibility: hidden;
- border-radius: 6px;
-}
-.tooltip span.tooltip-content:after {
- content: '';
- position: absolute;
- top: 100%;
- left: 50%;
- margin-left: -8px;
- width: 0; height: 0;
- border-top: 8px solid #000000;
- border-right: 8px solid transparent;
- border-left: 8px solid transparent;
-}
-:hover.tooltip span.tooltip-content {
- visibility: visible;
- opacity: 0.8;
- bottom: 30px;
- left: 50%;
- z-index: 999;
-}
-th, td {
- vertical-align: top;
- padding: 2px 5px;
- border-collapse: collapse;
- border-right: solid 1px #eee;
- border-left: solid 1px #eee;
-}
-td:first-child {
- border-left: none;
-}
-td:last-child {
- border-right: none;
-}
-
-)"
- "</style>";
-
-const char *EndHeader = "</head>";
-
-const char *BeginCenteredDiv = "<div class='centered'>";
-
-const char *EndCenteredDiv = "</div>";
-
-const char *BeginSourceNameDiv = "<div class='source-name-title'>";
-
-const char *EndSourceNameDiv = "</div>";
-
-const char *BeginCodeTD = "<td class='code'>";
-
-const char *EndCodeTD = "</td>";
-
-const char *BeginPre = "<pre>";
-
-const char *EndPre = "</pre>";
-
-const char *BeginExpansionDiv = "<div class='expansion-view'>";
-
-const char *EndExpansionDiv = "</div>";
-
-const char *BeginTable = "<table>";
-
-const char *EndTable = "</table>";
-
-void emitPrelude(raw_ostream &OS) {
- OS << "<!doctype html>"
- "<html>"
- << BeginHeader << CSSForCoverage << EndHeader << "<body>"
- << BeginCenteredDiv;
-}
-
-void emitEpilog(raw_ostream &OS) {
- OS << EndCenteredDiv << "</body>"
- "</html>";
-}
-
-// Return a string with the special characters in \p Str escaped.
-std::string escape(StringRef Str) {
- std::string Result;
- for (char C : Str) {
- if (C == '&')
- Result += "&";
- else if (C == '<')
- Result += "<";
- else if (C == '>')
- Result += ">";
- else if (C == '\"')
- Result += """;
- else
- Result += C;
- }
- return Result;
-}
-
-// Create a \p Name tag around \p Str, and optionally set its \p ClassName.
-std::string tag(const std::string &Name, const std::string &Str,
- const std::string &ClassName = "") {
- std::string Tag = "<" + Name;
- if (ClassName != "")
- Tag += " class='" + ClassName + "'";
- return Tag + ">" + Str + "</" + Name + ">";
-}
-
-// Create an anchor to \p Link with the label \p Str.
-std::string a(const std::string &Link, const std::string &Str) {
- return "<a href='" + Link + "'>" + Str + "</a>";
-}
-
-} // anonymous namespace
-
-Expected<CoveragePrinter::OwnedStream>
-CoveragePrinterHTML::createViewFile(StringRef Path, bool InToplevel) {
- auto OSOrErr = createOutputStream(Path, "html", InToplevel);
- if (!OSOrErr)
- return OSOrErr;
-
- OwnedStream OS = std::move(OSOrErr.get());
- emitPrelude(*OS.get());
- return std::move(OS);
-}
-
-void CoveragePrinterHTML::closeViewFile(OwnedStream OS) {
- emitEpilog(*OS.get());
-}
-
-Error CoveragePrinterHTML::createIndexFile(ArrayRef<StringRef> SourceFiles) {
- auto OSOrErr = createOutputStream("index", "html", /*InToplevel=*/true);
- if (Error E = OSOrErr.takeError())
- return E;
- auto OS = std::move(OSOrErr.get());
- raw_ostream &OSRef = *OS.get();
-
- // Emit a table containing links to reports for each file in the covmapping.
- emitPrelude(OSRef);
- OSRef << BeginSourceNameDiv << "Index" << EndSourceNameDiv;
- OSRef << BeginTable;
- for (StringRef SF : SourceFiles) {
- std::string LinkText = escape(sys::path::relative_path(SF));
- std::string LinkTarget =
- escape(getOutputPath(SF, "html", /*InToplevel=*/false));
- OSRef << tag("tr", tag("td", tag("pre", a(LinkTarget, LinkText), "code")));
- }
- OSRef << EndTable;
- emitEpilog(OSRef);
-
- return Error::success();
-}
-
-void SourceCoverageViewHTML::renderViewHeader(raw_ostream &OS) {
- OS << BeginTable;
-}
-
-void SourceCoverageViewHTML::renderViewFooter(raw_ostream &OS) {
- OS << EndTable;
-}
-
-void SourceCoverageViewHTML::renderSourceName(raw_ostream &OS) {
- OS << BeginSourceNameDiv << tag("pre", escape(getSourceName()))
- << EndSourceNameDiv;
-}
-
-void SourceCoverageViewHTML::renderLinePrefix(raw_ostream &OS, unsigned) {
- OS << "<tr>";
-}
-
-void SourceCoverageViewHTML::renderLineSuffix(raw_ostream &OS, unsigned) {
- // If this view has sub-views, renderLine() cannot close the view's cell.
- // Take care of it here, after all sub-views have been rendered.
- if (hasSubViews())
- OS << EndCodeTD;
- OS << "</tr>";
-}
-
-void SourceCoverageViewHTML::renderViewDivider(raw_ostream &, unsigned) {
- // The table-based output makes view dividers unnecessary.
-}
-
-void SourceCoverageViewHTML::renderLine(
- raw_ostream &OS, LineRef L, const coverage::CoverageSegment *WrappedSegment,
- CoverageSegmentArray Segments, unsigned ExpansionCol, unsigned) {
- StringRef Line = L.Line;
-
- // Steps for handling text-escaping, highlighting, and tooltip creation:
- //
- // 1. Split the line into N+1 snippets, where N = |Segments|. The first
- // snippet starts from Col=1 and ends at the start of the first segment.
- // The last snippet starts at the last mapped column in the line and ends
- // at the end of the line. Both are required but may be empty.
-
- SmallVector<std::string, 8> Snippets;
-
- unsigned LCol = 1;
- auto Snip = [&](unsigned Start, unsigned Len) {
- assert(Start + Len <= Line.size() && "Snippet extends past the EOL");
- Snippets.push_back(Line.substr(Start, Len));
- LCol += Len;
- };
-
- Snip(LCol - 1, Segments.empty() ? 0 : (Segments.front()->Col - 1));
-
- for (unsigned I = 1, E = Segments.size(); I < E; ++I) {
- assert(LCol == Segments[I - 1]->Col && "Snippet start position is wrong");
- Snip(LCol - 1, Segments[I]->Col - LCol);
- }
-
- // |Line| + 1 is needed to avoid underflow when, e.g |Line| = 0 and LCol = 1.
- Snip(LCol - 1, Line.size() + 1 - LCol);
- assert(LCol == Line.size() + 1 && "Final snippet doesn't reach the EOL");
-
- // 2. Escape all of the snippets.
-
- for (unsigned I = 0, E = Snippets.size(); I < E; ++I)
- Snippets[I] = escape(Snippets[I]);
-
- // 3. Use \p WrappedSegment to set the highlight for snippets 0 and 1. Use
- // segment 1 to set the highlight for snippet 2, segment 2 to set the
- // highlight for snippet 3, and so on.
-
- Optional<std::string> Color;
- auto Highlight = [&](const std::string &Snippet) {
- return tag("span", Snippet, Color.getValue());
- };
-
- auto CheckIfUncovered = [](const coverage::CoverageSegment *S) {
- return S && S->HasCount && S->Count == 0;
- };
-
- if (CheckIfUncovered(WrappedSegment) ||
- CheckIfUncovered(Segments.empty() ? nullptr : Segments.front())) {
- Color = "red";
- Snippets[0] = Highlight(Snippets[0]);
- Snippets[1] = Highlight(Snippets[1]);
- }
-
- for (unsigned I = 1, E = Segments.size(); I < E; ++I) {
- const auto *CurSeg = Segments[I];
- if (CurSeg->Col == ExpansionCol)
- Color = "cyan";
- else if (CheckIfUncovered(CurSeg))
- Color = "red";
- else
- Color = None;
-
- if (Color.hasValue())
- Snippets[I + 1] = Highlight(Snippets[I + 1]);
- }
-
- // 4. Snippets[1:N+1] correspond to \p Segments[0:N]: use these to generate
- // sub-line region count tooltips if needed.
-
- bool HasMultipleRegions = [&] {
- unsigned RegionCount = 0;
- for (const auto *S : Segments)
- if (S->HasCount && S->IsRegionEntry)
- if (++RegionCount > 1)
- return true;
- return false;
- }();
-
- if (shouldRenderRegionMarkers(HasMultipleRegions)) {
- for (unsigned I = 0, E = Segments.size(); I < E; ++I) {
- const auto *CurSeg = Segments[I];
- if (!CurSeg->IsRegionEntry || !CurSeg->HasCount)
- continue;
-
- Snippets[I + 1] =
- tag("div", Snippets[I + 1] + tag("span", formatCount(CurSeg->Count),
- "tooltip-content"),
- "tooltip");
- }
- }
-
- OS << BeginCodeTD;
- OS << BeginPre;
- for (const auto &Snippet : Snippets)
- OS << Snippet;
- OS << EndPre;
-
- // If there are no sub-views left to attach to this cell, end the cell.
- // Otherwise, end it after the sub-views are rendered (renderLineSuffix()).
- if (!hasSubViews())
- OS << EndCodeTD;
-}
-
-void SourceCoverageViewHTML::renderLineCoverageColumn(
- raw_ostream &OS, const LineCoverageStats &Line) {
- std::string Count = "";
- if (Line.isMapped())
- Count = tag("pre", formatCount(Line.ExecutionCount));
- std::string CoverageClass =
- (Line.ExecutionCount > 0) ? "covered-line" : "uncovered-line";
- OS << tag("td", Count, CoverageClass);
-}
-
-void SourceCoverageViewHTML::renderLineNumberColumn(raw_ostream &OS,
- unsigned LineNo) {
- OS << tag("td", tag("pre", utostr(uint64_t(LineNo))), "line-number");
-}
-
-void SourceCoverageViewHTML::renderRegionMarkers(raw_ostream &,
- CoverageSegmentArray,
- unsigned) {
- // Region markers are rendered in-line using tooltips.
-}
-
-void SourceCoverageViewHTML::renderExpansionSite(
- raw_ostream &OS, LineRef L, const coverage::CoverageSegment *WrappedSegment,
- CoverageSegmentArray Segments, unsigned ExpansionCol, unsigned ViewDepth) {
- // Render the line containing the expansion site. No extra formatting needed.
- renderLine(OS, L, WrappedSegment, Segments, ExpansionCol, ViewDepth);
-}
-
-void SourceCoverageViewHTML::renderExpansionView(raw_ostream &OS,
- ExpansionView &ESV,
- unsigned ViewDepth) {
- OS << BeginExpansionDiv;
- ESV.View->print(OS, /*WholeFile=*/false, /*ShowSourceName=*/false,
- ViewDepth + 1);
- OS << EndExpansionDiv;
-}
-
-void SourceCoverageViewHTML::renderInstantiationView(raw_ostream &OS,
- InstantiationView &ISV,
- unsigned ViewDepth) {
- OS << BeginExpansionDiv;
- ISV.View->print(OS, /*WholeFile=*/false, /*ShowSourceName=*/true, ViewDepth);
- OS << EndExpansionDiv;
-}
diff --git a/tools/llvm-cov/SourceCoverageViewHTML.h b/tools/llvm-cov/SourceCoverageViewHTML.h
deleted file mode 100644
index 50ecf2b..0000000
--- a/tools/llvm-cov/SourceCoverageViewHTML.h
+++ /dev/null
@@ -1,83 +0,0 @@
-//===- SourceCoverageViewHTML.h - A html code coverage view ---------------===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-///
-/// \file This file defines the interface to the html coverage renderer.
-///
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_COV_SOURCECOVERAGEVIEWHTML_H
-#define LLVM_COV_SOURCECOVERAGEVIEWHTML_H
-
-#include "SourceCoverageView.h"
-
-namespace llvm {
-
-/// \brief A coverage printer for html output.
-class CoveragePrinterHTML : public CoveragePrinter {
-public:
- Expected<OwnedStream> createViewFile(StringRef Path,
- bool InToplevel) override;
-
- void closeViewFile(OwnedStream OS) override;
-
- Error createIndexFile(ArrayRef<StringRef> SourceFiles) override;
-
- CoveragePrinterHTML(const CoverageViewOptions &Opts)
- : CoveragePrinter(Opts) {}
-};
-
-/// \brief A code coverage view which supports html-based rendering.
-class SourceCoverageViewHTML : public SourceCoverageView {
- void renderViewHeader(raw_ostream &OS) override;
-
- void renderViewFooter(raw_ostream &OS) override;
-
- void renderSourceName(raw_ostream &OS) override;
-
- void renderLinePrefix(raw_ostream &OS, unsigned ViewDepth) override;
-
- void renderLineSuffix(raw_ostream &OS, unsigned ViewDepth) override;
-
- void renderViewDivider(raw_ostream &OS, unsigned ViewDepth) override;
-
- void renderLine(raw_ostream &OS, LineRef L,
- const coverage::CoverageSegment *WrappedSegment,
- CoverageSegmentArray Segments, unsigned ExpansionCol,
- unsigned ViewDepth) override;
-
- void renderExpansionSite(raw_ostream &OS, LineRef L,
- const coverage::CoverageSegment *WrappedSegment,
- CoverageSegmentArray Segments, unsigned ExpansionCol,
- unsigned ViewDepth) override;
-
- void renderExpansionView(raw_ostream &OS, ExpansionView &ESV,
- unsigned ViewDepth) override;
-
- void renderInstantiationView(raw_ostream &OS, InstantiationView &ISV,
- unsigned ViewDepth) override;
-
- void renderLineCoverageColumn(raw_ostream &OS,
- const LineCoverageStats &Line) override;
-
- void renderLineNumberColumn(raw_ostream &OS, unsigned LineNo) override;
-
- void renderRegionMarkers(raw_ostream &OS, CoverageSegmentArray Segments,
- unsigned ViewDepth) override;
-
-public:
- SourceCoverageViewHTML(StringRef SourceName, const MemoryBuffer &File,
- const CoverageViewOptions &Options,
- coverage::CoverageData &&CoverageInfo)
- : SourceCoverageView(SourceName, File, Options, std::move(CoverageInfo)) {
- }
-};
-
-} // namespace llvm
-
-#endif // LLVM_COV_SOURCECOVERAGEVIEWHTML_H
diff --git a/tools/llvm-cov/SourceCoverageViewText.cpp b/tools/llvm-cov/SourceCoverageViewText.cpp
index ae9d6da..8b13789 100644
--- a/tools/llvm-cov/SourceCoverageViewText.cpp
+++ b/tools/llvm-cov/SourceCoverageViewText.cpp
@@ -1,213 +1 @@
-//===- SourceCoverageViewText.cpp - A text-based code coverage view -------===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-///
-/// \file This file implements the text-based coverage renderer.
-///
-//===----------------------------------------------------------------------===//
-#include "SourceCoverageViewText.h"
-#include "llvm/ADT/Optional.h"
-#include "llvm/ADT/SmallString.h"
-#include "llvm/ADT/StringExtras.h"
-
-using namespace llvm;
-
-Expected<CoveragePrinter::OwnedStream>
-CoveragePrinterText::createViewFile(StringRef Path, bool InToplevel) {
- return createOutputStream(Path, "txt", InToplevel);
-}
-
-void CoveragePrinterText::closeViewFile(OwnedStream OS) {
- OS->operator<<('\n');
-}
-
-Error CoveragePrinterText::createIndexFile(ArrayRef<StringRef> SourceFiles) {
- auto OSOrErr = createOutputStream("index", "txt", /*InToplevel=*/true);
- if (Error E = OSOrErr.takeError())
- return E;
- auto OS = std::move(OSOrErr.get());
- raw_ostream &OSRef = *OS.get();
-
- for (StringRef SF : SourceFiles)
- OSRef << getOutputPath(SF, "txt", /*InToplevel=*/false) << '\n';
-
- return Error::success();
-}
-
-namespace {
-
-static const unsigned LineCoverageColumnWidth = 7;
-static const unsigned LineNumberColumnWidth = 5;
-
-/// \brief Get the width of the leading columns.
-unsigned getCombinedColumnWidth(const CoverageViewOptions &Opts) {
- return (Opts.ShowLineStats ? LineCoverageColumnWidth + 1 : 0) +
- (Opts.ShowLineNumbers ? LineNumberColumnWidth + 1 : 0);
-}
-
-/// \brief The width of the line that is used to divide between the view and
-/// the subviews.
-unsigned getDividerWidth(const CoverageViewOptions &Opts) {
- return getCombinedColumnWidth(Opts) + 4;
-}
-
-} // anonymous namespace
-
-void SourceCoverageViewText::renderViewHeader(raw_ostream &) {}
-
-void SourceCoverageViewText::renderViewFooter(raw_ostream &) {}
-
-void SourceCoverageViewText::renderSourceName(raw_ostream &OS) {
- getOptions().colored_ostream(OS, raw_ostream::CYAN) << getSourceName()
- << ":\n";
-}
-
-void SourceCoverageViewText::renderLinePrefix(raw_ostream &OS,
- unsigned ViewDepth) {
- for (unsigned I = 0; I < ViewDepth; ++I)
- OS << " |";
-}
-
-void SourceCoverageViewText::renderLineSuffix(raw_ostream &, unsigned) {}
-
-void SourceCoverageViewText::renderViewDivider(raw_ostream &OS,
- unsigned ViewDepth) {
- assert(ViewDepth != 0 && "Cannot render divider at top level");
- renderLinePrefix(OS, ViewDepth - 1);
- OS.indent(2);
- unsigned Length = getDividerWidth(getOptions());
- for (unsigned I = 0; I < Length; ++I)
- OS << '-';
- OS << '\n';
-}
-
-void SourceCoverageViewText::renderLine(
- raw_ostream &OS, LineRef L,
- const coverage::CoverageSegment *WrappedSegment,
- CoverageSegmentArray Segments, unsigned ExpansionCol, unsigned ViewDepth) {
- StringRef Line = L.Line;
- unsigned LineNumber = L.LineNo;
-
- Optional<raw_ostream::Colors> Highlight;
- SmallVector<std::pair<unsigned, unsigned>, 2> HighlightedRanges;
-
- // The first segment overlaps from a previous line, so we treat it specially.
- if (WrappedSegment && WrappedSegment->HasCount && WrappedSegment->Count == 0)
- Highlight = raw_ostream::RED;
-
- // Output each segment of the line, possibly highlighted.
- unsigned Col = 1;
- for (const auto *S : Segments) {
- unsigned End = std::min(S->Col, static_cast<unsigned>(Line.size()) + 1);
- colored_ostream(OS, Highlight ? *Highlight : raw_ostream::SAVEDCOLOR,
- getOptions().Colors && Highlight, /*Bold=*/false,
- /*BG=*/true)
- << Line.substr(Col - 1, End - Col);
- if (getOptions().Debug && Highlight)
- HighlightedRanges.push_back(std::make_pair(Col, End));
- Col = End;
- if (Col == ExpansionCol)
- Highlight = raw_ostream::CYAN;
- else if (S->HasCount && S->Count == 0)
- Highlight = raw_ostream::RED;
- else
- Highlight = None;
- }
-
- // Show the rest of the line.
- colored_ostream(OS, Highlight ? *Highlight : raw_ostream::SAVEDCOLOR,
- getOptions().Colors && Highlight, /*Bold=*/false, /*BG=*/true)
- << Line.substr(Col - 1, Line.size() - Col + 1);
- OS << '\n';
-
- if (getOptions().Debug) {
- for (const auto &Range : HighlightedRanges)
- errs() << "Highlighted line " << LineNumber << ", " << Range.first
- << " -> " << Range.second << '\n';
- if (Highlight)
- errs() << "Highlighted line " << LineNumber << ", " << Col << " -> ?\n";
- }
-}
-
-void SourceCoverageViewText::renderLineCoverageColumn(
- raw_ostream &OS, const LineCoverageStats &Line) {
- if (!Line.isMapped()) {
- OS.indent(LineCoverageColumnWidth) << '|';
- return;
- }
- std::string C = formatCount(Line.ExecutionCount);
- OS.indent(LineCoverageColumnWidth - C.size());
- colored_ostream(OS, raw_ostream::MAGENTA,
- Line.hasMultipleRegions() && getOptions().Colors)
- << C;
- OS << '|';
-}
-
-void SourceCoverageViewText::renderLineNumberColumn(raw_ostream &OS,
- unsigned LineNo) {
- SmallString<32> Buffer;
- raw_svector_ostream BufferOS(Buffer);
- BufferOS << LineNo;
- auto Str = BufferOS.str();
- // Trim and align to the right.
- Str = Str.substr(0, std::min(Str.size(), (size_t)LineNumberColumnWidth));
- OS.indent(LineNumberColumnWidth - Str.size()) << Str << '|';
-}
-
-void SourceCoverageViewText::renderRegionMarkers(
- raw_ostream &OS, CoverageSegmentArray Segments, unsigned ViewDepth) {
- renderLinePrefix(OS, ViewDepth);
- OS.indent(getCombinedColumnWidth(getOptions()));
-
- unsigned PrevColumn = 1;
- for (const auto *S : Segments) {
- if (!S->IsRegionEntry)
- continue;
- // Skip to the new region.
- if (S->Col > PrevColumn)
- OS.indent(S->Col - PrevColumn);
- PrevColumn = S->Col + 1;
- std::string C = formatCount(S->Count);
- PrevColumn += C.size();
- OS << '^' << C;
- }
- OS << '\n';
-
- if (getOptions().Debug)
- for (const auto *S : Segments)
- errs() << "Marker at " << S->Line << ":" << S->Col << " = "
- << formatCount(S->Count) << (S->IsRegionEntry ? "\n" : " (pop)\n");
-}
-
-void SourceCoverageViewText::renderExpansionSite(
- raw_ostream &OS, LineRef L, const coverage::CoverageSegment *WrappedSegment,
- CoverageSegmentArray Segments, unsigned ExpansionCol, unsigned ViewDepth) {
- renderLinePrefix(OS, ViewDepth);
- OS.indent(getCombinedColumnWidth(getOptions()) + (ViewDepth == 0 ? 0 : 1));
- renderLine(OS, L, WrappedSegment, Segments, ExpansionCol, ViewDepth);
-}
-
-void SourceCoverageViewText::renderExpansionView(raw_ostream &OS,
- ExpansionView &ESV,
- unsigned ViewDepth) {
- // Render the child subview.
- if (getOptions().Debug)
- errs() << "Expansion at line " << ESV.getLine() << ", " << ESV.getStartCol()
- << " -> " << ESV.getEndCol() << '\n';
- ESV.View->print(OS, /*WholeFile=*/false, /*ShowSourceName=*/false,
- ViewDepth + 1);
-}
-
-void SourceCoverageViewText::renderInstantiationView(raw_ostream &OS,
- InstantiationView &ISV,
- unsigned ViewDepth) {
- renderLinePrefix(OS, ViewDepth);
- OS << ' ';
- ISV.View->print(OS, /*WholeFile=*/false, /*ShowSourceName=*/true, ViewDepth);
-}
diff --git a/tools/llvm-cov/SourceCoverageViewText.h b/tools/llvm-cov/SourceCoverageViewText.h
deleted file mode 100644
index b233124..0000000
--- a/tools/llvm-cov/SourceCoverageViewText.h
+++ /dev/null
@@ -1,83 +0,0 @@
-//===- SourceCoverageViewText.h - A text-based code coverage view ---------===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-///
-/// \file This file defines the interface to the text-based coverage renderer.
-///
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_COV_SOURCECOVERAGEVIEWTEXT_H
-#define LLVM_COV_SOURCECOVERAGEVIEWTEXT_H
-
-#include "SourceCoverageView.h"
-
-namespace llvm {
-
-/// \brief A coverage printer for text output.
-class CoveragePrinterText : public CoveragePrinter {
-public:
- Expected<OwnedStream> createViewFile(StringRef Path,
- bool InToplevel) override;
-
- void closeViewFile(OwnedStream OS) override;
-
- Error createIndexFile(ArrayRef<StringRef> SourceFiles) override;
-
- CoveragePrinterText(const CoverageViewOptions &Opts)
- : CoveragePrinter(Opts) {}
-};
-
-/// \brief A code coverage view which supports text-based rendering.
-class SourceCoverageViewText : public SourceCoverageView {
- void renderViewHeader(raw_ostream &OS) override;
-
- void renderViewFooter(raw_ostream &OS) override;
-
- void renderSourceName(raw_ostream &OS) override;
-
- void renderLinePrefix(raw_ostream &OS, unsigned ViewDepth) override;
-
- void renderLineSuffix(raw_ostream &OS, unsigned ViewDepth) override;
-
- void renderViewDivider(raw_ostream &OS, unsigned ViewDepth) override;
-
- void renderLine(raw_ostream &OS, LineRef L,
- const coverage::CoverageSegment *WrappedSegment,
- CoverageSegmentArray Segments, unsigned ExpansionCol,
- unsigned ViewDepth) override;
-
- void renderExpansionSite(raw_ostream &OS, LineRef L,
- const coverage::CoverageSegment *WrappedSegment,
- CoverageSegmentArray Segments, unsigned ExpansionCol,
- unsigned ViewDepth) override;
-
- void renderExpansionView(raw_ostream &OS, ExpansionView &ESV,
- unsigned ViewDepth) override;
-
- void renderInstantiationView(raw_ostream &OS, InstantiationView &ISV,
- unsigned ViewDepth) override;
-
- void renderLineCoverageColumn(raw_ostream &OS,
- const LineCoverageStats &Line) override;
-
- void renderLineNumberColumn(raw_ostream &OS, unsigned LineNo) override;
-
- void renderRegionMarkers(raw_ostream &OS, CoverageSegmentArray Segments,
- unsigned ViewDepth) override;
-
-public:
- SourceCoverageViewText(StringRef SourceName, const MemoryBuffer &File,
- const CoverageViewOptions &Options,
- coverage::CoverageData &&CoverageInfo)
- : SourceCoverageView(SourceName, File, Options, std::move(CoverageInfo)) {
- }
-};
-
-} // namespace llvm
-
-#endif // LLVM_COV_SOURCECOVERAGEVIEWTEXT_H
diff --git a/tools/llvm-cov/TestingSupport.cpp b/tools/llvm-cov/TestingSupport.cpp
index 72768f4..8b13789 100644
--- a/tools/llvm-cov/TestingSupport.cpp
+++ b/tools/llvm-cov/TestingSupport.cpp
@@ -1,92 +1 @@
-//===- TestingSupport.cpp - Convert objects files into test files --------===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-#include "llvm/Object/ObjectFile.h"
-#include "llvm/ProfileData/InstrProf.h"
-#include "llvm/Support/CommandLine.h"
-#include "llvm/Support/LEB128.h"
-#include "llvm/Support/raw_ostream.h"
-#include <functional>
-#include <system_error>
-
-using namespace llvm;
-using namespace object;
-
-int convertForTestingMain(int argc, const char *argv[]) {
- cl::opt<std::string> InputSourceFile(cl::Positional, cl::Required,
- cl::desc("<Source file>"));
-
- cl::opt<std::string> OutputFilename(
- "o", cl::Required,
- cl::desc(
- "File with the profile data obtained after an instrumented run"));
-
- cl::ParseCommandLineOptions(argc, argv, "LLVM code coverage tool\n");
-
- auto ObjErr = llvm::object::ObjectFile::createObjectFile(InputSourceFile);
- if (!ObjErr) {
- std::string Buf;
- raw_string_ostream OS(Buf);
- logAllUnhandledErrors(ObjErr.takeError(), OS, "");
- OS.flush();
- errs() << "error: " << Buf;
- return 1;
- }
- ObjectFile *OF = ObjErr.get().getBinary();
- auto BytesInAddress = OF->getBytesInAddress();
- if (BytesInAddress != 8) {
- errs() << "error: 64 bit binary expected\n";
- return 1;
- }
-
- // Look for the sections that we are interested in.
- int FoundSectionCount = 0;
- SectionRef ProfileNames, CoverageMapping;
- for (const auto &Section : OF->sections()) {
- StringRef Name;
- if (Section.getName(Name))
- return 1;
- if (Name == llvm::getInstrProfNameSectionName(false)) {
- ProfileNames = Section;
- } else if (Name == llvm::getInstrProfCoverageSectionName(false)) {
- CoverageMapping = Section;
- } else
- continue;
- ++FoundSectionCount;
- }
- if (FoundSectionCount != 2)
- return 1;
-
- // Get the contents of the given sections.
- uint64_t ProfileNamesAddress = ProfileNames.getAddress();
- StringRef CoverageMappingData;
- StringRef ProfileNamesData;
- if (CoverageMapping.getContents(CoverageMappingData) ||
- ProfileNames.getContents(ProfileNamesData))
- return 1;
-
- int FD;
- if (auto Err =
- sys::fs::openFileForWrite(OutputFilename, FD, sys::fs::F_None)) {
- errs() << "error: " << Err.message() << "\n";
- return 1;
- }
-
- raw_fd_ostream OS(FD, true);
- OS << "llvmcovmtestdata";
- encodeULEB128(ProfileNamesData.size(), OS);
- encodeULEB128(ProfileNamesAddress, OS);
- OS << ProfileNamesData;
- // Coverage mapping data is expected to have an alignment of 8.
- for (unsigned Pad = OffsetToAlignment(OS.tell(), 8); Pad; --Pad)
- OS.write(uint8_t(0));
- OS << CoverageMappingData;
-
- return 0;
-}
diff --git a/tools/llvm-cov/gcov.cpp b/tools/llvm-cov/gcov.cpp
index 4652fed..8b13789 100644
--- a/tools/llvm-cov/gcov.cpp
+++ b/tools/llvm-cov/gcov.cpp
@@ -1,145 +1 @@
-//===- gcov.cpp - GCOV compatible LLVM coverage tool ----------------------===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// llvm-cov is a command line tools to analyze and report coverage information.
-//
-//===----------------------------------------------------------------------===//
-#include "llvm/ADT/SmallString.h"
-#include "llvm/Support/CommandLine.h"
-#include "llvm/Support/Errc.h"
-#include "llvm/Support/FileSystem.h"
-#include "llvm/Support/GCOV.h"
-#include "llvm/Support/Path.h"
-#include <system_error>
-using namespace llvm;
-
-static void reportCoverage(StringRef SourceFile, StringRef ObjectDir,
- const std::string &InputGCNO,
- const std::string &InputGCDA, bool DumpGCOV,
- const GCOV::Options &Options) {
- SmallString<128> CoverageFileStem(ObjectDir);
- if (CoverageFileStem.empty()) {
- // If no directory was specified with -o, look next to the source file.
- CoverageFileStem = sys::path::parent_path(SourceFile);
- sys::path::append(CoverageFileStem, sys::path::stem(SourceFile));
- } else if (sys::fs::is_directory(ObjectDir))
- // A directory name was given. Use it and the source file name.
- sys::path::append(CoverageFileStem, sys::path::stem(SourceFile));
- else
- // A file was given. Ignore the source file and look next to this file.
- sys::path::replace_extension(CoverageFileStem, "");
-
- std::string GCNO = InputGCNO.empty()
- ? std::string(CoverageFileStem.str()) + ".gcno"
- : InputGCNO;
- std::string GCDA = InputGCDA.empty()
- ? std::string(CoverageFileStem.str()) + ".gcda"
- : InputGCDA;
- GCOVFile GF;
-
- ErrorOr<std::unique_ptr<MemoryBuffer>> GCNO_Buff =
- MemoryBuffer::getFileOrSTDIN(GCNO);
- if (std::error_code EC = GCNO_Buff.getError()) {
- errs() << GCNO << ": " << EC.message() << "\n";
- return;
- }
- GCOVBuffer GCNO_GB(GCNO_Buff.get().get());
- if (!GF.readGCNO(GCNO_GB)) {
- errs() << "Invalid .gcno File!\n";
- return;
- }
-
- ErrorOr<std::unique_ptr<MemoryBuffer>> GCDA_Buff =
- MemoryBuffer::getFileOrSTDIN(GCDA);
- if (std::error_code EC = GCDA_Buff.getError()) {
- if (EC != errc::no_such_file_or_directory) {
- errs() << GCDA << ": " << EC.message() << "\n";
- return;
- }
- // Clear the filename to make it clear we didn't read anything.
- GCDA = "-";
- } else {
- GCOVBuffer GCDA_GB(GCDA_Buff.get().get());
- if (!GF.readGCDA(GCDA_GB)) {
- errs() << "Invalid .gcda File!\n";
- return;
- }
- }
-
- if (DumpGCOV)
- GF.dump();
-
- FileInfo FI(Options);
- GF.collectLineCounts(FI);
- FI.print(llvm::outs(), SourceFile, GCNO, GCDA);
-}
-
-int gcovMain(int argc, const char *argv[]) {
- cl::list<std::string> SourceFiles(cl::Positional, cl::OneOrMore,
- cl::desc("SOURCEFILE"));
-
- cl::opt<bool> AllBlocks("a", cl::Grouping, cl::init(false),
- cl::desc("Display all basic blocks"));
- cl::alias AllBlocksA("all-blocks", cl::aliasopt(AllBlocks));
-
- cl::opt<bool> BranchProb("b", cl::Grouping, cl::init(false),
- cl::desc("Display branch probabilities"));
- cl::alias BranchProbA("branch-probabilities", cl::aliasopt(BranchProb));
-
- cl::opt<bool> BranchCount("c", cl::Grouping, cl::init(false),
- cl::desc("Display branch counts instead "
- "of percentages (requires -b)"));
- cl::alias BranchCountA("branch-counts", cl::aliasopt(BranchCount));
-
- cl::opt<bool> LongNames("l", cl::Grouping, cl::init(false),
- cl::desc("Prefix filenames with the main file"));
- cl::alias LongNamesA("long-file-names", cl::aliasopt(LongNames));
-
- cl::opt<bool> FuncSummary("f", cl::Grouping, cl::init(false),
- cl::desc("Show coverage for each function"));
- cl::alias FuncSummaryA("function-summaries", cl::aliasopt(FuncSummary));
-
- cl::opt<bool> NoOutput("n", cl::Grouping, cl::init(false),
- cl::desc("Do not output any .gcov files"));
- cl::alias NoOutputA("no-output", cl::aliasopt(NoOutput));
-
- cl::opt<std::string> ObjectDir(
- "o", cl::value_desc("DIR|FILE"), cl::init(""),
- cl::desc("Find objects in DIR or based on FILE's path"));
- cl::alias ObjectDirA("object-directory", cl::aliasopt(ObjectDir));
- cl::alias ObjectDirB("object-file", cl::aliasopt(ObjectDir));
-
- cl::opt<bool> PreservePaths("p", cl::Grouping, cl::init(false),
- cl::desc("Preserve path components"));
- cl::alias PreservePathsA("preserve-paths", cl::aliasopt(PreservePaths));
-
- cl::opt<bool> UncondBranch("u", cl::Grouping, cl::init(false),
- cl::desc("Display unconditional branch info "
- "(requires -b)"));
- cl::alias UncondBranchA("unconditional-branches", cl::aliasopt(UncondBranch));
-
- cl::OptionCategory DebugCat("Internal and debugging options");
- cl::opt<bool> DumpGCOV("dump", cl::init(false), cl::cat(DebugCat),
- cl::desc("Dump the gcov file to stderr"));
- cl::opt<std::string> InputGCNO("gcno", cl::cat(DebugCat), cl::init(""),
- cl::desc("Override inferred gcno file"));
- cl::opt<std::string> InputGCDA("gcda", cl::cat(DebugCat), cl::init(""),
- cl::desc("Override inferred gcda file"));
-
- cl::ParseCommandLineOptions(argc, argv, "LLVM code coverage tool\n");
-
- GCOV::Options Options(AllBlocks, BranchProb, BranchCount, FuncSummary,
- PreservePaths, UncondBranch, LongNames, NoOutput);
-
- for (const auto &SourceFile : SourceFiles)
- reportCoverage(SourceFile, ObjectDir, InputGCNO, InputGCDA, DumpGCOV,
- Options);
- return 0;
-}
diff --git a/tools/llvm-cov/llvm-cov.cpp b/tools/llvm-cov/llvm-cov.cpp
index ba60cd9..aa1f228 100644
--- a/tools/llvm-cov/llvm-cov.cpp
+++ b/tools/llvm-cov/llvm-cov.cpp
@@ -10,85 +10,6 @@
// llvm-cov is a command line tools to analyze and report coverage information.
//
//===----------------------------------------------------------------------===//
-
-#include "llvm/ADT/StringRef.h"
-#include "llvm/ADT/StringSwitch.h"
-#include "llvm/Support/CommandLine.h"
-#include "llvm/Support/ManagedStatic.h"
-#include "llvm/Support/Path.h"
-#include "llvm/Support/PrettyStackTrace.h"
-#include "llvm/Support/Process.h"
-#include "llvm/Support/Signals.h"
-#include "llvm/Support/raw_ostream.h"
-#include <string>
-
-using namespace llvm;
-
-/// \brief The main entry point for the 'show' subcommand.
-int showMain(int argc, const char *argv[]);
-
-/// \brief The main entry point for the 'report' subcommand.
-int reportMain(int argc, const char *argv[]);
-
-/// \brief The main entry point for the 'convert-for-testing' subcommand.
-int convertForTestingMain(int argc, const char *argv[]);
-
-/// \brief The main entry point for the gcov compatible coverage tool.
-int gcovMain(int argc, const char *argv[]);
-
-/// \brief Top level help.
-static int helpMain(int argc, const char *argv[]) {
- errs() << "Usage: llvm-cov {gcov|report|show} [OPTION]...\n\n"
- << "Shows code coverage information.\n\n"
- << "Subcommands:\n"
- << " gcov: Work with the gcov format.\n"
- << " show: Annotate source files using instrprof style coverage.\n"
- << " report: Summarize instrprof style coverage information.\n";
- return 0;
-}
-
-/// \brief Top level version information.
-static int versionMain(int argc, const char *argv[]) {
- cl::PrintVersionMessage();
- return 0;
-}
-
int main(int argc, const char **argv) {
- // Print a stack trace if we signal out.
- sys::PrintStackTraceOnErrorSignal(argv[0]);
- PrettyStackTraceProgram X(argc, argv);
- llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
-
- // If argv[0] is or ends with 'gcov', always be gcov compatible
- if (sys::path::stem(argv[0]).endswith_lower("gcov"))
- return gcovMain(argc, argv);
-
- // Check if we are invoking a specific tool command.
- if (argc > 1) {
- typedef int (*MainFunction)(int, const char *[]);
- MainFunction Func = StringSwitch<MainFunction>(argv[1])
- .Case("convert-for-testing", convertForTestingMain)
- .Case("gcov", gcovMain)
- .Case("report", reportMain)
- .Case("show", showMain)
- .Cases("-h", "-help", "--help", helpMain)
- .Cases("-version", "--version", versionMain)
- .Default(nullptr);
-
- if (Func) {
- std::string Invocation = std::string(argv[0]) + " " + argv[1];
- argv[1] = Invocation.c_str();
- return Func(argc - 1, argv + 1);
- }
- }
-
- if (argc > 1) {
- if (sys::Process::StandardErrHasColors())
- errs().changeColor(raw_ostream::RED);
- errs() << "Unrecognized command: " << argv[1] << ".\n\n";
- if (sys::Process::StandardErrHasColors())
- errs().resetColor();
- }
- helpMain(argc, argv);
return 1;
}
diff --git a/tools/sancov/sancov.cc b/tools/sancov/sancov.cc
index 55b0370..c869a73 100644
--- a/tools/sancov/sancov.cc
+++ b/tools/sancov/sancov.cc
@@ -10,1249 +10,7 @@
// This file is a command-line tool for reading and analyzing sanitizer
// coverage.
//===----------------------------------------------------------------------===//
-#include "llvm/ADT/STLExtras.h"
-#include "llvm/ADT/Twine.h"
-#include "llvm/DebugInfo/Symbolize/Symbolize.h"
-#include "llvm/MC/MCAsmInfo.h"
-#include "llvm/MC/MCContext.h"
-#include "llvm/MC/MCDisassembler/MCDisassembler.h"
-#include "llvm/MC/MCInst.h"
-#include "llvm/MC/MCInstPrinter.h"
-#include "llvm/MC/MCInstrAnalysis.h"
-#include "llvm/MC/MCInstrInfo.h"
-#include "llvm/MC/MCObjectFileInfo.h"
-#include "llvm/MC/MCRegisterInfo.h"
-#include "llvm/MC/MCSubtargetInfo.h"
-#include "llvm/Object/Archive.h"
-#include "llvm/Object/Binary.h"
-#include "llvm/Object/ELFObjectFile.h"
-#include "llvm/Object/ObjectFile.h"
-#include "llvm/Support/Casting.h"
-#include "llvm/Support/CommandLine.h"
-#include "llvm/Support/Errc.h"
-#include "llvm/Support/ErrorOr.h"
-#include "llvm/Support/FileSystem.h"
-#include "llvm/Support/LineIterator.h"
-#include "llvm/Support/MD5.h"
-#include "llvm/Support/ManagedStatic.h"
-#include "llvm/Support/MemoryBuffer.h"
-#include "llvm/Support/Path.h"
-#include "llvm/Support/PrettyStackTrace.h"
-#include "llvm/Support/Regex.h"
-#include "llvm/Support/Signals.h"
-#include "llvm/Support/SpecialCaseList.h"
-#include "llvm/Support/TargetRegistry.h"
-#include "llvm/Support/TargetSelect.h"
-#include "llvm/Support/ToolOutputFile.h"
-#include "llvm/Support/raw_ostream.h"
-
-#include <algorithm>
-#include <set>
-#include <stdio.h>
-#include <string>
-#include <utility>
-#include <vector>
-
-using namespace llvm;
-
-namespace {
-
-// --------- COMMAND LINE FLAGS ---------
-
-enum ActionType {
- PrintAction,
- PrintCovPointsAction,
- CoveredFunctionsAction,
- NotCoveredFunctionsAction,
- HtmlReportAction,
- StatsAction
-};
-
-cl::opt<ActionType> Action(
- cl::desc("Action (required)"), cl::Required,
- cl::values(clEnumValN(PrintAction, "print", "Print coverage addresses"),
- clEnumValN(PrintCovPointsAction, "print-coverage-pcs",
- "Print coverage instrumentation points addresses."),
- clEnumValN(CoveredFunctionsAction, "covered-functions",
- "Print all covered funcions."),
- clEnumValN(NotCoveredFunctionsAction, "not-covered-functions",
- "Print all not covered funcions."),
- clEnumValN(HtmlReportAction, "html-report",
- "Print HTML coverage report."),
- clEnumValN(StatsAction, "print-coverage-stats",
- "Print coverage statistics."),
- clEnumValEnd));
-
-static cl::list<std::string>
- ClInputFiles(cl::Positional, cl::OneOrMore,
- cl::desc("(<binary file>|<.sancov file>)..."));
-
-static cl::opt<bool> ClDemangle("demangle", cl::init(true),
- cl::desc("Print demangled function name."));
-
-static cl::opt<std::string> ClStripPathPrefix(
- "strip_path_prefix", cl::init(""),
- cl::desc("Strip this prefix from file paths in reports."));
-
-static cl::opt<std::string>
- ClBlacklist("blacklist", cl::init(""),
- cl::desc("Blacklist file (sanitizer blacklist format)."));
-
-static cl::opt<bool> ClUseDefaultBlacklist(
- "use_default_blacklist", cl::init(true), cl::Hidden,
- cl::desc("Controls if default blacklist should be used."));
-
-static const char *const DefaultBlacklistStr = "fun:__sanitizer_.*\n"
- "src:/usr/include/.*\n"
- "src:.*/libc\\+\\+/.*\n";
-
-// --------- FORMAT SPECIFICATION ---------
-
-struct FileHeader {
- uint32_t Bitness;
- uint32_t Magic;
-};
-
-static const uint32_t BinCoverageMagic = 0xC0BFFFFF;
-static const uint32_t Bitness32 = 0xFFFFFF32;
-static const uint32_t Bitness64 = 0xFFFFFF64;
-
-// --------- ERROR HANDLING ---------
-
-static void Fail(const llvm::Twine &E) {
- errs() << "Error: " << E << "\n";
- exit(1);
-}
-
-static void FailIfError(std::error_code Error) {
- if (!Error)
- return;
- errs() << "Error: " << Error.message() << "(" << Error.value() << ")\n";
- exit(1);
-}
-
-template <typename T> static void FailIfError(const ErrorOr<T> &E) {
- FailIfError(E.getError());
-}
-
-static void FailIfError(Error Err) {
- if (Err) {
- logAllUnhandledErrors(std::move(Err), errs(), "Error: ");
- exit(1);
- }
-}
-
-template <typename T> static void FailIfError(Expected<T> &E) {
- FailIfError(E.takeError());
-}
-
-static void FailIfNotEmpty(const llvm::Twine &E) {
- if (E.str().empty())
- return;
- Fail(E);
-}
-
-template <typename T>
-static void FailIfEmpty(const std::unique_ptr<T> &Ptr,
- const std::string &Message) {
- if (Ptr.get())
- return;
- Fail(Message);
-}
-
-// ---------
-
-// Produces std::map<K, std::vector<E>> grouping input
-// elements by FuncTy result.
-template <class RangeTy, class FuncTy>
-static inline auto group_by(const RangeTy &R, FuncTy F)
- -> std::map<typename std::decay<decltype(F(*R.begin()))>::type,
- std::vector<typename std::decay<decltype(*R.begin())>::type>> {
- std::map<typename std::decay<decltype(F(*R.begin()))>::type,
- std::vector<typename std::decay<decltype(*R.begin())>::type>>
- Result;
- for (const auto &E : R) {
- Result[F(E)].push_back(E);
- }
- return Result;
-}
-
-template <typename T>
-static void readInts(const char *Start, const char *End,
- std::set<uint64_t> *Ints) {
- const T *S = reinterpret_cast<const T *>(Start);
- const T *E = reinterpret_cast<const T *>(End);
- std::copy(S, E, std::inserter(*Ints, Ints->end()));
-}
-
-struct FileLoc {
- bool operator<(const FileLoc &RHS) const {
- return std::tie(FileName, Line) < std::tie(RHS.FileName, RHS.Line);
- }
-
- std::string FileName;
- uint32_t Line;
-};
-
-struct FileFn {
- bool operator<(const FileFn &RHS) const {
- return std::tie(FileName, FunctionName) <
- std::tie(RHS.FileName, RHS.FunctionName);
- }
-
- std::string FileName;
- std::string FunctionName;
-};
-
-struct FnLoc {
- bool operator<(const FnLoc &RHS) const {
- return std::tie(Loc, FunctionName) < std::tie(RHS.Loc, RHS.FunctionName);
- }
-
- FileLoc Loc;
- std::string FunctionName;
-};
-
-std::string stripPathPrefix(std::string Path) {
- if (ClStripPathPrefix.empty())
- return Path;
- size_t Pos = Path.find(ClStripPathPrefix);
- if (Pos == std::string::npos)
- return Path;
- return Path.substr(Pos + ClStripPathPrefix.size());
-}
-
-static std::unique_ptr<symbolize::LLVMSymbolizer> createSymbolizer() {
- symbolize::LLVMSymbolizer::Options SymbolizerOptions;
- SymbolizerOptions.Demangle = ClDemangle;
- SymbolizerOptions.UseSymbolTable = true;
- return std::unique_ptr<symbolize::LLVMSymbolizer>(
- new symbolize::LLVMSymbolizer(SymbolizerOptions));
-}
-
-// A DILineInfo with address.
-struct AddrInfo : public DILineInfo {
- uint64_t Addr;
-
- AddrInfo(const DILineInfo &DI, uint64_t Addr) : DILineInfo(DI), Addr(Addr) {
- FileName = normalizeFilename(FileName);
- }
-
-private:
- static std::string normalizeFilename(const std::string &FileName) {
- SmallString<256> S(FileName);
- sys::path::remove_dots(S, /* remove_dot_dot */ true);
- return S.str().str();
- }
-};
-
-class Blacklists {
-public:
- Blacklists()
- : DefaultBlacklist(createDefaultBlacklist()),
- UserBlacklist(createUserBlacklist()) {}
-
- // AddrInfo contains normalized filename. It is important to check it rather
- // than DILineInfo.
- bool isBlacklisted(const AddrInfo &AI) {
- if (DefaultBlacklist && DefaultBlacklist->inSection("fun", AI.FunctionName))
- return true;
- if (DefaultBlacklist && DefaultBlacklist->inSection("src", AI.FileName))
- return true;
- if (UserBlacklist && UserBlacklist->inSection("fun", AI.FunctionName))
- return true;
- if (UserBlacklist && UserBlacklist->inSection("src", AI.FileName))
- return true;
- return false;
- }
-
-private:
- static std::unique_ptr<SpecialCaseList> createDefaultBlacklist() {
- if (!ClUseDefaultBlacklist)
- return std::unique_ptr<SpecialCaseList>();
- std::unique_ptr<MemoryBuffer> MB =
- MemoryBuffer::getMemBuffer(DefaultBlacklistStr);
- std::string Error;
- auto Blacklist = SpecialCaseList::create(MB.get(), Error);
- FailIfNotEmpty(Error);
- return Blacklist;
- }
-
- static std::unique_ptr<SpecialCaseList> createUserBlacklist() {
- if (ClBlacklist.empty())
- return std::unique_ptr<SpecialCaseList>();
-
- return SpecialCaseList::createOrDie({{ClBlacklist}});
- }
- std::unique_ptr<SpecialCaseList> DefaultBlacklist;
- std::unique_ptr<SpecialCaseList> UserBlacklist;
-};
-
-// Collect all debug info for given addresses.
-static std::vector<AddrInfo> getAddrInfo(const std::string &ObjectFile,
- const std::set<uint64_t> &Addrs,
- bool InlinedCode) {
- std::vector<AddrInfo> Result;
- auto Symbolizer(createSymbolizer());
- Blacklists B;
-
- for (auto Addr : Addrs) {
- auto LineInfo = Symbolizer->symbolizeCode(ObjectFile, Addr);
- FailIfError(LineInfo);
- auto LineAddrInfo = AddrInfo(*LineInfo, Addr);
- if (B.isBlacklisted(LineAddrInfo))
- continue;
- Result.push_back(LineAddrInfo);
- if (InlinedCode) {
- auto InliningInfo = Symbolizer->symbolizeInlinedCode(ObjectFile, Addr);
- FailIfError(InliningInfo);
- for (uint32_t I = 0; I < InliningInfo->getNumberOfFrames(); ++I) {
- auto FrameInfo = InliningInfo->getFrame(I);
- auto FrameAddrInfo = AddrInfo(FrameInfo, Addr);
- if (B.isBlacklisted(FrameAddrInfo))
- continue;
- Result.push_back(FrameAddrInfo);
- }
- }
- }
-
- return Result;
-}
-
-// Locate __sanitizer_cov* function addresses that are used for coverage
-// reporting.
-static std::set<uint64_t>
-findSanitizerCovFunctions(const object::ObjectFile &O) {
- std::set<uint64_t> Result;
-
- for (const object::SymbolRef &Symbol : O.symbols()) {
- Expected<uint64_t> AddressOrErr = Symbol.getAddress();
- FailIfError(errorToErrorCode(AddressOrErr.takeError()));
-
- Expected<StringRef> NameOrErr = Symbol.getName();
- FailIfError(errorToErrorCode(NameOrErr.takeError()));
- StringRef Name = NameOrErr.get();
-
- if (Name == "__sanitizer_cov" || Name == "__sanitizer_cov_with_check" ||
- Name == "__sanitizer_cov_trace_func_enter") {
- if (!(Symbol.getFlags() & object::BasicSymbolRef::SF_Undefined))
- Result.insert(AddressOrErr.get());
- }
- }
-
- return Result;
-}
-
-// Locate addresses of all coverage points in a file. Coverage point
-// is defined as the 'address of instruction following __sanitizer_cov
-// call - 1'.
-static void getObjectCoveragePoints(const object::ObjectFile &O,
- std::set<uint64_t> *Addrs) {
- Triple TheTriple("unknown-unknown-unknown");
- TheTriple.setArch(Triple::ArchType(O.getArch()));
- auto TripleName = TheTriple.getTriple();
-
- std::string Error;
- const Target *TheTarget = TargetRegistry::lookupTarget(TripleName, Error);
- FailIfNotEmpty(Error);
-
- std::unique_ptr<const MCSubtargetInfo> STI(
- TheTarget->createMCSubtargetInfo(TripleName, "", ""));
- FailIfEmpty(STI, "no subtarget info for target " + TripleName);
-
- std::unique_ptr<const MCRegisterInfo> MRI(
- TheTarget->createMCRegInfo(TripleName));
- FailIfEmpty(MRI, "no register info for target " + TripleName);
-
- std::unique_ptr<const MCAsmInfo> AsmInfo(
- TheTarget->createMCAsmInfo(*MRI, TripleName));
- FailIfEmpty(AsmInfo, "no asm info for target " + TripleName);
-
- std::unique_ptr<const MCObjectFileInfo> MOFI(new MCObjectFileInfo);
- MCContext Ctx(AsmInfo.get(), MRI.get(), MOFI.get());
- std::unique_ptr<MCDisassembler> DisAsm(
- TheTarget->createMCDisassembler(*STI, Ctx));
- FailIfEmpty(DisAsm, "no disassembler info for target " + TripleName);
-
- std::unique_ptr<const MCInstrInfo> MII(TheTarget->createMCInstrInfo());
- FailIfEmpty(MII, "no instruction info for target " + TripleName);
-
- std::unique_ptr<const MCInstrAnalysis> MIA(
- TheTarget->createMCInstrAnalysis(MII.get()));
- FailIfEmpty(MIA, "no instruction analysis info for target " + TripleName);
-
- auto SanCovAddrs = findSanitizerCovFunctions(O);
- if (SanCovAddrs.empty())
- Fail("__sanitizer_cov* functions not found");
-
- for (object::SectionRef Section : O.sections()) {
- if (Section.isVirtual() || !Section.isText()) // llvm-objdump does the same.
- continue;
- uint64_t SectionAddr = Section.getAddress();
- uint64_t SectSize = Section.getSize();
- if (!SectSize)
- continue;
-
- StringRef BytesStr;
- FailIfError(Section.getContents(BytesStr));
- ArrayRef<uint8_t> Bytes(reinterpret_cast<const uint8_t *>(BytesStr.data()),
- BytesStr.size());
-
- for (uint64_t Index = 0, Size = 0; Index < Section.getSize();
- Index += Size) {
- MCInst Inst;
- if (!DisAsm->getInstruction(Inst, Size, Bytes.slice(Index),
- SectionAddr + Index, nulls(), nulls())) {
- if (Size == 0)
- Size = 1;
- continue;
- }
- uint64_t Addr = Index + SectionAddr;
- // Sanitizer coverage uses the address of the next instruction - 1.
- uint64_t CovPoint = Addr + Size - 1;
- uint64_t Target;
- if (MIA->isCall(Inst) &&
- MIA->evaluateBranch(Inst, SectionAddr + Index, Size, Target) &&
- SanCovAddrs.find(Target) != SanCovAddrs.end())
- Addrs->insert(CovPoint);
- }
- }
-}
-
-static void
-visitObjectFiles(const object::Archive &A,
- function_ref<void(const object::ObjectFile &)> Fn) {
- Error Err;
- for (auto &C : A.children(Err)) {
- Expected<std::unique_ptr<object::Binary>> ChildOrErr = C.getAsBinary();
- FailIfError(errorToErrorCode(ChildOrErr.takeError()));
- if (auto *O = dyn_cast<object::ObjectFile>(&*ChildOrErr.get()))
- Fn(*O);
- else
- FailIfError(object::object_error::invalid_file_type);
- }
- FailIfError(std::move(Err));
-}
-
-static void
-visitObjectFiles(const std::string &FileName,
- function_ref<void(const object::ObjectFile &)> Fn) {
- Expected<object::OwningBinary<object::Binary>> BinaryOrErr =
- object::createBinary(FileName);
- if (!BinaryOrErr)
- FailIfError(errorToErrorCode(BinaryOrErr.takeError()));
-
- object::Binary &Binary = *BinaryOrErr.get().getBinary();
- if (object::Archive *A = dyn_cast<object::Archive>(&Binary))
- visitObjectFiles(*A, Fn);
- else if (object::ObjectFile *O = dyn_cast<object::ObjectFile>(&Binary))
- Fn(*O);
- else
- FailIfError(object::object_error::invalid_file_type);
-}
-
-std::set<uint64_t> findSanitizerCovFunctions(const std::string &FileName) {
- std::set<uint64_t> Result;
- visitObjectFiles(FileName, [&](const object::ObjectFile &O) {
- auto Addrs = findSanitizerCovFunctions(O);
- Result.insert(Addrs.begin(), Addrs.end());
- });
- return Result;
-}
-
-// Locate addresses of all coverage points in a file. Coverage point
-// is defined as the 'address of instruction following __sanitizer_cov
-// call - 1'.
-std::set<uint64_t> getCoveragePoints(const std::string &FileName) {
- std::set<uint64_t> Result;
- visitObjectFiles(FileName, [&](const object::ObjectFile &O) {
- getObjectCoveragePoints(O, &Result);
- });
- return Result;
-}
-
-static void printCovPoints(const std::string &ObjFile, raw_ostream &OS) {
- for (uint64_t Addr : getCoveragePoints(ObjFile)) {
- OS << "0x";
- OS.write_hex(Addr);
- OS << "\n";
- }
-}
-
-static std::string escapeHtml(const std::string &S) {
- std::string Result;
- Result.reserve(S.size());
- for (char Ch : S) {
- switch (Ch) {
- case '&':
- Result.append("&");
- break;
- case '\'':
- Result.append("'");
- break;
- case '"':
- Result.append(""");
- break;
- case '<':
- Result.append("<");
- break;
- case '>':
- Result.append(">");
- break;
- default:
- Result.push_back(Ch);
- break;
- }
- }
- return Result;
-}
-
-// Adds leading zeroes wrapped in 'lz' style.
-// Leading zeroes help locate 000% coverage.
-static std::string formatHtmlPct(size_t Pct) {
- Pct = std::max(std::size_t{0}, std::min(std::size_t{100}, Pct));
-
- std::string Num = std::to_string(Pct);
- std::string Zeroes(3 - Num.size(), '0');
- if (!Zeroes.empty())
- Zeroes = "<span class='lz'>" + Zeroes + "</span>";
-
- return Zeroes + Num;
-}
-
-static std::string anchorName(const std::string &Anchor) {
- llvm::MD5 Hasher;
- llvm::MD5::MD5Result Hash;
- Hasher.update(Anchor);
- Hasher.final(Hash);
-
- SmallString<32> HexString;
- llvm::MD5::stringifyResult(Hash, HexString);
- return HexString.str().str();
-}
-
-static ErrorOr<bool> isCoverageFile(const std::string &FileName) {
- ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr =
- MemoryBuffer::getFile(FileName);
- if (!BufOrErr) {
- errs() << "Warning: " << BufOrErr.getError().message() << "("
- << BufOrErr.getError().value()
- << "), filename: " << llvm::sys::path::filename(FileName) << "\n";
- return BufOrErr.getError();
- }
- std::unique_ptr<MemoryBuffer> Buf = std::move(BufOrErr.get());
- if (Buf->getBufferSize() < 8) {
- return false;
- }
- const FileHeader *Header =
- reinterpret_cast<const FileHeader *>(Buf->getBufferStart());
- return Header->Magic == BinCoverageMagic;
-}
-
-struct CoverageStats {
- CoverageStats() : AllPoints(0), CovPoints(0), AllFns(0), CovFns(0) {}
-
- size_t AllPoints;
- size_t CovPoints;
- size_t AllFns;
- size_t CovFns;
-};
-
-static raw_ostream &operator<<(raw_ostream &OS, const CoverageStats &Stats) {
- OS << "all-edges: " << Stats.AllPoints << "\n";
- OS << "cov-edges: " << Stats.CovPoints << "\n";
- OS << "all-functions: " << Stats.AllFns << "\n";
- OS << "cov-functions: " << Stats.CovFns << "\n";
- return OS;
-}
-
-class CoverageData {
-public:
- // Read single file coverage data.
- static ErrorOr<std::unique_ptr<CoverageData>>
- read(const std::string &FileName) {
- ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr =
- MemoryBuffer::getFile(FileName);
- if (!BufOrErr)
- return BufOrErr.getError();
- std::unique_ptr<MemoryBuffer> Buf = std::move(BufOrErr.get());
- if (Buf->getBufferSize() < 8) {
- errs() << "File too small (<8): " << Buf->getBufferSize();
- return make_error_code(errc::illegal_byte_sequence);
- }
- const FileHeader *Header =
- reinterpret_cast<const FileHeader *>(Buf->getBufferStart());
-
- if (Header->Magic != BinCoverageMagic) {
- errs() << "Wrong magic: " << Header->Magic;
- return make_error_code(errc::illegal_byte_sequence);
- }
-
- auto Addrs = llvm::make_unique<std::set<uint64_t>>();
-
- switch (Header->Bitness) {
- case Bitness64:
- readInts<uint64_t>(Buf->getBufferStart() + 8, Buf->getBufferEnd(),
- Addrs.get());
- break;
- case Bitness32:
- readInts<uint32_t>(Buf->getBufferStart() + 8, Buf->getBufferEnd(),
- Addrs.get());
- break;
- default:
- errs() << "Unsupported bitness: " << Header->Bitness;
- return make_error_code(errc::illegal_byte_sequence);
- }
-
- return std::unique_ptr<CoverageData>(new CoverageData(std::move(Addrs)));
- }
-
- // Merge multiple coverage data together.
- static std::unique_ptr<CoverageData>
- merge(const std::vector<std::unique_ptr<CoverageData>> &Covs) {
- auto Addrs = llvm::make_unique<std::set<uint64_t>>();
-
- for (const auto &Cov : Covs)
- Addrs->insert(Cov->Addrs->begin(), Cov->Addrs->end());
-
- return std::unique_ptr<CoverageData>(new CoverageData(std::move(Addrs)));
- }
-
- // Read list of files and merges their coverage info.
- static ErrorOr<std::unique_ptr<CoverageData>>
- readAndMerge(const std::vector<std::string> &FileNames) {
- std::vector<std::unique_ptr<CoverageData>> Covs;
- for (const auto &FileName : FileNames) {
- auto Cov = read(FileName);
- if (!Cov)
- return Cov.getError();
- Covs.push_back(std::move(Cov.get()));
- }
- return merge(Covs);
- }
-
- // Print coverage addresses.
- void printAddrs(raw_ostream &OS) {
- for (auto Addr : *Addrs) {
- OS << "0x";
- OS.write_hex(Addr);
- OS << "\n";
- }
- }
-
-protected:
- explicit CoverageData(std::unique_ptr<std::set<uint64_t>> Addrs)
- : Addrs(std::move(Addrs)) {}
-
- friend class CoverageDataWithObjectFile;
-
- std::unique_ptr<std::set<uint64_t>> Addrs;
-};
-
-// Coverage data translated into source code line-level information.
-// Fetches debug info in constructor and calculates various information per
-// request.
-class SourceCoverageData {
-public:
- enum LineStatus {
- // coverage information for the line is not available.
- // default value in maps.
- UNKNOWN = 0,
- // the line is fully covered.
- COVERED = 1,
- // the line is fully uncovered.
- NOT_COVERED = 2,
- // some points in the line a covered, some are not.
- MIXED = 3
- };
-
- SourceCoverageData(std::string ObjectFile, const std::set<uint64_t> &Addrs)
- : AllCovPoints(getCoveragePoints(ObjectFile)) {
- if (!std::includes(AllCovPoints.begin(), AllCovPoints.end(), Addrs.begin(),
- Addrs.end())) {
- Fail("Coverage points in binary and .sancov file do not match.");
- }
-
- AllAddrInfo = getAddrInfo(ObjectFile, AllCovPoints, true);
- CovAddrInfo = getAddrInfo(ObjectFile, Addrs, true);
- }
-
- // Compute number of coverage points hit/total in a file.
- // file_name -> <coverage, all_coverage>
- std::map<std::string, std::pair<size_t, size_t>> computeFileCoverage() {
- std::map<std::string, std::pair<size_t, size_t>> FileCoverage;
- auto AllCovPointsByFile =
- group_by(AllAddrInfo, [](const AddrInfo &AI) { return AI.FileName; });
- auto CovPointsByFile =
- group_by(CovAddrInfo, [](const AddrInfo &AI) { return AI.FileName; });
-
- for (const auto &P : AllCovPointsByFile) {
- const std::string &FileName = P.first;
-
- FileCoverage[FileName] =
- std::make_pair(CovPointsByFile[FileName].size(),
- AllCovPointsByFile[FileName].size());
- }
- return FileCoverage;
- }
-
- // line_number -> line_status.
- typedef std::map<int, LineStatus> LineStatusMap;
- // file_name -> LineStatusMap
- typedef std::map<std::string, LineStatusMap> FileLineStatusMap;
-
- // fills in the {file_name -> {line_no -> status}} map.
- FileLineStatusMap computeLineStatusMap() {
- FileLineStatusMap StatusMap;
-
- auto AllLocs = group_by(AllAddrInfo, [](const AddrInfo &AI) {
- return FileLoc{AI.FileName, AI.Line};
- });
- auto CovLocs = group_by(CovAddrInfo, [](const AddrInfo &AI) {
- return FileLoc{AI.FileName, AI.Line};
- });
-
- for (const auto &P : AllLocs) {
- const FileLoc &Loc = P.first;
- auto I = CovLocs.find(Loc);
-
- if (I == CovLocs.end()) {
- StatusMap[Loc.FileName][Loc.Line] = NOT_COVERED;
- } else {
- StatusMap[Loc.FileName][Loc.Line] =
- (I->second.size() == P.second.size()) ? COVERED : MIXED;
- }
- }
- return StatusMap;
- }
-
- std::set<FileFn> computeAllFunctions() const {
- std::set<FileFn> Fns;
- for (const auto &AI : AllAddrInfo) {
- Fns.insert(FileFn{AI.FileName, AI.FunctionName});
- }
- return Fns;
- }
-
- std::set<FileFn> computeCoveredFunctions() const {
- std::set<FileFn> Fns;
- auto CovFns = group_by(CovAddrInfo, [](const AddrInfo &AI) {
- return FileFn{AI.FileName, AI.FunctionName};
- });
-
- for (const auto &P : CovFns) {
- Fns.insert(P.first);
- }
- return Fns;
- }
-
- std::set<FileFn> computeNotCoveredFunctions() const {
- std::set<FileFn> Fns;
-
- auto AllFns = group_by(AllAddrInfo, [](const AddrInfo &AI) {
- return FileFn{AI.FileName, AI.FunctionName};
- });
- auto CovFns = group_by(CovAddrInfo, [](const AddrInfo &AI) {
- return FileFn{AI.FileName, AI.FunctionName};
- });
-
- for (const auto &P : AllFns) {
- if (CovFns.find(P.first) == CovFns.end()) {
- Fns.insert(P.first);
- }
- }
- return Fns;
- }
-
- // Compute % coverage for each function.
- std::map<FileFn, int> computeFunctionsCoverage() const {
- std::map<FileFn, int> FnCoverage;
- auto AllFns = group_by(AllAddrInfo, [](const AddrInfo &AI) {
- return FileFn{AI.FileName, AI.FunctionName};
- });
-
- auto CovFns = group_by(CovAddrInfo, [](const AddrInfo &AI) {
- return FileFn{AI.FileName, AI.FunctionName};
- });
-
- for (const auto &P : AllFns) {
- FileFn F = P.first;
- FnCoverage[F] = CovFns[F].size() * 100 / P.second.size();
- }
-
- return FnCoverage;
- }
-
- typedef std::map<FileLoc, std::set<std::string>> FunctionLocs;
- // finds first line number in a file for each function.
- FunctionLocs resolveFunctions(const std::set<FileFn> &Fns) const {
- std::vector<AddrInfo> FnAddrs;
- for (const auto &AI : AllAddrInfo) {
- if (Fns.find(FileFn{AI.FileName, AI.FunctionName}) != Fns.end())
- FnAddrs.push_back(AI);
- }
-
- auto GroupedAddrs = group_by(FnAddrs, [](const AddrInfo &AI) {
- return FnLoc{FileLoc{AI.FileName, AI.Line}, AI.FunctionName};
- });
-
- FunctionLocs Result;
- std::string LastFileName;
- std::set<std::string> ProcessedFunctions;
-
- for (const auto &P : GroupedAddrs) {
- const FnLoc &Loc = P.first;
- std::string FileName = Loc.Loc.FileName;
- std::string FunctionName = Loc.FunctionName;
-
- if (LastFileName != FileName)
- ProcessedFunctions.clear();
- LastFileName = FileName;
-
- if (!ProcessedFunctions.insert(FunctionName).second)
- continue;
-
- auto FLoc = FileLoc{FileName, Loc.Loc.Line};
- Result[FLoc].insert(FunctionName);
- }
- return Result;
- }
-
- std::set<std::string> files() const {
- std::set<std::string> Files;
- for (const auto &AI : AllAddrInfo) {
- Files.insert(AI.FileName);
- }
- return Files;
- }
-
- void collectStats(CoverageStats *Stats) const {
- Stats->AllPoints += AllCovPoints.size();
- Stats->AllFns += computeAllFunctions().size();
- Stats->CovFns += computeCoveredFunctions().size();
- }
-
-private:
- const std::set<uint64_t> AllCovPoints;
-
- std::vector<AddrInfo> AllAddrInfo;
- std::vector<AddrInfo> CovAddrInfo;
-};
-
-static void printFunctionLocs(const SourceCoverageData::FunctionLocs &FnLocs,
- raw_ostream &OS) {
- for (const auto &Fns : FnLocs) {
- for (const auto &Fn : Fns.second) {
- OS << stripPathPrefix(Fns.first.FileName) << ":" << Fns.first.Line << " "
- << Fn << "\n";
- }
- }
-}
-
-// Holder for coverage data + filename of corresponding object file.
-class CoverageDataWithObjectFile : public CoverageData {
-public:
- static ErrorOr<std::unique_ptr<CoverageDataWithObjectFile>>
- readAndMerge(const std::string &ObjectFile,
- const std::vector<std::string> &FileNames) {
- auto MergedDataOrError = CoverageData::readAndMerge(FileNames);
- if (!MergedDataOrError)
- return MergedDataOrError.getError();
- return std::unique_ptr<CoverageDataWithObjectFile>(
- new CoverageDataWithObjectFile(ObjectFile,
- std::move(MergedDataOrError.get())));
- }
-
- std::string object_file() const { return ObjectFile; }
-
- // Print list of covered functions.
- // Line format: <file_name>:<line> <function_name>
- void printCoveredFunctions(raw_ostream &OS) const {
- SourceCoverageData SCovData(ObjectFile, *Addrs);
- auto CoveredFns = SCovData.computeCoveredFunctions();
- printFunctionLocs(SCovData.resolveFunctions(CoveredFns), OS);
- }
-
- // Print list of not covered functions.
- // Line format: <file_name>:<line> <function_name>
- void printNotCoveredFunctions(raw_ostream &OS) const {
- SourceCoverageData SCovData(ObjectFile, *Addrs);
- auto NotCoveredFns = SCovData.computeNotCoveredFunctions();
- printFunctionLocs(SCovData.resolveFunctions(NotCoveredFns), OS);
- }
-
- void printReport(raw_ostream &OS) const {
- SourceCoverageData SCovData(ObjectFile, *Addrs);
- auto LineStatusMap = SCovData.computeLineStatusMap();
-
- std::set<FileFn> AllFns = SCovData.computeAllFunctions();
- // file_loc -> set[function_name]
- auto AllFnsByLoc = SCovData.resolveFunctions(AllFns);
- auto FileCoverage = SCovData.computeFileCoverage();
-
- auto FnCoverage = SCovData.computeFunctionsCoverage();
- auto FnCoverageByFile =
- group_by(FnCoverage, [](const std::pair<FileFn, int> &FileFn) {
- return FileFn.first.FileName;
- });
-
- // TOC
-
- size_t NotCoveredFilesCount = 0;
- std::set<std::string> Files = SCovData.files();
-
- // Covered Files.
- OS << "<details open><summary>Touched Files</summary>\n";
- OS << "<table>\n";
- OS << "<tr><th>File</th><th>Coverage %</th>";
- OS << "<th>Hit (Total) Fns</th></tr>\n";
- for (const auto &FileName : Files) {
- std::pair<size_t, size_t> FC = FileCoverage[FileName];
- if (FC.first == 0) {
- NotCoveredFilesCount++;
- continue;
- }
- size_t CovPct = FC.second == 0 ? 100 : 100 * FC.first / FC.second;
-
- OS << "<tr><td><a href=\"#" << anchorName(FileName) << "\">"
- << stripPathPrefix(FileName) << "</a></td>"
- << "<td>" << formatHtmlPct(CovPct) << "%</td>"
- << "<td>" << FC.first << " (" << FC.second << ")"
- << "</tr>\n";
- }
- OS << "</table>\n";
- OS << "</details>\n";
-
- // Not covered files.
- if (NotCoveredFilesCount) {
- OS << "<details><summary>Not Touched Files</summary>\n";
- OS << "<table>\n";
- for (const auto &FileName : Files) {
- std::pair<size_t, size_t> FC = FileCoverage[FileName];
- if (FC.first == 0)
- OS << "<tr><td>" << stripPathPrefix(FileName) << "</td>\n";
- }
- OS << "</table>\n";
- OS << "</details>\n";
- } else {
- OS << "<p>Congratulations! All source files are touched.</p>\n";
- }
-
- // Source
- for (const auto &FileName : Files) {
- std::pair<size_t, size_t> FC = FileCoverage[FileName];
- if (FC.first == 0)
- continue;
- OS << "<a name=\"" << anchorName(FileName) << "\"></a>\n";
- OS << "<h2>" << stripPathPrefix(FileName) << "</h2>\n";
- OS << "<details open><summary>Function Coverage</summary>";
- OS << "<div class='fnlist'>\n";
-
- auto &FileFnCoverage = FnCoverageByFile[FileName];
-
- for (const auto &P : FileFnCoverage) {
- std::string FunctionName = P.first.FunctionName;
-
- OS << "<div class='fn' style='order: " << P.second << "'>";
- OS << "<span class='pct'>" << formatHtmlPct(P.second)
- << "%</span> ";
- OS << "<span class='name'><a href=\"#"
- << anchorName(FileName + "::" + FunctionName) << "\">";
- OS << escapeHtml(FunctionName) << "</a></span>";
- OS << "</div>\n";
- }
- OS << "</div></details>\n";
-
- ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr =
- MemoryBuffer::getFile(FileName);
- if (!BufOrErr) {
- OS << "Error reading file: " << FileName << " : "
- << BufOrErr.getError().message() << "("
- << BufOrErr.getError().value() << ")\n";
- continue;
- }
-
- OS << "<pre>\n";
- const auto &LineStatuses = LineStatusMap[FileName];
- for (line_iterator I = line_iterator(*BufOrErr.get(), false);
- !I.is_at_eof(); ++I) {
- uint32_t Line = I.line_number();
- { // generate anchors (if any);
- FileLoc Loc = FileLoc{FileName, Line};
- auto It = AllFnsByLoc.find(Loc);
- if (It != AllFnsByLoc.end()) {
- for (const std::string &Fn : It->second) {
- OS << "<a name=\"" << anchorName(FileName + "::" + Fn)
- << "\"></a>";
- };
- }
- }
-
- OS << "<span ";
- auto LIT = LineStatuses.find(I.line_number());
- auto Status = (LIT != LineStatuses.end()) ? LIT->second
- : SourceCoverageData::UNKNOWN;
- switch (Status) {
- case SourceCoverageData::UNKNOWN:
- OS << "class=unknown";
- break;
- case SourceCoverageData::COVERED:
- OS << "class=covered";
- break;
- case SourceCoverageData::NOT_COVERED:
- OS << "class=notcovered";
- break;
- case SourceCoverageData::MIXED:
- OS << "class=mixed";
- break;
- }
- OS << ">";
- OS << escapeHtml(*I) << "</span>\n";
- }
- OS << "</pre>\n";
- }
- }
-
- void collectStats(CoverageStats *Stats) const {
- Stats->CovPoints += Addrs->size();
-
- SourceCoverageData SCovData(ObjectFile, *Addrs);
- SCovData.collectStats(Stats);
- }
-
-private:
- CoverageDataWithObjectFile(std::string ObjectFile,
- std::unique_ptr<CoverageData> Coverage)
- : CoverageData(std::move(Coverage->Addrs)),
- ObjectFile(std::move(ObjectFile)) {}
- const std::string ObjectFile;
-};
-
-// Multiple coverage files data organized by object file.
-class CoverageDataSet {
-public:
- static ErrorOr<std::unique_ptr<CoverageDataSet>>
- readCmdArguments(std::vector<std::string> FileNames) {
- // Short name => file name.
- std::map<std::string, std::string> ObjFiles;
- std::string FirstObjFile;
- std::set<std::string> CovFiles;
-
- // Partition input values into coverage/object files.
- for (const auto &FileName : FileNames) {
- auto ErrorOrIsCoverage = isCoverageFile(FileName);
- if (!ErrorOrIsCoverage)
- continue;
- if (ErrorOrIsCoverage.get()) {
- CovFiles.insert(FileName);
- } else {
- auto ShortFileName = llvm::sys::path::filename(FileName);
- if (ObjFiles.find(ShortFileName) != ObjFiles.end()) {
- Fail("Duplicate binary file with a short name: " + ShortFileName);
- }
-
- ObjFiles[ShortFileName] = FileName;
- if (FirstObjFile.empty())
- FirstObjFile = FileName;
- }
- }
-
- Regex SancovRegex("(.*)\\.[0-9]+\\.sancov");
- SmallVector<StringRef, 2> Components;
-
- // Object file => list of corresponding coverage file names.
- auto CoverageByObjFile = group_by(CovFiles, [&](std::string FileName) {
- auto ShortFileName = llvm::sys::path::filename(FileName);
- auto Ok = SancovRegex.match(ShortFileName, &Components);
- if (!Ok) {
- Fail("Can't match coverage file name against "
- "<module_name>.<pid>.sancov pattern: " +
- FileName);
- }
-
- auto Iter = ObjFiles.find(Components[1]);
- if (Iter == ObjFiles.end()) {
- Fail("Object file for coverage not found: " + FileName);
- }
- return Iter->second;
- });
-
- // Read coverage.
- std::vector<std::unique_ptr<CoverageDataWithObjectFile>> MergedCoverage;
- for (const auto &Pair : CoverageByObjFile) {
- if (findSanitizerCovFunctions(Pair.first).empty()) {
- for (const auto &FileName : Pair.second) {
- CovFiles.erase(FileName);
- }
-
- errs()
- << "Ignoring " << Pair.first
- << " and its coverage because __sanitizer_cov* functions were not "
- "found.\n";
- continue;
- }
-
- auto DataOrError =
- CoverageDataWithObjectFile::readAndMerge(Pair.first, Pair.second);
- FailIfError(DataOrError);
- MergedCoverage.push_back(std::move(DataOrError.get()));
- }
-
- return std::unique_ptr<CoverageDataSet>(
- new CoverageDataSet(FirstObjFile, &MergedCoverage, CovFiles));
- }
-
- void printCoveredFunctions(raw_ostream &OS) const {
- for (const auto &Cov : Coverage) {
- Cov->printCoveredFunctions(OS);
- }
- }
-
- void printNotCoveredFunctions(raw_ostream &OS) const {
- for (const auto &Cov : Coverage) {
- Cov->printNotCoveredFunctions(OS);
- }
- }
-
- void printStats(raw_ostream &OS) const {
- CoverageStats Stats;
- for (const auto &Cov : Coverage) {
- Cov->collectStats(&Stats);
- }
- OS << Stats;
- }
-
- void printReport(raw_ostream &OS) const {
- auto Title =
- (llvm::sys::path::filename(MainObjFile) + " Coverage Report").str();
-
- OS << "<html>\n";
- OS << "<head>\n";
-
- // Stylesheet
- OS << "<style>\n";
- OS << ".covered { background: #7F7; }\n";
- OS << ".notcovered { background: #F77; }\n";
- OS << ".mixed { background: #FF7; }\n";
- OS << "summary { font-weight: bold; }\n";
- OS << "details > summary + * { margin-left: 1em; }\n";
- OS << ".fnlist { display: flex; flex-flow: column nowrap; }\n";
- OS << ".fn { display: flex; flex-flow: row nowrap; }\n";
- OS << ".pct { width: 3em; text-align: right; margin-right: 1em; }\n";
- OS << ".name { flex: 2; }\n";
- OS << ".lz { color: lightgray; }\n";
- OS << "</style>\n";
- OS << "<title>" << Title << "</title>\n";
- OS << "</head>\n";
- OS << "<body>\n";
-
- // Title
- OS << "<h1>" << Title << "</h1>\n";
-
- // Modules TOC.
- if (Coverage.size() > 1) {
- for (const auto &CovData : Coverage) {
- OS << "<li><a href=\"#module_" << anchorName(CovData->object_file())
- << "\">" << llvm::sys::path::filename(CovData->object_file())
- << "</a></li>\n";
- }
- }
-
- for (const auto &CovData : Coverage) {
- if (Coverage.size() > 1) {
- OS << "<h2>" << llvm::sys::path::filename(CovData->object_file())
- << "</h2>\n";
- }
- OS << "<a name=\"module_" << anchorName(CovData->object_file())
- << "\"></a>\n";
- CovData->printReport(OS);
- }
-
- // About
- OS << "<details><summary>About</summary>\n";
- OS << "Coverage files:<ul>";
- for (const auto &InputFile : CoverageFiles) {
- llvm::sys::fs::file_status Status;
- llvm::sys::fs::status(InputFile, Status);
- OS << "<li>" << stripPathPrefix(InputFile) << " ("
- << Status.getLastModificationTime().str() << ")</li>\n";
- }
- OS << "</ul></details>\n";
-
- OS << "</body>\n";
- OS << "</html>\n";
- }
-
- bool empty() const { return Coverage.empty(); }
-
-private:
- explicit CoverageDataSet(
- const std::string &MainObjFile,
- std::vector<std::unique_ptr<CoverageDataWithObjectFile>> *Data,
- const std::set<std::string> &CoverageFiles)
- : MainObjFile(MainObjFile), CoverageFiles(CoverageFiles) {
- Data->swap(this->Coverage);
- }
-
- const std::string MainObjFile;
- std::vector<std::unique_ptr<CoverageDataWithObjectFile>> Coverage;
- const std::set<std::string> CoverageFiles;
-};
-
-} // namespace
int main(int argc, char **argv) {
- // Print stack trace if we signal out.
- sys::PrintStackTraceOnErrorSignal(argv[0]);
- PrettyStackTraceProgram X(argc, argv);
- llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
-
- llvm::InitializeAllTargetInfos();
- llvm::InitializeAllTargetMCs();
- llvm::InitializeAllDisassemblers();
-
- cl::ParseCommandLineOptions(argc, argv, "Sanitizer Coverage Processing Tool");
-
- // -print doesn't need object files.
- if (Action == PrintAction) {
- auto CovData = CoverageData::readAndMerge(ClInputFiles);
- FailIfError(CovData);
- CovData.get()->printAddrs(outs());
- return 0;
- } else if (Action == PrintCovPointsAction) {
- // -print-coverage-points doesn't need coverage files.
- for (const std::string &ObjFile : ClInputFiles) {
- printCovPoints(ObjFile, outs());
- }
- return 0;
- }
-
- auto CovDataSet = CoverageDataSet::readCmdArguments(ClInputFiles);
- FailIfError(CovDataSet);
-
- if (CovDataSet.get()->empty()) {
- Fail("No coverage files specified.");
- }
-
- switch (Action) {
- case CoveredFunctionsAction: {
- CovDataSet.get()->printCoveredFunctions(outs());
- return 0;
- }
- case NotCoveredFunctionsAction: {
- CovDataSet.get()->printNotCoveredFunctions(outs());
- return 0;
- }
- case HtmlReportAction: {
- CovDataSet.get()->printReport(outs());
- return 0;
- }
- case StatsAction: {
- CovDataSet.get()->printStats(outs());
- return 0;
- }
- case PrintAction:
- case PrintCovPointsAction:
- llvm_unreachable("unsupported action");
- }
+ return 0;
}
diff --git a/unittests/Support/ThreadPool.cpp b/unittests/Support/ThreadPool.cpp
index 69a24bc..b185859 100644
--- a/unittests/Support/ThreadPool.cpp
+++ b/unittests/Support/ThreadPool.cpp
@@ -7,6 +7,8 @@
//
//===----------------------------------------------------------------------===//
+#if 0
+
#include "llvm/Support/ThreadPool.h"
#include "llvm/ADT/STLExtras.h"
@@ -166,3 +168,5 @@ TEST_F(ThreadPoolTest, PoolDestruction) {
}
ASSERT_EQ(5, checked_in);
}
+
+#endif
