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