From f76f3154361169f5b074a05ce31e0a04bcadcde5 Mon Sep 17 00:00:00 2001 From: Daniel Sanders Date: Thu, 16 Nov 2017 00:46:35 +0000 Subject: [globalisel][tablegen] Generate rule coverage and use it to identify untested rules Summary: This patch adds a LLVM_ENABLE_GISEL_COV which, like LLVM_ENABLE_DAGISEL_COV, causes TableGen to instrument the generated table to collect rule coverage information. However, LLVM_ENABLE_GISEL_COV goes a bit further than LLVM_ENABLE_DAGISEL_COV. The information is written to files (${CMAKE_BINARY_DIR}/gisel-coverage-* by default). These files can then be concatenated into ${LLVM_GISEL_COV_PREFIX}-all after which TableGen will read this information and use it to emit warnings about untested rules. This technique could also be used by SelectionDAG and can be further extended to detect hot rules and give them priority over colder rules. Usage: * Enable LLVM_ENABLE_GISEL_COV in CMake * Build the compiler and run some tests * cat gisel-coverage-[0-9]* > gisel-coverage-all * Delete lib/Target/*/*GenGlobalISel.inc* * Build the compiler Known issues: * ${LLVM_GISEL_COV_PREFIX}-all must be generated as a manual step due to a lack of a portable 'cat' command. It should be the concatenation of all ${LLVM_GISEL_COV_PREFIX}-[0-9]* files. * There's no mechanism to discard coverage information when the ruleset changes Depends on D39742 Reviewers: ab, qcolombet, t.p.northover, aditya_nandakumar, rovka Reviewed By: rovka Subscribers: vsk, arsenm, nhaehnle, mgorny, kristof.beyls, javed.absar, igorb, llvm-commits Differential Revision: https://reviews.llvm.org/D39747 llvm-svn: 318356 --- llvm/lib/Support/CodeGenCoverage.cpp | 118 +++++++++++++++++++++++++++++++++++ 1 file changed, 118 insertions(+) create mode 100644 llvm/lib/Support/CodeGenCoverage.cpp (limited to 'llvm/lib/Support/CodeGenCoverage.cpp') diff --git a/llvm/lib/Support/CodeGenCoverage.cpp b/llvm/lib/Support/CodeGenCoverage.cpp new file mode 100644 index 00000000000..5cc84cb96e8 --- /dev/null +++ b/llvm/lib/Support/CodeGenCoverage.cpp @@ -0,0 +1,118 @@ +//===- lib/Support/CodeGenCoverage.cpp -------------------------------------==// +// +// 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 CodeGenCoverage class. +//===----------------------------------------------------------------------===// + +#include "llvm/Support/CodeGenCoverage.h" + +#include "llvm/Support/Endian.h" +#include "llvm/Support/FileSystem.h" +#include "llvm/Support/Mutex.h" +#include "llvm/Support/ScopedPrinter.h" +#include "llvm/Support/ToolOutputFile.h" + +#if LLVM_ON_UNIX +#include +#elif LLVM_ON_WIN32 +#include +#endif + +using namespace llvm; + +static sys::SmartMutex OutputMutex; + +CodeGenCoverage::CodeGenCoverage() {} + +void CodeGenCoverage::setCovered(uint64_t RuleID) { + if (RuleCoverage.size() <= RuleID) + RuleCoverage.resize(RuleID + 1, 0); + RuleCoverage[RuleID] = true; +} + +bool CodeGenCoverage::isCovered(uint64_t RuleID) { + if (RuleCoverage.size() <= RuleID) + return false; + return RuleCoverage[RuleID]; +} + +bool CodeGenCoverage::parse(MemoryBuffer &Buffer, StringRef BackendName) { + const char *CurPtr = Buffer.getBufferStart(); + + while (CurPtr != Buffer.getBufferEnd()) { + // Read the backend name from the input. + const char *LexedBackendName = CurPtr; + while (*CurPtr++ != 0) + ; + if (CurPtr == Buffer.getBufferEnd()) + return false; // Data is invalid, expected rule id's to follow. + + bool IsForThisBackend = BackendName.equals(LexedBackendName); + while (CurPtr != Buffer.getBufferEnd()) { + if (std::distance(CurPtr, Buffer.getBufferEnd()) < 8) + return false; // Data is invalid. Not enough bytes for another rule id. + + uint64_t RuleID = support::endian::read64(CurPtr, support::native); + CurPtr += 8; + + // ~0ull terminates the rule id list. + if (RuleID == ~0ull) + break; + + // Anything else, is recorded or ignored depending on whether it's + // intended for the backend we're interested in. + if (IsForThisBackend) + setCovered(RuleID); + } + } + + return true; +} + +bool CodeGenCoverage::emit(StringRef CoveragePrefix, + StringRef BackendName) const { + if (!CoveragePrefix.empty() && !RuleCoverage.empty()) { + sys::SmartScopedLock Lock(OutputMutex); + + // We can handle locking within a process easily enough but we don't want to + // manage it between multiple processes. Use the process ID to ensure no + // more than one process is ever writing to the same file at the same time. + std::string Pid = +#if LLVM_ON_UNIX + llvm::to_string(::getpid()); +#elif LLVM_ON_WIN32 + llvm::to_string(::GetCurrentProcessId()); +#else + ""; +#endif + + std::string CoverageFilename = (CoveragePrefix + Pid).str(); + + std::error_code EC; + sys::fs::OpenFlags OpenFlags = sys::fs::F_Append; + std::unique_ptr CoverageFile = + llvm::make_unique(CoverageFilename, EC, OpenFlags); + if (EC) + return false; + + uint64_t Zero = 0; + uint64_t InvZero = ~0ull; + CoverageFile->os() << BackendName; + CoverageFile->os().write((const char *)&Zero, sizeof(unsigned char)); + for (uint64_t I : RuleCoverage.set_bits()) + CoverageFile->os().write((const char *)&I, sizeof(uint64_t)); + CoverageFile->os().write((const char *)&InvZero, sizeof(uint64_t)); + + CoverageFile->keep(); + } + + return true; +} + +void CodeGenCoverage::reset() { RuleCoverage.resize(0); } -- cgit v1.2.3