1//===- lib/Support/CodeGenCoverage.cpp -------------------------------------==//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8/// \file
9/// This file implements the CodeGenCoverage class.
10//===----------------------------------------------------------------------===//
11
12#include "llvm/Support/CodeGenCoverage.h"
13
14#include "llvm/Support/Endian.h"
15#include "llvm/Support/FileSystem.h"
16#include "llvm/Support/MemoryBuffer.h"
17#include "llvm/Support/Mutex.h"
18#include "llvm/Support/Process.h"
19#include "llvm/Support/ScopedPrinter.h"
20#include "llvm/Support/ToolOutputFile.h"
21
22using namespace llvm;
23
24static sys::SmartMutex<true> OutputMutex;
25
26CodeGenCoverage::CodeGenCoverage() = default;
27
28void CodeGenCoverage::setCovered(uint64_t RuleID) {
29  if (RuleCoverage.size() <= RuleID)
30    RuleCoverage.resize(RuleID + 1, false);
31  RuleCoverage[RuleID] = true;
32}
33
34bool CodeGenCoverage::isCovered(uint64_t RuleID) const {
35  if (RuleCoverage.size() <= RuleID)
36    return false;
37  return RuleCoverage[RuleID];
38}
39
40iterator_range<CodeGenCoverage::const_covered_iterator>
41CodeGenCoverage::covered() const {
42  return RuleCoverage.set_bits();
43}
44
45bool CodeGenCoverage::parse(MemoryBuffer &Buffer, StringRef BackendName) {
46  const char *CurPtr = Buffer.getBufferStart();
47
48  while (CurPtr != Buffer.getBufferEnd()) {
49    // Read the backend name from the input.
50    const char *LexedBackendName = CurPtr;
51    while (*CurPtr++ != 0)
52      ;
53    if (CurPtr == Buffer.getBufferEnd())
54      return false; // Data is invalid, expected rule id's to follow.
55
56    bool IsForThisBackend = BackendName.equals(LexedBackendName);
57    while (CurPtr != Buffer.getBufferEnd()) {
58      if (std::distance(CurPtr, Buffer.getBufferEnd()) < 8)
59        return false; // Data is invalid. Not enough bytes for another rule id.
60
61      uint64_t RuleID =
62          support::endian::read64(CurPtr, llvm::endianness::native);
63      CurPtr += 8;
64
65      // ~0ull terminates the rule id list.
66      if (RuleID == ~0ull)
67        break;
68
69      // Anything else, is recorded or ignored depending on whether it's
70      // intended for the backend we're interested in.
71      if (IsForThisBackend)
72        setCovered(RuleID);
73    }
74  }
75
76  return true;
77}
78
79bool CodeGenCoverage::emit(StringRef CoveragePrefix,
80                           StringRef BackendName) const {
81  if (!CoveragePrefix.empty() && !RuleCoverage.empty()) {
82    sys::SmartScopedLock<true> Lock(OutputMutex);
83
84    // We can handle locking within a process easily enough but we don't want to
85    // manage it between multiple processes. Use the process ID to ensure no
86    // more than one process is ever writing to the same file at the same time.
87    std::string Pid = llvm::to_string(sys::Process::getProcessId());
88
89    std::string CoverageFilename = (CoveragePrefix + Pid).str();
90
91    std::error_code EC;
92    sys::fs::OpenFlags OpenFlags = sys::fs::OF_Append;
93    std::unique_ptr<ToolOutputFile> CoverageFile =
94        std::make_unique<ToolOutputFile>(CoverageFilename, EC, OpenFlags);
95    if (EC)
96      return false;
97
98    uint64_t Zero = 0;
99    uint64_t InvZero = ~0ull;
100    CoverageFile->os() << BackendName;
101    CoverageFile->os().write((const char *)&Zero, sizeof(unsigned char));
102    for (uint64_t I : RuleCoverage.set_bits())
103      CoverageFile->os().write((const char *)&I, sizeof(uint64_t));
104    CoverageFile->os().write((const char *)&InvZero, sizeof(uint64_t));
105
106    CoverageFile->keep();
107  }
108
109  return true;
110}
111
112void CodeGenCoverage::reset() { RuleCoverage.resize(0); }
113