diff options
Diffstat (limited to 'compilerplugins/clang/sharedvisitor')
| -rw-r--r-- | compilerplugins/clang/sharedvisitor/README | 45 | ||||
| -rw-r--r-- | compilerplugins/clang/sharedvisitor/analyzer.cxx | 299 | ||||
| -rw-r--r-- | compilerplugins/clang/sharedvisitor/dummyplugin.hxx | 81 | ||||
| -rw-r--r-- | compilerplugins/clang/sharedvisitor/generator.cxx | 480 | ||||
| -rw-r--r-- | compilerplugins/clang/sharedvisitor/precompiled_clang.hxx | 12 |
5 files changed, 917 insertions, 0 deletions
diff --git a/compilerplugins/clang/sharedvisitor/README b/compilerplugins/clang/sharedvisitor/README new file mode 100644 index 000000000..7b4a8b3c7 --- /dev/null +++ b/compilerplugins/clang/sharedvisitor/README @@ -0,0 +1,45 @@ +These tools generate another "plugin" which in fact only dispatches Visit* and Traverse* +calls to all other plugins registered with it. This means that there is just one +RecursiveASTVisitor pass for all those plugins instead of one per each, which +with the current number of plugins actually makes a performance difference. + +If you work on a plugin, comment out LO_CLANG_SHARED_PLUGINS in Makefile-clang.mk in order +to disable the feature (re-generating takes time). + +There are two tools: +- analyzer, which analyses one .cxx file (one plugins) and writes info about it to a .plugininfo + file, this allows parallelising this part, since it can take some time +- generator, which reads all the .plugininfo files and generates sharedvisitor.cxx + +Requirements for plugins: +- Can use Visit* and Traverse* functions, but not WalkUp*. +- Visit* functions can generally remain unmodified. +- run() function must be split into preRun() and postRun() if there's any additional functionality + besides calling TraverseDecl(). The shared visitor will call the preRun() and postRun() functions + as necessary while calling its own run(). The run() function of the plugin must stay + (in case of a non-shared build) but should generally look like this: + if( preRun()) + if( TraverseDecl(compiler.getASTContext().getTranslationUnitDecl())) + postRun(); +- Traverse* functions must be split into PreTraverse* and PostTraverse*, similarly to how run() + is handled, the Traverse* function should generally look like this: + bool ret = true; + if( PreTraverse*(decl)) + { + ret = RecursiveASTVisitor::Traverse*(decl); + PostTraverse*(decl, ret); + } + return ret; + + +TODO: +- Create macros for the standardized layout of run(), Traverse*, etc.? +- Possibly check plugin sources more thoroughly (e.g. that run() doesn't actually do more). +- Have one tool that extracts info from plugin .cxx files into some .txt file and another tool + that generates sharedvisitor.cxx based on those files? That would generally make the generation + faster when doing incremental changes. The .txt file could also contain some checksum of the .cxx + to avoid the analysing pass completely if just the timestamp has changed. +- Do not re-compile sharedvisitor.cxx if its contents have not actually changed. +- Is it possible to make the clang code analyze just the .cxx without also parsing all the headers? +- Instead of having to comment out LO_CLANG_SHARED_PLUGINS, implement --enable-compiler-plugins=debug . +- Try make analyzer use a precompiled header of Clang headers, for better performance. diff --git a/compilerplugins/clang/sharedvisitor/analyzer.cxx b/compilerplugins/clang/sharedvisitor/analyzer.cxx new file mode 100644 index 000000000..a000bd249 --- /dev/null +++ b/compilerplugins/clang/sharedvisitor/analyzer.cxx @@ -0,0 +1,299 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ + +#include "clang/AST/ASTConsumer.h" +#include "clang/AST/RecursiveASTVisitor.h" +#include "clang/Frontend/CompilerInstance.h" +#include "clang/Frontend/FrontendAction.h" +#include "clang/Tooling/Tooling.h" +#include "llvm/ADT/StringExtras.h" + +#include <cassert> +#include <cstddef> +#include <cstring> +#include <iostream> +#include <memory> +#include <fstream> +#include <set> + +#include "config_clang.h" +#include "../check.hxx" +#include "../check.cxx" + +using namespace clang; +using namespace llvm; + +using namespace loplugin; + +// Info about a Traverse* function in a plugin. +struct TraverseFunctionInfo +{ + std::string name; + std::string argument; + bool hasPre = false; + bool hasPost = false; +}; + +struct TraverseFunctionInfoLess +{ + bool operator()( const TraverseFunctionInfo& l, const TraverseFunctionInfo& r ) const + { + return l.name < r.name; + } +}; + +static std::set< TraverseFunctionInfo, TraverseFunctionInfoLess > traverseFunctions; + +class CheckFileVisitor + : public RecursiveASTVisitor< CheckFileVisitor > +{ +public: + void setContext(ASTContext const& context) { context_ = &context; } + + bool VisitCXXRecordDecl(CXXRecordDecl *Declaration); + + bool TraverseNamespaceDecl(NamespaceDecl * decl) + { + // Skip non-LO namespaces the same way FilteringPlugin does. + if( !ContextCheck( decl ).Namespace( "loplugin" ).GlobalNamespace() + && !ContextCheck( decl ).AnonymousNamespace()) + { + return true; + } + return RecursiveASTVisitor<CheckFileVisitor>::TraverseNamespaceDecl(decl); + } + +private: + ASTContext const* context_ = nullptr; + + QualType unqualifyPointeeType(QualType type) + { + assert(context_ != nullptr); + if (auto const t = type->getAs<clang::PointerType>()) + { + return context_->getQualifiedType( + context_->getPointerType(t->getPointeeType().getUnqualifiedType()), + type.getQualifiers()); + } + return type; + } +}; + +static bool inheritsPluginClassCheck( const Decl* decl ) +{ + return bool( DeclCheck( decl ).Class( "FilteringPlugin" ).Namespace( "loplugin" ).GlobalNamespace()) + || bool( DeclCheck( decl ).Class( "FilteringRewritePlugin" ).Namespace( "loplugin" ).GlobalNamespace()); +} + +static TraverseFunctionInfo findOrCreateTraverseFunctionInfo( StringRef name ) +{ + TraverseFunctionInfo info; + info.name = name.str(); + auto foundInfo = traverseFunctions.find( info ); + if( foundInfo != traverseFunctions.end()) + { + info = std::move( *foundInfo ); + traverseFunctions.erase( foundInfo ); + } + return info; +} + +static bool foundSomething; + +bool CheckFileVisitor::VisitCXXRecordDecl( CXXRecordDecl* decl ) +{ + if( !isDerivedFrom( decl, inheritsPluginClassCheck )) + return true; + + if( decl->getName() == "FilteringPlugin" || decl->getName() == "FilteringRewritePlugin" ) + return true; + + std::cout << "# This file is autogenerated. Do not modify." << std::endl; + std::cout << "# Generated by compilerplugins/clang/sharedvisitor/analyzer.cxx ." << std::endl; + std::cout << "InfoVersion:1" << std::endl; + std::cout << "ClassName:" << decl->getName().str() << std::endl; + traverseFunctions.clear(); + for( const CXXMethodDecl* method : decl->methods()) + { + if( !method->getDeclName().isIdentifier()) + continue; + if( method->isStatic() || method->getAccess() != AS_public ) + continue; + if( method->getName().startswith( "Visit" )) + { + if( method->getNumParams() == 1 ) + { + std::cout << "VisitFunctionStart" << std::endl; + std::cout << "VisitFunctionName:" << method->getName().str() << std::endl; + std::cout << "VisitFunctionArgument:" + << unqualifyPointeeType( + method->getParamDecl( 0 )->getTypeSourceInfo()->getType()).getAsString() + << std::endl; + std::cout << "VisitFunctionEnd" << std::endl; + } + else + { + std::cerr << "Unhandled Visit* function: " << decl->getName().str() + << "::" << method->getName().str() << std::endl; + abort(); + } + } + else if( method->getName().startswith( "Traverse" )) + { + if( method->getNumParams() == 1 ) + { + TraverseFunctionInfo traverseInfo = findOrCreateTraverseFunctionInfo( method->getName()); + traverseInfo.argument = method->getParamDecl( 0 )->getTypeSourceInfo()->getType().getAsString(); + traverseFunctions.insert( std::move( traverseInfo )); + } + else + { + std::cerr << "Unhandled Traverse* function: " << decl->getName().str() + << "::" << method->getName().str() << std::endl; + abort(); + } + } + else if( method->getName().startswith( "PreTraverse" )) + { + TraverseFunctionInfo traverseInfo = findOrCreateTraverseFunctionInfo( method->getName().substr( 3 )); + traverseInfo.hasPre = true; + traverseFunctions.insert( std::move( traverseInfo )); + } + else if( method->getName().startswith( "PostTraverse" )) + { + TraverseFunctionInfo traverseInfo = findOrCreateTraverseFunctionInfo( method->getName().substr( 4 )); + traverseInfo.hasPost = true; + traverseFunctions.insert( std::move( traverseInfo )); + } + else if( method->getName() == "shouldVisitTemplateInstantiations" ) + std::cout << "ShouldVisitTemplateInstantiations:1" << std::endl; + else if (method->getName() == "shouldVisitImplicitCode") + std::cout << "ShouldVisitImplicitCode:1" << std::endl; + else if( method->getName().startswith( "WalkUp" )) + { + std::cerr << "WalkUp function not supported for shared visitor: " << decl->getName().str() + << "::" << method->getName().str() << std::endl; + abort(); + } + } + + for( const auto& traverseFunction : traverseFunctions ) + { + std::cout << "TraverseFunctionStart" << std::endl; + std::cout << "TraverseFunctionName:" << traverseFunction.name << std::endl; + std::cout << "TraverseFunctionArgument:" << traverseFunction.argument << std::endl; + std::cout << "TraverseFunctionHasPre:" << traverseFunction.hasPre << std::endl; + std::cout << "TraverseFunctionHasPost:" << traverseFunction.hasPost << std::endl; + std::cout << "TraverseFunctionEnd" << std::endl; + } + + std::cout << "InfoEnd" << std::endl; + foundSomething = true; + return true; +} + +class FindNamedClassConsumer + : public ASTConsumer +{ +public: + void Initialize(ASTContext& context) override + { + visitor.setContext(context); + } + virtual void HandleTranslationUnit(ASTContext& context) override + { + visitor.TraverseDecl( context.getTranslationUnitDecl()); + } +private: + CheckFileVisitor visitor; +}; + +class FindNamedClassAction + : public ASTFrontendAction + { +public: + virtual std::unique_ptr<ASTConsumer> CreateASTConsumer( CompilerInstance&, StringRef ) override + { + return std::unique_ptr<ASTConsumer>( new FindNamedClassConsumer ); + } +}; + + +std::string readSourceFile( const char* filename ) +{ + std::string contents; + std::ifstream stream( filename ); + if( !stream ) + { + std::cerr << "Failed to open: " << filename << std::endl; + exit( 1 ); + } + std::string line; + bool hasIfdef = false; + while( getline( stream, line )) + { + // TODO add checks that it's e.g. not "#ifdef" ? + if( line.find( "#ifndef LO_CLANG_SHARED_PLUGINS" ) == 0 ) + hasIfdef = true; + contents += line; + contents += '\n'; + } + if( stream.eof() && hasIfdef ) + return contents; + return ""; +} + +int main(int argc, char** argv) +{ + std::vector< std::string > args; + int i = 1; + for( ; i < argc; ++ i ) + { + constexpr std::size_t prefixlen = 5; // strlen("-arg="); + if (std::strncmp(argv[i], "-arg=", prefixlen) != 0) + { + break; + } + args.push_back(argv[i] + prefixlen); + } + SmallVector< StringRef, 20 > clangflags; + SplitString( CLANGFLAGS, clangflags ); + for (auto const & i: clangflags) { + args.push_back(i.str()); + } + args.insert( + args.end(), + { // These must match LO_CLANG_ANALYZER_PCH_CXXFLAGS in Makefile-clang.mk . + "-I" BUILDDIR "/config_host" // plugin sources use e.g. config_global.h +#if LO_CLANG_USE_ANALYZER_PCH + , + "-include-pch", // use PCH with Clang headers to speed up parsing/analysing + BUILDDIR "/compilerplugins/clang/sharedvisitor/clang.pch" +#endif + }); + for( ; i < argc; ++ i ) + { + std::string contents = readSourceFile(argv[i]); + if( contents.empty()) + continue; + foundSomething = false; + if( !tooling::runToolOnCodeWithArgs( std::unique_ptr<FindNamedClassAction>(new FindNamedClassAction), contents, args, argv[ i ] )) + { + std::cerr << "Failed to analyze: " << argv[ i ] << std::endl; + return 2; + } + if( !foundSomething ) + { + // there's #ifndef LO_CLANG_SHARED_PLUGINS in the source, but no class matched + std::cerr << "Failed to find code: " << argv[ i ] << std::endl; + return 2; + } + } + return 0; +} diff --git a/compilerplugins/clang/sharedvisitor/dummyplugin.hxx b/compilerplugins/clang/sharedvisitor/dummyplugin.hxx new file mode 100644 index 000000000..1ef87416a --- /dev/null +++ b/compilerplugins/clang/sharedvisitor/dummyplugin.hxx @@ -0,0 +1,81 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * Based on LLVM/Clang. + * + * This file is distributed under the University of Illinois Open Source + * License. See LICENSE.TXT for details. + * + */ + +#pragma once + +#include "config_clang.h" + +#include "../plugin.hxx" + +using namespace clang; +using namespace llvm; + +namespace loplugin +{ + +// These classes are used as base classes when building with LO_CLANG_SHARED_PLUGINS. +// Since plugin classes in that case should use just one shared RecursiveASTVisitor, +// sharedvisitor/generator.cxx will make these to be the base classes used, so that +// compiling the code doesn't spend a several minutes optimizing instances +// of RecursiveASTVisitor that will never get used. + +template<typename T> +class DummyRecursiveASTVisitor +{ +public: + // These need to be reimplemented, because plugins contain calls to them, + // but they should actually never get called in the shared-visitor mode. + // This could be autogenerated too, but it's probably simpler to just extend + // manually as needed. + bool TraverseDecl( Decl* ) { return complain(); } + bool TraverseLinkageSpecDecl( LinkageSpecDecl* ) { return complain(); } + bool TraverseStmt( Stmt* ) { return complain(); } + bool TraverseIfStmt( IfStmt* ) { return complain(); } + bool TraverseWhileStmt( WhileStmt* ) { return complain(); } + bool TraverseDoStmt( DoStmt* ) { return complain(); } + bool TraverseForStmt( ForStmt* ) { return complain(); } + bool TraverseCompoundStmt( CompoundStmt* ) { return complain(); } + bool TraverseCXXForRangeStmt( CXXForRangeStmt* ) { return complain(); } + bool TraverseConditionalOperator( ConditionalOperator* ) { return complain(); } + bool TraverseCXXCatchStmt( CXXCatchStmt* ) { return complain(); } + bool TraverseCXXDestructorDecl( CXXDestructorDecl* ) { return complain(); } + bool TraverseFunctionDecl( FunctionDecl* ) { return complain(); } + bool TraverseSwitchStmt( SwitchStmt* ) { return complain(); } + bool TraverseImplicitCastExpr( ImplicitCastExpr* ) { return complain(); } + bool TraverseCStyleCastExpr( CStyleCastExpr* ) { return complain(); } + bool TraverseCXXStaticCastExpr( CXXStaticCastExpr* ) { return complain(); } + bool TraverseCXXFunctionalCastExpr( CXXFunctionalCastExpr* ) { return complain(); } + bool TraverseFriendDecl( FriendDecl* ) { return complain(); } + bool TraverseTypeLoc( TypeLoc ) { return complain(); } + bool TraverseAlignedAttr( AlignedAttr* ) { return complain(); } + bool TraverseVarDecl( VarDecl* ) { return complain(); } + bool TraverseUnaryExprOrTypeTraitExpr( UnaryExprOrTypeTraitExpr* ) { return complain(); } +private: + bool complain() { assert(false && "should not be calling this in sharedplugin mode"); abort(); return false; } +}; + +template<typename Derived> +class DummyFilteringPlugin : public DummyRecursiveASTVisitor<Derived>, public Plugin +{ +public: + explicit DummyFilteringPlugin( const InstantiationData& data ) : Plugin(data) {} +}; + +template<typename Derived> +class DummyFilteringRewritePlugin : public DummyRecursiveASTVisitor<Derived>, public RewritePlugin +{ +public: + explicit DummyFilteringRewritePlugin( const InstantiationData& data ) : RewritePlugin(data) {} +}; + +} // namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/compilerplugins/clang/sharedvisitor/generator.cxx b/compilerplugins/clang/sharedvisitor/generator.cxx new file mode 100644 index 000000000..ca5d2743c --- /dev/null +++ b/compilerplugins/clang/sharedvisitor/generator.cxx @@ -0,0 +1,480 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ + +#include <algorithm> +#include <cassert> +#include <cstddef> +#include <cstring> +#include <iostream> +#include <fstream> +#include <memory> +#include <set> +#include <vector> + +// Info about a Visit* function in a plugin. +struct VisitFunctionInfo +{ + std::string name; + std::string argument; +}; + + +// Info about a Traverse* function in a plugin. +struct TraverseFunctionInfo +{ + std::string name; + std::string argument; + bool hasPre = false; + bool hasPost = false; +}; + +struct VisitFunctionInfoLess +{ + bool operator()( const VisitFunctionInfo& l, const VisitFunctionInfo& r ) const + { + return l.name < r.name; + } +}; + +struct TraverseFunctionInfoLess +{ + bool operator()( const TraverseFunctionInfo& l, const TraverseFunctionInfo& r ) const + { + return l.name < r.name; + } +}; + + +// Information about each LO plugin. +struct PluginInfo +{ + std::string className; // e.g. "BadStatics" + std::string variableName; // e.g. "badStatics" + std::string lowercaseName; + bool shouldVisitTemplateInstantiations; + bool shouldVisitImplicitCode; + std::set< VisitFunctionInfo, VisitFunctionInfoLess > visitFunctions; + std::set< TraverseFunctionInfo, TraverseFunctionInfoLess > traverseFunctions; +}; + +// We need separate visitors for shouldVisitTemplateInstantiations and shouldVisitImplicitCode, +// so split plugins into groups by what they should visit. +// It seems that trying to handle the shouldVisit* functionality with just one visitor +// is tricky. +enum PluginType +{ + PluginBasic, + PluginVisitTemplates, + PluginVisitImplicit, + PluginVisitTemplatesImplicit, +}; + +const int Plugin_Begin = PluginBasic; +const int Plugin_End = PluginVisitTemplatesImplicit + 1; +static const char* const pluginTypeNames[ Plugin_End ] + = { "Basic", "VisitTemplates", "VisitImplicit", "VisitTemplatesImplicit" }; + +static std::vector< PluginInfo > plugins[ Plugin_End ]; + + +void generateVisitor( PluginType type ); + +void generate() +{ + std::ostream& output = std::cout; + output << +"// This file is autogenerated. Do not modify.\n" +"// Generated by compilerplugins/clang/sharedvisitor/generator.cxx .\n" +"\n" +"#ifdef LO_CLANG_SHARED_PLUGINS\n" +"\n" +"#include <config_clang.h>\n" +"\n" +"#include <clang/AST/ASTContext.h>\n" +"#include <clang/AST/RecursiveASTVisitor.h>\n" +"\n" +"#include \"plugin.hxx\"\n" +"#include \"sharedvisitor/dummyplugin.hxx\"\n" +"\n"; + + output << "#undef LO_CLANG_SHARED_PLUGINS // to get sources of individual plugins\n"; + output << "// make use of the dummy base classes\n"; + output << "#define RecursiveASTVisitor DummyRecursiveASTVisitor\n"; + output << "#define FilteringPlugin DummyFilteringPlugin\n"; + output << "#define FilteringRewritePlugin DummyFilteringRewritePlugin\n"; + output << "\n"; + for( const auto& pluginGroup : plugins ) + for( const PluginInfo& plugin : pluginGroup ) + output << "#include \"" << plugin.lowercaseName << ".cxx\"" << std::endl; + output << "\n"; + output << "#undef RecursiveASTVisitor\n"; + output << "#undef FilteringPlugin\n"; + output << "#undef FilteringRewritePlugin\n"; + + output << +"\n" +"using namespace clang;\n" +"using namespace llvm;\n" +"\n" +"namespace loplugin\n" +"{\n"; + + for( int type = Plugin_Begin; type < Plugin_End; ++type ) + generateVisitor( static_cast< PluginType >( type )); + + output << +"} // namespace loplugin\n" +"\n" +"#endif // LO_CLANG_SHARED_PLUGINS\n"; +} + +void generateVisitor( PluginType type ) +{ + if( plugins[ type ].empty()) + return; + std::ostream& output = std::cout; + output << +"\n" +"class SharedRecursiveASTVisitor" << pluginTypeNames[ type ] << "\n" +" : public FilteringPlugin< SharedRecursiveASTVisitor" << pluginTypeNames[ type ] << ">\n" +"{\n" +"public:\n" +" explicit SharedRecursiveASTVisitor" << pluginTypeNames[ type ] << "(const InstantiationData& rData)\n" +" : FilteringPlugin(rData)\n"; + for( const PluginInfo& plugin : plugins[ type ] ) + output << " , " << plugin.variableName << "( nullptr )\n"; + output << " , activeRefCount( 0 )\n"; + output << " {}\n"; + + output << +" ~SharedRecursiveASTVisitor" << pluginTypeNames[ type ] << "()\n" +" {\n" +" if( activeRefCount != 0 )\n" +" abort();\n" +" }\n"; + + output << +" virtual bool preRun() override\n" +" {\n"; + for( const PluginInfo& plugin : plugins[ type ] ) + { + output << " if( " << plugin.variableName << " && !" << plugin.variableName << "->preRun())\n"; + // This will disable the plugin for the rest of the run. + output << " " << plugin.variableName << " = nullptr;\n"; + } + output << +" return anyPluginActive();\n" +" }\n"; + + output << +" virtual void postRun() override\n" +" {\n"; + for( const PluginInfo& plugin : plugins[ type ] ) + { + output << " if( " << plugin.variableName << " )\n"; + output << " " << plugin.variableName << "->postRun();\n"; + } + output << +" }\n"; + + output << +" virtual void run() override {\n" +" if (preRun()) {\n" +" TraverseDecl(compiler.getASTContext().getTranslationUnitDecl());\n" +" postRun();\n" +" }\n" +" }\n" +" enum { isSharedPlugin = true };\n"; + + output << +" virtual bool setSharedPlugin( Plugin* plugin, const char* name ) override\n" +" {\n"; + bool first = true; + for( const PluginInfo& plugin : plugins[ type ] ) + { + output << " "; + if( !first ) + output << "else "; + first = false; + output << "if( strcmp( name, \"" << plugin.lowercaseName << "\" ) == 0 )\n"; + output << " " << plugin.variableName << " = static_cast< " << plugin.className << "* >( plugin );\n"; + } + output << +" else\n" +" return false;\n" +" return true;\n" +" }\n"; + + if( type == PluginVisitTemplates || type == PluginVisitTemplatesImplicit ) + output << "bool shouldVisitTemplateInstantiations() const { return true; }\n"; + if( type == PluginVisitImplicit || type == PluginVisitTemplatesImplicit ) + output << "bool shouldVisitImplicitCode() const { return true; }\n"; + + std::set< VisitFunctionInfo, VisitFunctionInfoLess > visitFunctions; + for( const PluginInfo& plugin : plugins[ type ] ) + for( const VisitFunctionInfo& visit : plugin.visitFunctions ) + visitFunctions.insert( visit ); + for( const VisitFunctionInfo& visit : visitFunctions ) + { + output << " bool " << visit.name << "(" << visit.argument << " arg)\n"; + output << +" {\n" +" if( ignoreLocation( arg ))\n" +" return true;\n"; + for( const PluginInfo& plugin : plugins[ type ] ) + { + if( plugin.visitFunctions.find( visit ) == plugin.visitFunctions.end()) + continue; + output << " if( " << plugin.variableName << " != nullptr "; + output << ")\n"; + output << " {\n"; + output << " if( !" << plugin.variableName << "->" << visit.name << "( arg ))\n"; + // This will disable the plugin for the rest of the run (as would returning false + // from Visit* normally do in the non-shared case). + output << " " << plugin.variableName << " = nullptr;\n"; + output << " }\n"; + } + output << +" return anyPluginActive();\n" +" }\n"; + } + + std::set< TraverseFunctionInfo, TraverseFunctionInfoLess > traverseFunctions; + for( const PluginInfo& plugin : plugins[ type ] ) + for( const TraverseFunctionInfo& traverse : plugin.traverseFunctions ) + traverseFunctions.insert( traverse ); + for( const TraverseFunctionInfo& traverse : traverseFunctions ) + { + output << " bool " << traverse.name << "(" << traverse.argument << " arg)\n"; + output << " {\n"; + for( const PluginInfo& plugin : plugins[ type ] ) + { + auto pluginTraverse = plugin.traverseFunctions.find( traverse ); + if( pluginTraverse == plugin.traverseFunctions.end()) + continue; + output << " " << plugin.className << "* save" << plugin.className << " = " << plugin.variableName << ";\n"; + if( pluginTraverse->hasPre ) + { + output << " if( " << plugin.variableName << " != nullptr "; + output << ")\n"; + output << " {\n"; + output << " if( !" << plugin.variableName << "->Pre" << traverse.name << "( arg ))\n"; + // This will disable the plugin for the time of the traverse, until restored later, + // just like directly returning from Traverse* would skip that part. + output << " {\n"; + output << " " << plugin.variableName << " = nullptr;\n"; + output << " ++activeRefCount;\n"; + output << " }\n"; + output << " }\n"; + } + } + output << " bool ret = RecursiveASTVisitor::" << traverse.name << "( arg );\n"; + for( const PluginInfo& plugin : plugins[ type ] ) + { + auto pluginTraverse = plugin.traverseFunctions.find( traverse ); + if( pluginTraverse == plugin.traverseFunctions.end()) + continue; + if( pluginTraverse->hasPost ) + { + output << " if( " << plugin.variableName << " != nullptr "; + output << ")\n"; + output << " {\n"; + output << " if( !" << plugin.variableName << "->Post" << traverse.name << "( arg, ret ))\n"; + // This will disable the plugin for the rest of the run. + output << " save" << plugin.className << " = nullptr;\n"; + output << " }\n"; + } + output << " if( " << plugin.variableName << " == nullptr && save" << plugin.className << " != nullptr )\n"; + output << " --activeRefCount;\n"; + output << " " << plugin.variableName << " = save" << plugin.className << ";\n"; + } + output << " if( false ) // silence -Wunused-function warnings\n"; + output << " {\n"; + for( const PluginInfo& plugin : plugins[ type ] ) + { + auto pluginTraverse = plugin.traverseFunctions.find( traverse ); + if( pluginTraverse == plugin.traverseFunctions.end()) + continue; + output << " " << plugin.variableName << "->" << pluginTraverse->name << "( arg );\n"; + } + output << " }\n"; + output << " return ret;\n"; + output << " }\n"; + } + + output << +"private:\n"; + + output << +" bool anyPluginActive() const\n" +" {\n" +" return activeRefCount > 0"; + for( const PluginInfo& plugin : plugins[ type ] ) + output << "\n || " << plugin.variableName << " != nullptr"; + output << ";\n"; + output << " }\n"; + + for( const PluginInfo& plugin : plugins[ type ] ) + output << " " << plugin.className << "* " << plugin.variableName << ";\n"; + output << " int activeRefCount;\n"; + + output << +"};\n" +"\n" +"loplugin::Plugin::Registration< SharedRecursiveASTVisitor" << pluginTypeNames[ type ] + << " > registration" << pluginTypeNames[ type ] << "(\"sharedvisitor" << pluginTypeNames[ type ] << "\");\n" +"\n"; +} + +static std::string getValue( const std::string& line, const char* tag ) +{ + size_t taglen = strlen( tag ); + if( line.size() < taglen + 2 ) + return std::string(); + if( line.compare( 0, taglen, tag ) != 0 ) + return std::string(); + if( line[ taglen ] != ':' ) + return std::string(); + return line.substr( taglen + 1 ); +} + +static bool readFile( const std::string& fileName ) +{ + std::ifstream file( fileName ); + if( !file ) + { + std::cerr << "Cannot open file " << fileName << std::endl; + return false; + } + PluginInfo pluginInfo; + std::string line; + do + { + getline( file, line ); + } while( !line.empty() && line[ 0 ] == '#' ); + std::string version = getValue( line, "InfoVersion" ); + if( version != "1" ) + { + std::cerr << "Incorrect version '" << version << "' in " << fileName << std::endl; + return false; + } + getline( file, line ); + pluginInfo.className = getValue( line, "ClassName" ); + pluginInfo.variableName = pluginInfo.className; + assert( pluginInfo.variableName.size() > 0 ); + pluginInfo.variableName[ 0 ] = tolower( pluginInfo.variableName[ 0 ] ); + pluginInfo.lowercaseName = pluginInfo.className; + for( char& c : pluginInfo.lowercaseName ) + c = tolower( c ); + pluginInfo.shouldVisitTemplateInstantiations = false; + pluginInfo.shouldVisitImplicitCode = false; + bool endOk = false; + for(;;) + { + std::string line; + getline( file, line ); + if( file.eof() || !file ) + { + std::cerr << "Unexpected end of file" << std::endl; + return false; + } + if( line.empty()) + continue; + if( line == "InfoEnd" ) + { + endOk = true; + break; + } + else if( line == "VisitFunctionStart" ) + { + VisitFunctionInfo visitInfo; + getline( file, line ); + visitInfo.name = getValue( line, "VisitFunctionName" ); + getline( file, line ); + visitInfo.argument = getValue( line, "VisitFunctionArgument" ); + getline( file, line ); + if( line != "VisitFunctionEnd" ) + { + std::cerr << "Missing VisitFunctionEnd" << std::endl; + return false; + } + pluginInfo.visitFunctions.insert( std::move( visitInfo )); + } + else if( line == "TraverseFunctionStart" ) + { + TraverseFunctionInfo traverseInfo; + getline( file, line ); + traverseInfo.name = getValue( line, "TraverseFunctionName" ); + getline( file, line ); + traverseInfo.argument = getValue( line, "TraverseFunctionArgument" ); + getline( file, line ); + traverseInfo.hasPre = getValue( line, "TraverseFunctionHasPre" ) == "1"; + getline( file, line ); + traverseInfo.hasPost = getValue( line, "TraverseFunctionHasPost" ) == "1"; + getline( file, line ); + if( line != "TraverseFunctionEnd" ) + { + std::cerr << "Missing TraverseFunctionEnd" << std::endl; + return false; + } + pluginInfo.traverseFunctions.insert( std::move( traverseInfo )); + } + else + { + std::string value; + value = getValue( line, "ShouldVisitTemplateInstantiations" ); + if( value == "1" ) + pluginInfo.shouldVisitTemplateInstantiations = true; + else + { + value = getValue( line, "ShouldVisitImplicitCode" ); + if( value == "1" ) + pluginInfo.shouldVisitImplicitCode = true; + else + { + std::cerr << "Unknown line " << line << std::endl; + return false; + } + } + } + } + + assert( endOk ); + (void)endOk; + + if( pluginInfo.shouldVisitTemplateInstantiations && pluginInfo.shouldVisitImplicitCode ) + plugins[ PluginVisitTemplatesImplicit ].push_back( std::move( pluginInfo )); + else if( pluginInfo.shouldVisitTemplateInstantiations ) + plugins[ PluginVisitTemplates ].push_back( std::move( pluginInfo )); + else if( pluginInfo.shouldVisitImplicitCode ) + plugins[ PluginVisitImplicit ].push_back( std::move( pluginInfo )); + else + plugins[ PluginBasic ].push_back( std::move( pluginInfo )); + + return true; +} + +int main(int argc, char** argv) +{ + for( int i = 1 ; i < argc; ++i ) + { + if( !readFile( argv[ i ] )) + { + std::cerr << "Error reading " << argv[ i ] << std::endl; + return 1; + } + } + for( int type = Plugin_Begin; type < Plugin_End; ++type ) + { + sort( plugins[ static_cast< PluginType >( type ) ].begin(), plugins[ static_cast< PluginType >( type ) ].end(), + []( const PluginInfo& l, const PluginInfo& r ) { return l.className < r.className; } ); + } + generate(); + return 0; +} diff --git a/compilerplugins/clang/sharedvisitor/precompiled_clang.hxx b/compilerplugins/clang/sharedvisitor/precompiled_clang.hxx new file mode 100644 index 000000000..3baf4b04f --- /dev/null +++ b/compilerplugins/clang/sharedvisitor/precompiled_clang.hxx @@ -0,0 +1,12 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ + +// Used by the analyzer to speed up processing plugin sources. + +#include "../plugin.hxx" |