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, public CommentHandler {
49   // A vector of skipped source ranges and PrevTokLoc with NextTokLoc.
50   std::vector<SkippedRange> SkippedRanges;
51   Optional<unsigned> LastCommentIndex = None;
52 
53 public:
54   // Location of the token parsed before HandleComment is called. This is
55   // updated every time Preprocessor::Lex lexes a new token.
56   SourceLocation PrevTokLoc;
57   // The location of token before comment.
58   SourceLocation BeforeCommentLoc;
59 
60   std::vector<SkippedRange> &getSkippedRanges() {
61     return SkippedRanges;
62   }
63 
64   void SourceRangeSkipped(SourceRange Range, SourceLocation EndifLoc) override;
65 
66   bool HandleComment(Preprocessor &PP, SourceRange Range) override;
67 
68   void updateNextTokLoc(SourceLocation Loc);
69 };
70 
71 namespace CodeGen {
72 
73 class CodeGenModule;
74 
75 /// Organizes the cross-function state that is used while generating
76 /// code coverage mapping data.
77 class CoverageMappingModuleGen {
78   /// Information needed to emit a coverage record for a function.
79   struct FunctionInfo {
80     uint64_t NameHash;
81     uint64_t FuncHash;
82     std::string CoverageMapping;
83     bool IsUsed;
84   };
85 
86   CodeGenModule &CGM;
87   CoverageSourceInfo &SourceInfo;
88   llvm::SmallDenseMap<const FileEntry *, unsigned, 8> FileEntries;
89   std::vector<llvm::Constant *> FunctionNames;
90   std::vector<FunctionInfo> FunctionRecords;
91 
92   /// Emit a function record.
93   void emitFunctionMappingRecord(const FunctionInfo &Info,
94                                  uint64_t FilenamesRef);
95 
96 public:
97   static CoverageSourceInfo *setUpCoverageCallbacks(Preprocessor &PP);
98 
99   CoverageMappingModuleGen(CodeGenModule &CGM, CoverageSourceInfo &SourceInfo)
100       : CGM(CGM), SourceInfo(SourceInfo) {}
101 
102   CoverageSourceInfo &getSourceInfo() const {
103     return SourceInfo;
104   }
105 
106   /// Add a function's coverage mapping record to the collection of the
107   /// function mapping records.
108   void addFunctionMappingRecord(llvm::GlobalVariable *FunctionName,
109                                 StringRef FunctionNameValue,
110                                 uint64_t FunctionHash,
111                                 const std::string &CoverageMapping,
112                                 bool IsUsed = true);
113 
114   /// Emit the coverage mapping data for a translation unit.
115   void emit();
116 
117   /// Return the coverage mapping translation unit file id
118   /// for the given file.
119   unsigned getFileID(const FileEntry *File);
120 };
121 
122 /// Organizes the per-function state that is used while generating
123 /// code coverage mapping data.
124 class CoverageMappingGen {
125   CoverageMappingModuleGen &CVM;
126   SourceManager &SM;
127   const LangOptions &LangOpts;
128   llvm::DenseMap<const Stmt *, unsigned> *CounterMap;
129 
130 public:
131   CoverageMappingGen(CoverageMappingModuleGen &CVM, SourceManager &SM,
132                      const LangOptions &LangOpts)
133       : CVM(CVM), SM(SM), LangOpts(LangOpts), CounterMap(nullptr) {}
134 
135   CoverageMappingGen(CoverageMappingModuleGen &CVM, SourceManager &SM,
136                      const LangOptions &LangOpts,
137                      llvm::DenseMap<const Stmt *, unsigned> *CounterMap)
138       : CVM(CVM), SM(SM), LangOpts(LangOpts), CounterMap(CounterMap) {}
139 
140   /// Emit the coverage mapping data which maps the regions of
141   /// code to counters that will be used to find the execution
142   /// counts for those regions.
143   void emitCounterMapping(const Decl *D, llvm::raw_ostream &OS);
144 
145   /// Emit the coverage mapping data for an unused function.
146   /// It creates mapping regions with the counter of zero.
147   void emitEmptyMapping(const Decl *D, llvm::raw_ostream &OS);
148 };
149 
150 } // end namespace CodeGen
151 } // end namespace clang
152 
153 #endif
154