1 //===---- CoverageMappingGen.h - Coverage mapping generation ----*- C++ -*-===//
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 //
9 // Instrumentation-based code coverage mapping generator
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #ifndef LLVM_CLANG_LIB_CODEGEN_COVERAGEMAPPINGGEN_H
14 #define LLVM_CLANG_LIB_CODEGEN_COVERAGEMAPPINGGEN_H
15 
16 #include "clang/Basic/LLVM.h"
17 #include "clang/Basic/SourceLocation.h"
18 #include "clang/Lex/PPCallbacks.h"
19 #include "clang/Lex/Preprocessor.h"
20 #include "llvm/ADT/DenseMap.h"
21 #include "llvm/IR/GlobalValue.h"
22 #include "llvm/Support/raw_ostream.h"
23 
24 namespace clang {
25 
26 class LangOptions;
27 class SourceManager;
28 class FileEntry;
29 class Preprocessor;
30 class Decl;
31 class Stmt;
32 
33 struct SkippedRange {
34   SourceRange Range;
35   // The location of token before the skipped source range.
36   SourceLocation PrevTokLoc;
37   // The location of token after the skipped source range.
38   SourceLocation NextTokLoc;
39 
40   SkippedRange(SourceRange Range, SourceLocation PrevTokLoc = SourceLocation(),
41                SourceLocation NextTokLoc = SourceLocation())
42       : Range(Range), PrevTokLoc(PrevTokLoc), NextTokLoc(NextTokLoc) {}
43 };
44 
45 /// Stores additional source code information like skipped ranges which
46 /// is required by the coverage mapping generator and is obtained from
47 /// the preprocessor.
48 class CoverageSourceInfo : public PPCallbacks,
49                            public CommentHandler,
50                            public EmptylineHandler {
51   // A vector of skipped source ranges and PrevTokLoc with NextTokLoc.
52   std::vector<SkippedRange> SkippedRanges;
53 
54   SourceManager &SourceMgr;
55 
56 public:
57   // Location of the token parsed before HandleComment is called. This is
58   // updated every time Preprocessor::Lex lexes a new token.
59   SourceLocation PrevTokLoc;
60 
61   CoverageSourceInfo(SourceManager &SourceMgr) : SourceMgr(SourceMgr) {}
62 
63   std::vector<SkippedRange> &getSkippedRanges() { return SkippedRanges; }
64 
65   void AddSkippedRange(SourceRange Range);
66 
67   void SourceRangeSkipped(SourceRange Range, SourceLocation EndifLoc) override;
68 
69   void HandleEmptyline(SourceRange Range) override;
70 
71   bool HandleComment(Preprocessor &PP, SourceRange Range) override;
72 
73   void updateNextTokLoc(SourceLocation Loc);
74 };
75 
76 namespace CodeGen {
77 
78 class CodeGenModule;
79 
80 /// Organizes the cross-function state that is used while generating
81 /// code coverage mapping data.
82 class CoverageMappingModuleGen {
83   /// Information needed to emit a coverage record for a function.
84   struct FunctionInfo {
85     uint64_t NameHash;
86     uint64_t FuncHash;
87     std::string CoverageMapping;
88     bool IsUsed;
89   };
90 
91   CodeGenModule &CGM;
92   CoverageSourceInfo &SourceInfo;
93   llvm::SmallDenseMap<const FileEntry *, unsigned, 8> FileEntries;
94   std::vector<llvm::Constant *> FunctionNames;
95   std::vector<FunctionInfo> FunctionRecords;
96   std::map<std::string, std::string> ProfilePrefixMap;
97 
98   std::string normalizeFilename(StringRef Filename);
99 
100   /// Emit a function record.
101   void emitFunctionMappingRecord(const FunctionInfo &Info,
102                                  uint64_t FilenamesRef);
103 
104 public:
105   static CoverageSourceInfo *setUpCoverageCallbacks(Preprocessor &PP);
106 
107   CoverageMappingModuleGen(CodeGenModule &CGM, CoverageSourceInfo &SourceInfo);
108 
109   CoverageSourceInfo &getSourceInfo() const {
110     return SourceInfo;
111   }
112 
113   /// Add a function's coverage mapping record to the collection of the
114   /// function mapping records.
115   void addFunctionMappingRecord(llvm::GlobalVariable *FunctionName,
116                                 StringRef FunctionNameValue,
117                                 uint64_t FunctionHash,
118                                 const std::string &CoverageMapping,
119                                 bool IsUsed = true);
120 
121   /// Emit the coverage mapping data for a translation unit.
122   void emit();
123 
124   /// Return the coverage mapping translation unit file id
125   /// for the given file.
126   unsigned getFileID(const FileEntry *File);
127 
128   /// Return an interface into CodeGenModule.
129   CodeGenModule &getCodeGenModule() { return CGM; }
130 };
131 
132 /// Organizes the per-function state that is used while generating
133 /// code coverage mapping data.
134 class CoverageMappingGen {
135   CoverageMappingModuleGen &CVM;
136   SourceManager &SM;
137   const LangOptions &LangOpts;
138   llvm::DenseMap<const Stmt *, unsigned> *CounterMap;
139 
140 public:
141   CoverageMappingGen(CoverageMappingModuleGen &CVM, SourceManager &SM,
142                      const LangOptions &LangOpts)
143       : CVM(CVM), SM(SM), LangOpts(LangOpts), CounterMap(nullptr) {}
144 
145   CoverageMappingGen(CoverageMappingModuleGen &CVM, SourceManager &SM,
146                      const LangOptions &LangOpts,
147                      llvm::DenseMap<const Stmt *, unsigned> *CounterMap)
148       : CVM(CVM), SM(SM), LangOpts(LangOpts), CounterMap(CounterMap) {}
149 
150   /// Emit the coverage mapping data which maps the regions of
151   /// code to counters that will be used to find the execution
152   /// counts for those regions.
153   void emitCounterMapping(const Decl *D, llvm::raw_ostream &OS);
154 
155   /// Emit the coverage mapping data for an unused function.
156   /// It creates mapping regions with the counter of zero.
157   void emitEmptyMapping(const Decl *D, llvm::raw_ostream &OS);
158 };
159 
160 } // end namespace CodeGen
161 } // end namespace clang
162 
163 #endif
164