| // Copyright 2024 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| // A clang tool for the migration of Handle<T> to DirectHandle<T>. |
| // This is only useful for the V8 code base. |
| |
| #include <clang/AST/ASTContext.h> |
| #include <clang/ASTMatchers/ASTMatchFinder.h> |
| #include <clang/ASTMatchers/ASTMatchers.h> |
| #include <clang/Frontend/FrontendActions.h> |
| #include <clang/Tooling/CommonOptionsParser.h> |
| #include <clang/Tooling/Refactoring.h> |
| #include <clang/Tooling/Tooling.h> |
| #include <llvm/Support/CommandLine.h> |
| |
| #include <optional> |
| #include <regex> |
| #include <string> |
| #include <unordered_map> |
| #include <vector> |
| |
| using namespace clang; |
| using namespace clang::tooling; |
| using namespace clang::ast_matchers; |
| |
| // Command line options. |
| |
| static llvm::cl::OptionCategory my_tool_category( |
| "Handle migration tool options"); |
| static llvm::cl::extrahelp common_help(CommonOptionsParser::HelpMessage); |
| |
| constexpr int kVerboseNone = 0; |
| constexpr int kVerboseReportInterestingHandleUse = 1; |
| constexpr int kVerboseReportInterestingFunctionCall = 1; |
| constexpr int kVerboseReportImplicitHandleConversion = 2; |
| constexpr int kVerboseReportHandleDereference = 2; |
| constexpr int kVerboseReportInterestingHandleDecl = 3; |
| constexpr int kVerboseReportInterestingFunctions = 4; |
| constexpr int kVerboseWhereAreWe = 90; |
| |
| static llvm::cl::opt<int> VERBOSE("verbose", |
| llvm::cl::desc("Set verbosity level"), |
| llvm::cl::value_desc("level"), |
| llvm::cl::init(kVerboseNone), |
| llvm::cl::cat(my_tool_category)); |
| |
| static llvm::cl::alias alias_for_VERBOSE("v", |
| llvm::cl::desc("Alias for --verbose"), |
| llvm::cl::aliasopt(VERBOSE), |
| llvm::cl::cat(my_tool_category)); |
| |
| static llvm::cl::extrahelp verbosity_help( |
| "Verbosity levels:\n" |
| "\t0:\tquiet\n" |
| "\t1:\tinteresting handle uses and function calls\n" |
| "\t2:\timplicit handle conversions and dereferences\n" |
| "\t3:\tinteresting handle declarations\n" |
| "\t4:\tinteresting function declarations\n" |
| "\t90:\ttrack AST source location\n" |
| "\n"); |
| |
| static llvm::cl::opt<bool> only_in_main_file( |
| "local", |
| llvm::cl::desc("Process only declarations in main file(s), default false"), |
| llvm::cl::init(false), |
| llvm::cl::cat(my_tool_category)); |
| |
| // Boilerplate. (Using clang::ast_matchers naming convention for these.) |
| // ---------------------------------------------------------------------------- |
| |
| TypeMatcher relaxType(TypeMatcher t) { |
| return anyOf(t, pointerType(pointee(t)), referenceType(pointee(t))); |
| } |
| |
| StatementMatcher constructorWithOneArgument(StatementMatcher argument) { |
| return cxxConstructExpr(argumentCountIs(1), |
| hasArgument(0, ignoringImplicit(argument))); |
| } |
| |
| auto handleDecl = cxxRecordDecl(isSameOrDerivedFrom("::v8::internal::Handle"), |
| isTemplateInstantiation()); |
| auto directHandleDecl = |
| cxxRecordDecl(isSameOrDerivedFrom("::v8::internal::DirectHandle"), |
| isTemplateInstantiation()); |
| TypeMatcher handleType = relaxType(hasDeclaration(handleDecl)); |
| TypeMatcher directHandleType = relaxType(hasDeclaration(directHandleDecl)); |
| |
| // Database for storing interesting variables, functions, etc. |
| // ---------------------------------------------------------------------------- |
| |
| template <typename NodeType> |
| struct ASTNodeHash { |
| size_t operator()(const NodeType* x) const { |
| return x->getLocation().getHashValue(); |
| } |
| }; |
| |
| template <typename NodeType> |
| struct ASTNodeEquals { |
| bool operator()(const NodeType* x, const NodeType* y) const { |
| return x->getLocation() == y->getLocation(); |
| } |
| }; |
| |
| class InterestingFunction; |
| |
| // A database with possibly interesting declarations of type Handle<T>. |
| class InterestingHandle { |
| public: |
| InterestingHandle(const InterestingHandle&) = delete; |
| InterestingHandle(InterestingHandle&&) = default; |
| |
| static InterestingHandle* Insert(const VarDecl* decl, bool is_definition) { |
| assert(decl != nullptr); |
| auto it = interesting_.find(decl); |
| if (it == interesting_.end()) { |
| auto p = |
| interesting_.emplace(decl, InterestingHandle{decl, is_definition}); |
| it = p.first; |
| } |
| return &it->second; |
| } |
| |
| static InterestingHandle* Lookup(const VarDecl* decl) { |
| assert(decl != nullptr); |
| auto it = interesting_.find(decl); |
| if (it == interesting_.end()) { |
| return nullptr; |
| } |
| return &it->second; |
| } |
| |
| void Print(const SourceManager& source_manager) const { |
| llvm::outs() << " location: "; |
| location_.print(llvm::outs(), source_manager); |
| llvm::outs() << "\n"; |
| llvm::outs() << " type: " << type_ << "\n"; |
| } |
| |
| void AddDependent(InterestingHandle* h) { |
| // Marks `h` as a dependent of `this`: `this` is the parameter of a |
| // function definition and `h` is the corresponding parameter of some |
| // declaration of the same function. |
| // 1. `this` is a definition and therefore must not be dependent to any |
| // other definition. |
| assert(dependent_to_ == nullptr); |
| // 2. `h` must not be dependent to any other definition. |
| assert(h->dependent_to_ == nullptr); |
| // 3. `h` is in a declaration and therefore it must not have dependents. |
| assert(h->list_of_dependent_.empty()); |
| list_of_dependent_.push_back(h); |
| h->dependent_to_ = this; |
| } |
| |
| void AddAsParameter(InterestingFunction* f) { |
| if (function_ != nullptr && function_ != f) { |
| llvm::outs() |
| << "Warning: adding as a parameter to a different function\n"; |
| } |
| function_ = f; |
| } |
| |
| bool CanMigrate() const; |
| Replacement GetReplacement() const { return replacement_.value(); } |
| |
| // This method registers a usage of an interesting variable. The first |
| // parameter corresponds to the AST node where the variable is used, |
| // whereas the second parameter advises if migration should be possible. |
| // We want to disallow migration if a variable is used (at least once) in a |
| // context where a `Handle<T>` is really required. When the AST is traversed |
| // and a node with a variable usage is visited, the matcher callbacks will be |
| // invoked consecutively for that node, in the order that they were added to |
| // the match finder. These callbacks, independently from one another, may |
| // invoke this method to advise whether migration should be possible. |
| // Migration is prevented when this method is called for a variable's use for |
| // the first time with migrate = false. If it has previously been called for |
| // the same variable use with migrate = true, then migration is not prevented. |
| // Evidently, the order in which the matcher callbacks are added to the finder |
| // is very important. See the comment before `HandleUseVisitor` for a detailed |
| // example. |
| void RegisterUsage(const DeclRefExpr* use, bool migrate) { |
| if (dependent_to_ != nullptr) { |
| llvm::outs() << "Warning: use of handle that is marked as dependent\n"; |
| } |
| if (use != previous_use_ && !migrate) { |
| replacement_.reset(); |
| } |
| previous_use_ = use; |
| } |
| |
| private: |
| InterestingHandle(const VarDecl* decl, bool is_definition) |
| : is_definition_(is_definition), |
| type_(decl->getType().getAsString()), |
| location_(decl->getLocation()) { |
| // If this is not a definition, bail out, otherwise let's be optimistic and |
| // generate the replacement for migration! |
| if (!is_definition_) { |
| return; |
| } |
| |
| // We get the |replacement_range| in a bit clumsy way, because clang docs |
| // for QualifiedTypeLoc explicitly say that these objects "intentionally |
| // do not provide source location for type qualifiers". |
| const auto& source_manager = decl->getASTContext().getSourceManager(); |
| const auto& options = decl->getASTContext().getLangOpts(); |
| auto first_token_loc = source_manager.getSpellingLoc(decl->getBeginLoc()); |
| auto last_token_loc = |
| source_manager.getSpellingLoc(decl->getTypeSpecEndLoc()); |
| auto end_loc = |
| Lexer::getLocForEndOfToken(last_token_loc, 0, source_manager, options); |
| auto range = CharSourceRange::getCharRange(first_token_loc, end_loc); |
| |
| auto original_text = |
| Lexer::getSourceText(range, source_manager, options).str(); |
| std::regex re_handle("\\bHandle<"); |
| auto replacement_text = |
| std::regex_replace(original_text, re_handle, "DirectHandle<"); |
| |
| if (original_text != replacement_text) { |
| replacement_.emplace(source_manager, range, replacement_text); |
| } |
| } |
| |
| bool is_definition_; |
| std::string type_; |
| SourceLocation location_; |
| std::optional<Replacement> replacement_; |
| const DeclRefExpr* previous_use_ = nullptr; |
| |
| // For parameters, this points to the corresponding function. |
| InterestingFunction* function_ = nullptr; |
| // For parameters of a function declaration, this points to the |
| // corresponding parameter of the function definition. |
| InterestingHandle* dependent_to_ = nullptr; |
| // For parameters of a function definition, this contains a list |
| // of all the corresponding parameters of function declarations (if any). |
| std::vector<InterestingHandle*> list_of_dependent_; |
| |
| using Container = std::unordered_map<const VarDecl*, |
| InterestingHandle, |
| ASTNodeHash<VarDecl>, |
| ASTNodeEquals<VarDecl>>; |
| static Container interesting_; |
| }; |
| |
| InterestingHandle::Container InterestingHandle::interesting_; |
| |
| // A database with all interesting functions. |
| class InterestingFunction { |
| public: |
| InterestingFunction(const InterestingFunction&) = delete; |
| InterestingFunction(InterestingFunction&&) = default; |
| |
| static InterestingFunction* Insert(const FunctionDecl* decl) { |
| assert(decl != nullptr); |
| auto it = interesting_.find(decl); |
| if (it == interesting_.end()) { |
| auto p = interesting_.emplace(decl, InterestingFunction{decl}); |
| it = p.first; |
| } |
| return &it->second; |
| } |
| |
| static InterestingFunction* Lookup(const FunctionDecl* decl) { |
| assert(decl != nullptr); |
| auto it = interesting_.find(decl); |
| if (it == interesting_.end()) { |
| return nullptr; |
| } |
| return &it->second; |
| } |
| |
| void AddOrCheckParameter(const ParmVarDecl* param, InterestingHandle* p) { |
| unsigned i = param->getFunctionScopeIndex(); |
| if (i >= parameters_.size()) { |
| llvm::outs() << "Warning: parameter " << i |
| << " does not exist, there are only " << parameters_.size() |
| << " parameters\n"; |
| return; |
| } |
| if (parameters_[i] == nullptr) { |
| parameters_[i] = p; |
| p->AddAsParameter(this); |
| } else if (parameters_[i] != p) { |
| const auto& source_manager = param->getASTContext().getSourceManager(); |
| llvm::outs() << "Warning: parameter " << i << " has already been added\n"; |
| llvm::outs() << " previous:\n"; |
| parameters_[i]->Print(source_manager); |
| llvm::outs() << " current:\n"; |
| p->Print(source_manager); |
| } |
| } |
| |
| void AddLocalVariable(InterestingHandle* v) { local_vars_.push_back(v); } |
| |
| const std::vector<InterestingHandle*>& parameters() const { |
| return parameters_; |
| } |
| |
| const std::vector<InterestingHandle*>& local_vars() const { |
| return local_vars_; |
| } |
| |
| bool is_special() const { return is_special_; } |
| |
| static std::set<Replacement> GetReplacements() { |
| std::set<Replacement> result; |
| for (const auto& [_, f] : interesting_) { |
| for (InterestingHandle* p : f.parameters()) { |
| if (p != nullptr && p->CanMigrate()) { |
| result.insert(p->GetReplacement()); |
| } |
| } |
| for (InterestingHandle* v : f.local_vars()) { |
| if (v->CanMigrate()) { |
| result.insert(v->GetReplacement()); |
| } |
| } |
| } |
| return result; |
| } |
| |
| private: |
| explicit InterestingFunction(const FunctionDecl* decl) |
| : name_(decl->getQualifiedNameAsString()), |
| location_(decl->getLocation()), |
| parameters_(decl->getNumParams(), nullptr) { |
| if (auto* method_decl = dyn_cast<CXXMethodDecl>(decl)) { |
| is_special_ = method_decl->isVirtual(); |
| } else { |
| is_special_ = decl->isTemplateInstantiation() || |
| decl->isFunctionTemplateSpecialization(); |
| } |
| } |
| |
| std::string name_; |
| SourceLocation location_; |
| bool is_special_ = false; |
| std::vector<InterestingHandle*> parameters_; |
| std::vector<InterestingHandle*> local_vars_; |
| |
| using Container = std::unordered_map<const FunctionDecl*, |
| InterestingFunction, |
| ASTNodeHash<FunctionDecl>, |
| ASTNodeEquals<FunctionDecl>>; |
| static Container interesting_; |
| }; |
| |
| InterestingFunction::Container InterestingFunction::interesting_; |
| |
| bool InterestingHandle::CanMigrate() const { |
| if (dependent_to_ != nullptr) { |
| return dependent_to_->CanMigrate(); |
| } |
| if (!is_definition_) { |
| return false; |
| } |
| if (function_ != nullptr && function_->is_special()) { |
| return false; |
| } |
| return replacement_.has_value(); |
| } |
| |
| // Keep track of where we are, in the AST. |
| // This is used only for debugging purposes. |
| // ---------------------------------------------------------------------------- |
| class WhereWeAreVisitor : public MatchFinder::MatchCallback { |
| private: |
| static DeclarationMatcher matcher() { return decl().bind("decl"); } |
| |
| public: |
| explicit WhereWeAreVisitor(MatchFinder& finder) { |
| finder.addMatcher(matcher(), this); |
| } |
| |
| void run(MatchFinder::MatchResult const& Result) override { |
| auto* decl = Result.Nodes.getNodeAs<Decl>("decl"); |
| assert(decl != nullptr); |
| |
| if (VERBOSE >= kVerboseWhereAreWe) { |
| ASTContext* context = Result.Context; |
| auto loc = decl->getBeginLoc(); |
| llvm::outs() << "At: " << decl->getDeclKindName() << " "; |
| loc.print(llvm::outs(), context->getSourceManager()); |
| llvm::outs() << "\n"; |
| } |
| } |
| }; |
| |
| // Find and record interesting functions: |
| // - some parameter is a Handle<T>, or |
| // - the result is a Handle<T>, or |
| // - is a method of Handle<T>, because the object pointed to by `this` is a |
| // `Handle<T>`. |
| // ---------------------------------------------------------------------------- |
| class InterestingFunctionVisitor : public MatchFinder::MatchCallback { |
| private: |
| static DeclarationMatcher matcher() { |
| return functionDecl(anyOf(hasAnyParameter(parmVarDecl(hasType(handleType))), |
| returns(handleType), |
| cxxMethodDecl(ofClass(handleDecl)))) |
| .bind("interesting-function"); |
| } |
| |
| public: |
| explicit InterestingFunctionVisitor(MatchFinder& finder, |
| bool only_in_main_file = false) |
| : only_in_main_file_(only_in_main_file) { |
| finder.addMatcher(matcher(), this); |
| } |
| |
| void run(MatchFinder::MatchResult const& Result) override { |
| auto* decl = Result.Nodes.getNodeAs<FunctionDecl>("interesting-function"); |
| assert(decl != nullptr); |
| |
| if (only_in_main_file_) { |
| ASTContext* context = Result.Context; |
| if (!context->getSourceManager().isWrittenInMainFile( |
| decl->getBeginLoc())) { |
| return; |
| } |
| } |
| |
| InterestingFunction::Insert(decl); |
| |
| if (VERBOSE >= kVerboseReportInterestingFunctions) { |
| ASTContext* context = Result.Context; |
| auto loc = decl->getBeginLoc(); |
| llvm::outs() << "Func: "; |
| loc.print(llvm::outs(), context->getSourceManager()); |
| llvm::outs() << "\n"; |
| llvm::outs() << " name " << decl->getQualifiedNameAsString() << "\n"; |
| for (const auto& param : decl->parameters()) { |
| auto type = param->getOriginalType(); |
| llvm::outs() << " param " << param->getFunctionScopeIndex() |
| << " of type " << type.getAsString() << "\n"; |
| } |
| auto result_type = decl->getCallResultType(); |
| llvm::outs() << " result " << result_type.getAsString() << "\n"; |
| llvm::outs() << " templated kind " << decl->getTemplatedKind() << "\n"; |
| } |
| } |
| |
| private: |
| bool only_in_main_file_; |
| }; |
| |
| // Find and record interesting variables. |
| // - of type Handle<T>; and |
| // - local variables or parameters. |
| // ---------------------------------------------------------------------------- |
| class HandleDeclVisitor : public MatchFinder::MatchCallback { |
| private: |
| static DeclarationMatcher matcher() { |
| return anyOf( |
| varDecl(allOf(hasLocalStorage(), hasType(handleType), |
| hasAncestor(functionDecl().bind("func-decl")))) |
| .bind("var-decl"), |
| bindingDecl(allOf(hasType(handleType), |
| hasAncestor(functionDecl().bind("func-decl")))) |
| .bind("binding-decl")); |
| } |
| |
| public: |
| explicit HandleDeclVisitor(MatchFinder& finder, |
| bool only_in_main_file = false) |
| : only_in_main_file_(only_in_main_file) { |
| finder.addMatcher(matcher(), this); |
| } |
| |
| void run(MatchFinder::MatchResult const& Result) override { |
| auto* decl = Result.Nodes.getNodeAs<VarDecl>("var-decl"); |
| if (decl == nullptr) { |
| auto* binding = Result.Nodes.getNodeAs<BindingDecl>("binding-decl"); |
| assert(binding != nullptr); |
| decl = binding->getHoldingVar(); |
| assert(decl != nullptr); |
| } |
| |
| if (only_in_main_file_) { |
| ASTContext* context = Result.Context; |
| if (!context->getSourceManager().isWrittenInMainFile( |
| decl->getBeginLoc())) { |
| return; |
| } |
| } |
| |
| auto* func_decl = Result.Nodes.getNodeAs<FunctionDecl>("func-decl"); |
| assert(func_decl != nullptr); |
| |
| if (auto* param = dyn_cast<ParmVarDecl>(decl)) { |
| auto* ctxt = param->getDeclContext(); |
| assert(ctxt != nullptr); |
| auto type = param->getType(); |
| auto* func = dyn_cast<FunctionDecl>(ctxt); |
| if (func == nullptr) { |
| // TODO(42203211): This may happen, for example, if a handle parameter |
| // is part of some other parameter's type, e.g. |
| // |
| // void f(std::function<void(Handle<HeapObject>)> g); |
| // |
| // Migrating higher-order functions is out of the scope of this tool |
| // right now. For migrating the definition of `f` here, we would need to |
| // check all its call sites and see what the actual function passed as |
| // the `g` parameter is. If the actual parameter can be migrated in all |
| // cases to a function expecting a `DirectHandle`, then `f` can be |
| // migrated, otherwise it cannot. |
| // |
| // Such cases are ignored now and we expect that they be migrated |
| // manually. |
| llvm::outs() << "Warning: this parameter does not lead to function " |
| "declaration\n"; |
| ASTContext* context = Result.Context; |
| auto loc = decl->getBeginLoc(); |
| llvm::outs() << "Decl parm: "; |
| loc.print(llvm::outs(), context->getSourceManager()); |
| llvm::outs() << "\n"; |
| llvm::outs() << " type " << type.getAsString() << "\n"; |
| llvm::outs() << " index " << param->getFunctionScopeIndex() << "\n"; |
| return; |
| } |
| if (func != func_decl) { |
| llvm::outs() << "Warning: function declaration mismatch\n"; |
| llvm::outs() << " func: " << *func << "\n"; |
| llvm::outs() << " func_decl: " << *func_decl << "\n"; |
| } |
| auto* f = InterestingFunction::Lookup(func_decl); |
| if (f != nullptr && !func_decl->isDefaulted() && |
| !func_decl->isTemplateInstantiation()) { |
| auto* p = InterestingHandle::Lookup(param); |
| if (p == nullptr) { |
| bool is_definition = func_decl->hasBody(); |
| p = InterestingHandle::Insert(param, is_definition); |
| // If there's no function definition, nothing to be done yet. |
| if (auto* func_def = func_decl->getDefinition()) { |
| if (func_def == func_decl) { |
| // If this is the function definition. |
| assert(is_definition); |
| // Look for all registered declarations of this function. |
| for (const auto& prev_decl : func_decl->redecls()) { |
| if (auto* d = InterestingFunction::Lookup(prev_decl)) { |
| // Mark the corresponding parameter of the declaration as |
| // dependent to this entry. |
| auto* q = d->parameters()[param->getFunctionScopeIndex()]; |
| if (q != nullptr) { |
| p->AddDependent(q); |
| } |
| } |
| } |
| } else if (auto* d = InterestingFunction::Lookup(func_def)) { |
| // If there is a registered function definition, mark this entry |
| // as dependent to the corresponding parameter of the function |
| // definition. |
| auto* q = d->parameters()[param->getFunctionScopeIndex()]; |
| assert(q != nullptr); |
| q->AddDependent(p); |
| } |
| } |
| } |
| f->AddOrCheckParameter(param, p); |
| } |
| |
| if (VERBOSE >= kVerboseReportInterestingHandleDecl) { |
| ASTContext* context = Result.Context; |
| auto loc = decl->getBeginLoc(); |
| llvm::outs() << "Decl parm: "; |
| loc.print(llvm::outs(), context->getSourceManager()); |
| llvm::outs() << "\n"; |
| llvm::outs() << " type " << type.getAsString() << "\n"; |
| llvm::outs() << " index " << param->getFunctionScopeIndex() << "\n"; |
| llvm::outs() << " func " << func->getQualifiedNameAsString() << "\n"; |
| } |
| } else { |
| auto* p = InterestingHandle::Insert(decl, true); |
| auto* f = InterestingFunction::Lookup(func_decl); |
| if (!func_decl->isDefaulted() && !func_decl->isTemplateInstantiation()) { |
| if (f == nullptr) { |
| assert(func_decl->hasBody()); |
| f = InterestingFunction::Insert(func_decl); |
| } |
| assert(f != nullptr); |
| f->AddLocalVariable(p); |
| } |
| |
| if (VERBOSE >= kVerboseReportInterestingHandleDecl) { |
| ASTContext* context = Result.Context; |
| auto loc = decl->getBeginLoc(); |
| llvm::outs() << "Decl var: "; |
| loc.print(llvm::outs(), context->getSourceManager()); |
| llvm::outs() << "\n" |
| << " type " << decl->getType().getAsString() << "\n"; |
| } |
| } |
| } |
| |
| private: |
| bool only_in_main_file_; |
| }; |
| |
| // Find and process uses of handle parameters or variables. |
| // |
| // Tracking such uses is important, because we want to disallow the migration of |
| // a variable's type from `Handle<T>` to `DirectHandle<T>` if the variable is |
| // used (at least once) in a context where a `Handle<T>` is really required. |
| // In general, if a variable of type `Handle<T>` is used, we need to prevent the |
| // migration of a variable. This is the purpose of `HandleUseVisitor`. However, |
| // there are cases when such a variable is used in a manner that is compatible |
| // with a `DirectHandle<T>`, e.g., when the handle is dereferenced, or |
| // implicitly converted to a direct handle. In these cases there is no need to |
| // prevent the migration and this is the purpose of more specific visitors, such |
| // as `HandleDereferenceVisitor` or `ImplicitHandleToDirectHandleVisitor` below. |
| // |
| // As mentioned in the comment before `InterestingHandle::RegisterUsage`, the |
| // order in which visitors are executed is important. For a given variable |
| // usage, migration is prevented if the first executed visitor decides to |
| // prevent it. |
| // |
| // Consider the following example: |
| // |
| // void consume_direct(DirectHandle<HeapObject> o); /* line: 1 */ |
| // Handle<HeapObject> h; /* line: 2 */ |
| // consume_direct(h); /* line: 3 */ |
| // Tagged<Map> map = h->map(); /* line: 4 */ |
| // |
| // The use of variable `h` in line 3 will be processed by two visitors: |
| // |
| // 1. `HandleUseVisitor` (this one), which will claim that the use of this |
| // variable is reason enough for disallowing its migration. |
| // 2. `ImplicitHandleToDirectHandleVisitor` (below), which will realize that |
| // the handle is implicitly converted to a direct handle, therefore we can |
| // allow its migration. |
| // |
| // Because visitor 1 is added last to the match finder (we rely on this), |
| // visitor 2 will run before visitor 1 for this node, thus not preventing the |
| // migration. |
| // |
| // Similarly, the use of variable `h` in line 4 will be processed by two |
| // visitors: first `HandleDereferenceVisitor` and then `HandleUseVisitor`, in |
| // this order, and migration will again not be prevented. As none of the |
| // variable's uses has prevented migration, the type of variable `h` in line 2 |
| // will be migrated from `Handle<HeapObject>` to `DirectHandle<HeapObject>`. |
| // ---------------------------------------------------------------------------- |
| class HandleUseVisitor : public MatchFinder::MatchCallback { |
| public: |
| static StatementMatcher matcher() { |
| return declRefExpr( |
| allOf(to(varDecl().bind("var-decl")), hasType(handleType), |
| hasAncestor( |
| functionDecl(allOf(isDefinition(), hasBody(stmt()))) |
| .bind("func-def")))) |
| .bind("handle-use"); |
| } |
| |
| public: |
| explicit HandleUseVisitor(MatchFinder& finder, bool only_in_main_file = false) |
| : only_in_main_file_(only_in_main_file) { |
| finder.addMatcher(matcher(), this); |
| } |
| |
| void run(MatchFinder::MatchResult const& Result) override { |
| auto* use = Result.Nodes.getNodeAs<DeclRefExpr>("handle-use"); |
| assert(use != nullptr); |
| auto* decl = Result.Nodes.getNodeAs<VarDecl>("var-decl"); |
| assert(decl != nullptr); |
| auto* func = Result.Nodes.getNodeAs<FunctionDecl>("func-def"); |
| assert(func != nullptr); |
| |
| if (only_in_main_file_) { |
| ASTContext* context = Result.Context; |
| if (!context->getSourceManager().isWrittenInMainFile( |
| use->getBeginLoc())) { |
| return; |
| } |
| } |
| |
| auto* h = InterestingHandle::Lookup(decl); |
| assert(h != nullptr || func->isDefaulted() || |
| func->isTemplateInstantiation()); |
| |
| if (VERBOSE >= kVerboseReportInterestingHandleUse) { |
| auto type = decl->getType(); |
| ASTContext* context = Result.Context; |
| auto loc = use->getBeginLoc(); |
| llvm::outs() << "Use var: "; |
| loc.print(llvm::outs(), context->getSourceManager()); |
| llvm::outs() << "\n"; |
| llvm::outs() << " var of type " << type.getAsString() << "\n"; |
| } |
| |
| if (h != nullptr) { |
| // This will disallow migration, unless some other more specific visitor |
| // has already run and explicitly allowed migration for the same variable |
| // usage. Here, we rely on the fact that `HandleUseVisitor` is added last |
| // to the match finder, therefore it will run last for any given AST node. |
| h->RegisterUsage(use, false); |
| } |
| } |
| |
| private: |
| bool only_in_main_file_; |
| }; |
| |
| // Find and process calls to interesting functions. |
| // Currently, this does nothing interesting except for logging. |
| // ---------------------------------------------------------------------------- |
| class CallExprWithHandleVisitor : public MatchFinder::MatchCallback { |
| private: |
| static StatementMatcher matcher() { |
| return callExpr(hasAnyArgument(hasType(handleType))).bind("call-expr"); |
| } |
| |
| public: |
| explicit CallExprWithHandleVisitor(MatchFinder& finder, |
| bool only_in_main_file = false) |
| : only_in_main_file_(only_in_main_file) { |
| finder.addMatcher(matcher(), this); |
| } |
| |
| void run(MatchFinder::MatchResult const& Result) override { |
| auto* call = Result.Nodes.getNodeAs<CallExpr>("call-expr"); |
| assert(call != nullptr); |
| |
| if (only_in_main_file_) { |
| ASTContext* context = Result.Context; |
| if (!context->getSourceManager().isWrittenInMainFile( |
| call->getBeginLoc())) { |
| return; |
| } |
| } |
| |
| auto* decl = call->getCalleeDecl(); |
| // This happens when we have a call with an unresolved expression in a |
| // template definition. |
| if (decl == nullptr) { |
| return; |
| } |
| auto* func = dyn_cast<FunctionDecl>(decl); |
| if (func == nullptr) { |
| llvm::outs() << "Warning: This is not a FunctionDecl but a " |
| << decl->getDeclKindName() << "\n"; |
| return; |
| } |
| |
| if (VERBOSE >= kVerboseReportInterestingFunctionCall) { |
| ASTContext* context = Result.Context; |
| auto loc = call->getBeginLoc(); |
| llvm::outs() << "Call: "; |
| loc.print(llvm::outs(), context->getSourceManager()); |
| llvm::outs() << "\n"; |
| llvm::outs() << " callee " << func->getQualifiedNameAsString() << "\n"; |
| |
| int i = 0; |
| for (const auto& arg : call->arguments()) { |
| auto type = arg->getType(); |
| llvm::outs() << " param " << i << " of type " << type.getAsString() |
| << "\n"; |
| ++i; |
| } |
| } |
| } |
| |
| private: |
| bool only_in_main_file_; |
| }; |
| |
| // Implicit Handle<T> -> DirectHandle<T> conversions. |
| // They do not prevent handle migration. |
| // ---------------------------------------------------------------------------- |
| class ImplicitHandleToDirectHandleVisitor : public MatchFinder::MatchCallback { |
| private: |
| static StatementMatcher matcher() { |
| return implicitCastExpr( |
| allOf(hasImplicitDestinationType(directHandleType), |
| hasCastKind(CK_ConstructorConversion), |
| hasSourceExpression( |
| constructorWithOneArgument(constructorWithOneArgument( |
| HandleUseVisitor::matcher()))))) |
| .bind("implicit-cast"); |
| } |
| |
| public: |
| explicit ImplicitHandleToDirectHandleVisitor(MatchFinder& finder, |
| bool only_in_main_file = false) |
| : only_in_main_file_(only_in_main_file) { |
| finder.addMatcher(matcher(), this); |
| } |
| |
| void run(MatchFinder::MatchResult const& Result) override { |
| auto* expr = Result.Nodes.getNodeAs<ImplicitCastExpr>("implicit-cast"); |
| assert(expr != nullptr); |
| |
| if (only_in_main_file_) { |
| ASTContext* context = Result.Context; |
| if (!context->getSourceManager().isWrittenInMainFile( |
| expr->getBeginLoc())) { |
| return; |
| } |
| } |
| |
| if (VERBOSE >= kVerboseReportImplicitHandleConversion) { |
| ASTContext* context = Result.Context; |
| auto loc = expr->getBeginLoc(); |
| llvm::outs() << "H->DH: "; |
| loc.print(llvm::outs(), context->getSourceManager()); |
| llvm::outs() << "\n"; |
| } |
| |
| auto* use = Result.Nodes.getNodeAs<DeclRefExpr>("handle-use"); |
| assert(use != nullptr); |
| auto* decl = Result.Nodes.getNodeAs<VarDecl>("var-decl"); |
| assert(decl != nullptr); |
| |
| auto* h = InterestingHandle::Lookup(decl); |
| if (h != nullptr) { |
| // This will allow migration for this variable usage. |
| h->RegisterUsage(use, true); |
| } |
| } |
| |
| private: |
| bool only_in_main_file_; |
| }; |
| |
| // Handle<T>::operator* and Handle<T>::operator-> |
| // They do not prevent handle migration. |
| // ---------------------------------------------------------------------------- |
| class HandleDereferenceVisitor : public MatchFinder::MatchCallback { |
| private: |
| static StatementMatcher matcher() { |
| return cxxOperatorCallExpr( |
| hasAnyOverloadedOperatorName("*", "->"), |
| hasAnyArgument(ignoringImplicit(HandleUseVisitor::matcher()))) |
| .bind("handle-deref"); |
| } |
| |
| public: |
| explicit HandleDereferenceVisitor(MatchFinder& finder, |
| bool only_in_main_file = false) |
| : only_in_main_file_(only_in_main_file) { |
| finder.addMatcher(matcher(), this); |
| } |
| |
| void run(MatchFinder::MatchResult const& Result) override { |
| auto* expr = Result.Nodes.getNodeAs<CXXOperatorCallExpr>("handle-deref"); |
| assert(expr != nullptr); |
| |
| if (only_in_main_file_) { |
| ASTContext* context = Result.Context; |
| if (!context->getSourceManager().isWrittenInMainFile( |
| expr->getBeginLoc())) { |
| return; |
| } |
| } |
| |
| if (VERBOSE >= kVerboseReportHandleDereference) { |
| ASTContext* context = Result.Context; |
| auto loc = expr->getBeginLoc(); |
| llvm::outs() << "Handle deref: "; |
| loc.print(llvm::outs(), context->getSourceManager()); |
| llvm::outs() << "\n"; |
| } |
| |
| auto* use = Result.Nodes.getNodeAs<DeclRefExpr>("handle-use"); |
| assert(use != nullptr); |
| auto* decl = Result.Nodes.getNodeAs<VarDecl>("var-decl"); |
| assert(decl != nullptr); |
| |
| auto* h = InterestingHandle::Lookup(decl); |
| if (h != nullptr) { |
| // This will allow migration for this variable usage. |
| h->RegisterUsage(use, true); |
| } |
| } |
| |
| private: |
| bool only_in_main_file_; |
| }; |
| |
| // Main program. |
| // ---------------------------------------------------------------------------- |
| |
| int main(int argc, const char* argv[]) { |
| auto expected_parser = |
| CommonOptionsParser::create(argc, argv, my_tool_category); |
| if (!expected_parser) { |
| // Fail gracefully for unsupported options. |
| llvm::errs() << expected_parser.takeError(); |
| return 1; |
| } |
| CommonOptionsParser& options_parser = expected_parser.get(); |
| ClangTool Tool(options_parser.getCompilations(), |
| options_parser.getSourcePathList()); |
| |
| MatchFinder finder; |
| std::optional<WhereWeAreVisitor> where_we_are_visitor; |
| if (VERBOSE >= kVerboseWhereAreWe) { |
| where_we_are_visitor.emplace(finder); |
| } |
| |
| // These populate the database of functions and handle declarations. |
| InterestingFunctionVisitor interesting_function_visitor(finder, |
| only_in_main_file); |
| HandleDeclVisitor handle_decl_visitor(finder, only_in_main_file); |
| // These allow migration in some special cases. |
| HandleDereferenceVisitor handle_deref_callback(finder, only_in_main_file); |
| ImplicitHandleToDirectHandleVisitor implicit_conversion_visitor( |
| finder, only_in_main_file); |
| // This is not used, except for logging. |
| std::optional<CallExprWithHandleVisitor> call_expr_with_handle_visitor; |
| if (VERBOSE >= kVerboseReportInterestingFunctionCall) { |
| call_expr_with_handle_visitor.emplace(finder, only_in_main_file); |
| } |
| // This needs to be last, to disallow migration in all other cases. |
| HandleUseVisitor handle_use_callback(finder, only_in_main_file); |
| |
| int error_code = Tool.run(newFrontendActionFactory(&finder).get()); |
| if (error_code) { |
| return error_code; |
| } |
| |
| std::set<Replacement> replacements = InterestingFunction::GetReplacements(); |
| if (replacements.empty()) { |
| return 0; |
| } |
| |
| // Serialization format is documented in tools/clang/scripts/run_tool.py |
| llvm::outs() << "==== BEGIN EDITS ====\n"; |
| for (const auto& r : replacements) { |
| std::string replacement_text = r.getReplacementText().str(); |
| std::replace(replacement_text.begin(), replacement_text.end(), '\n', '\0'); |
| llvm::outs() << "r:::" << r.getFilePath() << ":::" << r.getOffset() |
| << ":::" << r.getLength() << ":::" << replacement_text << "\n"; |
| } |
| llvm::outs() << "==== END EDITS ====\n"; |
| |
| return 0; |
| } |
