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