OLD | NEW |
(Empty) | |
| 1 // Copyright 2017 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 |
| 5 // This clang tool finds all instances of net::DefineNetworkTrafficAnnotation in |
| 6 // given source code, extracts the location info and content of annotation tags |
| 7 // (unique id and annotation text), and stores them in separate text files |
| 8 // (per instance) in the given output directory. Please refer to README.md for |
| 9 // build and usage instructions. |
| 10 |
| 11 #include <memory> |
| 12 #include <vector> |
| 13 |
| 14 #include "clang/ASTMatchers/ASTMatchFinder.h" |
| 15 #include "clang/ASTMatchers/ASTMatchers.h" |
| 16 #include "clang/Basic/SourceManager.h" |
| 17 #include "clang/Frontend/FrontendActions.h" |
| 18 #include "clang/Lex/Lexer.h" |
| 19 #include "clang/Tooling/CommonOptionsParser.h" |
| 20 #include "clang/Tooling/Refactoring.h" |
| 21 #include "clang/Tooling/Tooling.h" |
| 22 #include "llvm/Support/CommandLine.h" |
| 23 |
| 24 using namespace clang::ast_matchers; |
| 25 |
| 26 namespace { |
| 27 |
| 28 // An instance of a call to the net::DefineNetworkTrafficAnnotation function. |
| 29 struct NetworkAnnotationInstance { |
| 30 // Information about where the call has happened. |
| 31 struct Location { |
| 32 std::string file_path; |
| 33 int line_number = -1; |
| 34 |
| 35 // Name of the function calling net::DefineNetworkTrafficAnnotation. E.g., |
| 36 // in the following code, |function_name| will be 'foo': |
| 37 // void foo() { NetworkTrafficAnnotationTag bar = |
| 38 // net::DefineNetworkTrafficAnnotation(...); } |
| 39 // If no function is found, 'Global Namespace' will be returned. |
| 40 std::string function_name; |
| 41 }; |
| 42 |
| 43 // Annotation content. These are the parameters of the call to |
| 44 // net::DefineNetworkTrafficAnnotation. The unique_id is an identifier for the |
| 45 // annotation that has to be unique across the entire code base. The |text| |
| 46 // stores a raw string with the annotation that should be extracted. |
| 47 struct Annotation { |
| 48 std::string unique_id; |
| 49 std::string text; |
| 50 }; |
| 51 |
| 52 Location location; |
| 53 Annotation annotation; |
| 54 }; |
| 55 |
| 56 using Collector = std::vector<NetworkAnnotationInstance>; |
| 57 |
| 58 // This class implements the call back functions for AST Matchers. The matchers |
| 59 // are defined in RunMatchers function. When a pattern is found there, |
| 60 // the run function in this class is called back with information on the matched |
| 61 // location and description of the matched pattern. |
| 62 class NetworkAnnotationTagCallback : public MatchFinder::MatchCallback { |
| 63 public: |
| 64 explicit NetworkAnnotationTagCallback(Collector* collector) |
| 65 : collector_(collector) {} |
| 66 ~NetworkAnnotationTagCallback() override = default; |
| 67 |
| 68 // Is called on any pattern found by ASTMathers that are defined in RunMathers |
| 69 // function. |
| 70 virtual void run(const MatchFinder::MatchResult& result) override { |
| 71 const clang::CallExpr* call_expr = |
| 72 result.Nodes.getNodeAs<clang::CallExpr>("definition_function"); |
| 73 const clang::StringLiteral* unique_id = |
| 74 result.Nodes.getNodeAs<clang::StringLiteral>("unique_id"); |
| 75 const clang::StringLiteral* annotation_text = |
| 76 result.Nodes.getNodeAs<clang::StringLiteral>("annotation_text"); |
| 77 const clang::FunctionDecl* ancestor = |
| 78 result.Nodes.getNodeAs<clang::FunctionDecl>("function_context"); |
| 79 |
| 80 assert(call_expr && unique_id && annotation_text); |
| 81 |
| 82 NetworkAnnotationInstance instance; |
| 83 instance.annotation.unique_id = unique_id->getString(); |
| 84 instance.annotation.text = annotation_text->getString(); |
| 85 |
| 86 // Get annotation location. |
| 87 clang::SourceLocation source_location = call_expr->getLocStart(); |
| 88 if (source_location.isMacroID()) { |
| 89 source_location = |
| 90 result.SourceManager->getImmediateMacroCallerLoc(source_location); |
| 91 } |
| 92 instance.location.file_path = |
| 93 result.SourceManager->getFilename(source_location); |
| 94 instance.location.line_number = |
| 95 result.SourceManager->getSpellingLineNumber(source_location); |
| 96 if (ancestor) |
| 97 instance.location.function_name = ancestor->getQualifiedNameAsString(); |
| 98 else |
| 99 instance.location.function_name = "Global Namespace"; |
| 100 |
| 101 // Trim leading "../"s from file path. |
| 102 std::replace(instance.location.file_path.begin(), |
| 103 instance.location.file_path.end(), '\\', '/'); |
| 104 while (instance.location.file_path.length() > 3 && |
| 105 instance.location.file_path.substr(0, 3) == "../") { |
| 106 instance.location.file_path = instance.location.file_path.substr( |
| 107 3, instance.location.file_path.length() - 3); |
| 108 } |
| 109 |
| 110 collector_->push_back(instance); |
| 111 } |
| 112 |
| 113 private: |
| 114 Collector* collector_; |
| 115 }; |
| 116 |
| 117 // Sets up an ASTMatcher and runs clang tool to populate collector. Returns the |
| 118 // result of running the clang tool. |
| 119 int RunMatchers(clang::tooling::ClangTool* clang_tool, Collector* collector) { |
| 120 NetworkAnnotationTagCallback callback(collector); |
| 121 MatchFinder match_finder; |
| 122 |
| 123 // Set up a pattern to find functions that are named |
| 124 // [net::]DefineNetworkTrafficAnnotation and have 2 arguments of string |
| 125 // literal type. If pattern has a function declaration as ancestor, it is |
| 126 // marked. |
| 127 match_finder.addMatcher( |
| 128 callExpr(hasDeclaration(functionDecl( |
| 129 anyOf(hasName("DefineNetworkTrafficAnnotation"), |
| 130 hasName("net::DefineNetworkTrafficAnnotation")))), |
| 131 hasArgument(0, stringLiteral().bind("unique_id")), |
| 132 hasArgument(1, stringLiteral().bind("annotation_text")), |
| 133 anyOf(hasAncestor(functionDecl().bind("function_context")), |
| 134 unless(hasAncestor(functionDecl())))) |
| 135 .bind("definition_function"), |
| 136 &callback); |
| 137 std::unique_ptr<clang::tooling::FrontendActionFactory> frontend_factory = |
| 138 clang::tooling::newFrontendActionFactory(&match_finder); |
| 139 return clang_tool->run(frontend_factory.get()); |
| 140 } |
| 141 |
| 142 } // namespace |
| 143 |
| 144 static llvm::cl::OptionCategory ToolCategory( |
| 145 "traffic_annotation_extractor: Extract traffic annotation texts"); |
| 146 static llvm::cl::extrahelp CommonHelp( |
| 147 clang::tooling::CommonOptionsParser::HelpMessage); |
| 148 |
| 149 int main(int argc, const char* argv[]) { |
| 150 clang::tooling::CommonOptionsParser options(argc, argv, ToolCategory); |
| 151 clang::tooling::ClangTool tool(options.getCompilations(), |
| 152 options.getSourcePathList()); |
| 153 Collector collector; |
| 154 |
| 155 int result = RunMatchers(&tool, &collector); |
| 156 |
| 157 if (result != 0) |
| 158 return result; |
| 159 |
| 160 // For each call to "DefineNetworkTrafficAnnotation", write annotation text |
| 161 // and relevant meta data into a separate file. The filename is uniquely |
| 162 // generated using the file path and filename of the code including the call |
| 163 // and its line number. |
| 164 for (const NetworkAnnotationInstance& call : collector) { |
| 165 llvm::outs() << "==== NEW ANNOTATION ====\n"; |
| 166 llvm::outs() << call.location.file_path << "\n"; |
| 167 llvm::outs() << call.location.function_name << "\n"; |
| 168 llvm::outs() << call.location.line_number << "\n"; |
| 169 llvm::outs() << call.annotation.unique_id << "\n"; |
| 170 llvm::outs() << call.annotation.text << "\n"; |
| 171 llvm::outs() << "==== ANNOTATION ENDS ====\n"; |
| 172 } |
| 173 |
| 174 return 0; |
| 175 } |
OLD | NEW |