Revert some of the visitors in codegen to test the performance impact

Author: Sirraide

clang/lib/CodeGen/CGDebugInfo.cpp

@@ -25,9 +25,9 @@
 #include "clang/AST/DeclFriend.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/DeclTemplate.h"
-#include "clang/AST/DynamicRecursiveASTVisitor.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/RecordLayout.h"
+#include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/AST/VTableBuilder.h"
 #include "clang/Basic/CodeGenOptions.h"
 #include "clang/Basic/SourceManager.h"
@@ -5697,9 +5697,10 @@ static bool ReferencesAnonymousEntity(ArrayRef<TemplateArgument> Args) {
     case TemplateArgument::Pack:
       return ReferencesAnonymousEntity(TA.getPackAsArray());
     case TemplateArgument::Type: {
-      struct ReferencesAnonymous : DynamicRecursiveASTVisitor {
+      struct ReferencesAnonymous
+          : public RecursiveASTVisitor<ReferencesAnonymous> {
         bool RefAnon = false;
-        bool VisitRecordType(RecordType *RT) override {
+        bool VisitRecordType(RecordType *RT) {
           if (ReferencesAnonymousEntity(RT)) {
             RefAnon = true;
             return false;
@@ -5720,17 +5721,17 @@ static bool ReferencesAnonymousEntity(ArrayRef<TemplateArgument> Args) {
   });
 }
 namespace {
-struct ReconstitutableType : DynamicRecursiveASTVisitor {
+struct ReconstitutableType : public RecursiveASTVisitor<ReconstitutableType> {
   bool Reconstitutable = true;
-  bool VisitVectorType(VectorType *FT) override {
+  bool VisitVectorType(VectorType *FT) {
     Reconstitutable = false;
     return false;
   }
-  bool VisitAtomicType(AtomicType *FT) override {
+  bool VisitAtomicType(AtomicType *FT) {
     Reconstitutable = false;
     return false;
   }
-  bool VisitType(Type *T) override {
+  bool VisitType(Type *T) {
     // _BitInt(N) isn't reconstitutable because the bit width isn't encoded in
     // the DWARF, only the byte width.
     if (T->isBitIntType()) {
@@ -5739,7 +5740,7 @@ struct ReconstitutableType : DynamicRecursiveASTVisitor {
     }
     return true;
   }
-  bool TraverseEnumType(EnumType *ET, bool = false) override {
+  bool TraverseEnumType(EnumType *ET, bool = false) {
     // Unnamed enums can't be reconstituted due to a lack of column info we
     // produce in the DWARF, so we can't get Clang's full name back.
     if (const auto *ED = dyn_cast<EnumDecl>(ET->getOriginalDecl())) {
@@ -5754,13 +5755,13 @@ struct ReconstitutableType : DynamicRecursiveASTVisitor {
     }
     return true;
   }
-  bool VisitFunctionProtoType(FunctionProtoType *FT) override {
+  bool VisitFunctionProtoType(FunctionProtoType *FT) {
     // noexcept is not encoded in DWARF, so the reversi
     Reconstitutable &= !isNoexceptExceptionSpec(FT->getExceptionSpecType());
     Reconstitutable &= !FT->getNoReturnAttr();
     return Reconstitutable;
   }
-  bool VisitRecordType(RecordType *RT) override {
+  bool VisitRecordType(RecordType *RT, bool = false) {
     if (ReferencesAnonymousEntity(RT)) {
       Reconstitutable = false;
       return false;

clang/lib/CodeGen/CodeGenModule.cpp

@@ -34,8 +34,8 @@
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/DeclTemplate.h"
-#include "clang/AST/DynamicRecursiveASTVisitor.h"
 #include "clang/AST/Mangle.h"
+#include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/AST/StmtVisitor.h"
 #include "clang/Basic/Builtins.h"
 #include "clang/Basic/CodeGenOptions.h"
@@ -4266,12 +4266,13 @@ namespace {
   };
 
   // Make sure we're not referencing non-imported vars or functions.
-  struct DLLImportFunctionVisitor : DynamicRecursiveASTVisitor {
+  struct DLLImportFunctionVisitor
+      : public RecursiveASTVisitor<DLLImportFunctionVisitor> {
     bool SafeToInline = true;
 
-    DLLImportFunctionVisitor() { ShouldVisitImplicitCode = true; }
+    bool shouldVisitImplicitCode() const { return true; }
 
-    bool VisitVarDecl(VarDecl *VD) override {
+    bool VisitVarDecl(VarDecl *VD) {
       if (VD->getTLSKind()) {
         // A thread-local variable cannot be imported.
         SafeToInline = false;
@@ -4285,13 +4286,13 @@ namespace {
       return SafeToInline;
     }
 
-    bool VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) override {
+    bool VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
       if (const auto *D = E->getTemporary()->getDestructor())
         SafeToInline = D->hasAttr<DLLImportAttr>();
       return SafeToInline;
     }
 
-    bool VisitDeclRefExpr(DeclRefExpr *E) override {
+    bool VisitDeclRefExpr(DeclRefExpr *E) {
       ValueDecl *VD = E->getDecl();
       if (isa<FunctionDecl>(VD))
         SafeToInline = VD->hasAttr<DLLImportAttr>();
@@ -4300,12 +4301,12 @@ namespace {
       return SafeToInline;
     }
 
-    bool VisitCXXConstructExpr(CXXConstructExpr *E) override {
+    bool VisitCXXConstructExpr(CXXConstructExpr *E) {
       SafeToInline = E->getConstructor()->hasAttr<DLLImportAttr>();
       return SafeToInline;
     }
 
-    bool VisitCXXMemberCallExpr(CXXMemberCallExpr *E) override {
+    bool VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
       CXXMethodDecl *M = E->getMethodDecl();
       if (!M) {
         // Call through a pointer to member function. This is safe to inline.
@@ -4316,12 +4317,12 @@ namespace {
       return SafeToInline;
     }
 
-    bool VisitCXXDeleteExpr(CXXDeleteExpr *E) override {
+    bool VisitCXXDeleteExpr(CXXDeleteExpr *E) {
       SafeToInline = E->getOperatorDelete()->hasAttr<DLLImportAttr>();
       return SafeToInline;
     }
 
-    bool VisitCXXNewExpr(CXXNewExpr *E) override {
+    bool VisitCXXNewExpr(CXXNewExpr *E) {
       SafeToInline = E->getOperatorNew()->hasAttr<DLLImportAttr>();
       return SafeToInline;
     }

clang/lib/CodeGen/ObjectFilePCHContainerWriter.cpp

@@ -11,8 +11,8 @@
 #include "CodeGenModule.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/DeclObjC.h"
-#include "clang/AST/DynamicRecursiveASTVisitor.h"
 #include "clang/AST/Expr.h"
+#include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/Basic/CodeGenOptions.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/TargetInfo.h"
@@ -56,7 +56,7 @@ class PCHContainerGenerator : public ASTConsumer {
   std::shared_ptr<PCHBuffer> Buffer;
 
   /// Visit every type and emit debug info for it.
-  struct DebugTypeVisitor : DynamicRecursiveASTVisitor {
+  struct DebugTypeVisitor : public RecursiveASTVisitor<DebugTypeVisitor> {
     clang::CodeGen::CGDebugInfo &DI;
     ASTContext &Ctx;
     DebugTypeVisitor(clang::CodeGen::CGDebugInfo &DI, ASTContext &Ctx)
@@ -67,13 +67,13 @@ class PCHContainerGenerator : public ASTConsumer {
       return !Ty->isDependentType() && !Ty->isUndeducedType();
     }
 
-    bool VisitImportDecl(ImportDecl *D) override {
+    bool VisitImportDecl(ImportDecl *D) {
       if (!D->getImportedOwningModule())
         DI.EmitImportDecl(*D);
       return true;
     }
 
-    bool VisitTypeDecl(TypeDecl *D) override {
+    bool VisitTypeDecl(TypeDecl *D) {
       // TagDecls may be deferred until after all decls have been merged and we
       // know the complete type. Pure forward declarations will be skipped, but
       // they don't need to be emitted into the module anyway.
@@ -90,14 +90,14 @@ class PCHContainerGenerator : public ASTConsumer {
       return true;
     }
 
-    bool VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) override {
+    bool VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) {
       QualType QualTy(D->getTypeForDecl(), 0);
       if (!QualTy.isNull() && CanRepresent(QualTy.getTypePtr()))
         DI.getOrCreateStandaloneType(QualTy, D->getLocation());
       return true;
     }
 
-    bool VisitFunctionDecl(FunctionDecl *D) override {
+    bool VisitFunctionDecl(FunctionDecl *D) {
       // Skip deduction guides.
       if (isa<CXXDeductionGuideDecl>(D))
         return true;
@@ -118,7 +118,7 @@ class PCHContainerGenerator : public ASTConsumer {
       return true;
     }
 
-    bool VisitObjCMethodDecl(ObjCMethodDecl *D) override {
+    bool VisitObjCMethodDecl(ObjCMethodDecl *D) {
       if (!D->getClassInterface())
         return true;