b4836ea7a8
Special detail is added for uninitialized variable analysis as this has serious performance problems than need to be tracked. Computing some of this data is expensive, for example walking the CFG to determine its size. To avoid doing that unless the stats data is going to be used, we thread a bit into the Sema object to track whether detailed stats should be collected or not. This bit is used to avoid computations whereever the computations are likely to be more expensive than checking the state of the flag. Thus, counters are in some cases unconditionally updated, but the more expensive (and less frequent) aggregation steps are skipped. With this patch, we're able to see that for 'gcc.c': *** Analysis Based Warnings Stats: 232 functions analyzed (0 w/o CFGs). 7151 CFG blocks built. 30 average CFG blocks per function. 1167 max CFG blocks per function. 163 functions analyzed for uninitialiazed variables 640 variables analyzed. 3 average variables per function. 94 max variables per function. 96409 block visits. 591 average block visits per function. 61546 max block visits per function. And for the reduced testcase in PR10183: *** Analysis Based Warnings Stats: 98 functions analyzed (0 w/o CFGs). 8526 CFG blocks built. 87 average CFG blocks per function. 7277 max CFG blocks per function. 68 functions analyzed for uninitialiazed variables 1359 variables analyzed. 19 average variables per function. 1196 max variables per function. 2540494 block visits. 37360 average block visits per function. 2536495 max block visits per function. That last number is the somewhat scary one that indicates the problem in PR10183. llvm-svn: 134494
113 lines
3.8 KiB
C++
113 lines
3.8 KiB
C++
//===--- ParseAST.cpp - Provide the clang::ParseAST method ----------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file implements the clang::ParseAST method.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "clang/Parse/ParseAST.h"
|
|
#include "clang/Sema/Sema.h"
|
|
#include "clang/Sema/CodeCompleteConsumer.h"
|
|
#include "clang/Sema/SemaConsumer.h"
|
|
#include "clang/Sema/ExternalSemaSource.h"
|
|
#include "clang/AST/ASTConsumer.h"
|
|
#include "clang/AST/DeclCXX.h"
|
|
#include "clang/AST/ExternalASTSource.h"
|
|
#include "clang/AST/Stmt.h"
|
|
#include "clang/Parse/Parser.h"
|
|
#include "llvm/ADT/OwningPtr.h"
|
|
#include "llvm/Support/CrashRecoveryContext.h"
|
|
#include <cstdio>
|
|
|
|
using namespace clang;
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Public interface to the file
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
/// ParseAST - Parse the entire file specified, notifying the ASTConsumer as
|
|
/// the file is parsed. This inserts the parsed decls into the translation unit
|
|
/// held by Ctx.
|
|
///
|
|
void clang::ParseAST(Preprocessor &PP, ASTConsumer *Consumer,
|
|
ASTContext &Ctx, bool PrintStats,
|
|
bool CompleteTranslationUnit,
|
|
CodeCompleteConsumer *CompletionConsumer) {
|
|
|
|
llvm::OwningPtr<Sema> S(new Sema(PP, Ctx, *Consumer,
|
|
CompleteTranslationUnit,
|
|
CompletionConsumer));
|
|
|
|
// Recover resources if we crash before exiting this method.
|
|
llvm::CrashRecoveryContextCleanupRegistrar<Sema> CleaupSema(S.get());
|
|
|
|
ParseAST(*S.get(), PrintStats);
|
|
}
|
|
|
|
void clang::ParseAST(Sema &S, bool PrintStats) {
|
|
// Collect global stats on Decls/Stmts (until we have a module streamer).
|
|
if (PrintStats) {
|
|
Decl::CollectingStats(true);
|
|
Stmt::CollectingStats(true);
|
|
}
|
|
|
|
// Also turn on collection of stats inside of the Sema object.
|
|
bool OldCollectStats = PrintStats;
|
|
std::swap(OldCollectStats, S.CollectStats);
|
|
|
|
ASTConsumer *Consumer = &S.getASTConsumer();
|
|
|
|
llvm::OwningPtr<Parser> ParseOP(new Parser(S.getPreprocessor(), S));
|
|
Parser &P = *ParseOP.get();
|
|
|
|
PrettyStackTraceParserEntry CrashInfo(P);
|
|
|
|
// Recover resources if we crash before exiting this method.
|
|
llvm::CrashRecoveryContextCleanupRegistrar<Parser>
|
|
CleaupParser(ParseOP.get());
|
|
|
|
S.getPreprocessor().EnterMainSourceFile();
|
|
P.Initialize();
|
|
S.Initialize();
|
|
|
|
if (ExternalASTSource *External = S.getASTContext().getExternalSource())
|
|
External->StartTranslationUnit(Consumer);
|
|
|
|
Parser::DeclGroupPtrTy ADecl;
|
|
|
|
while (!P.ParseTopLevelDecl(ADecl)) { // Not end of file.
|
|
// If we got a null return and something *was* parsed, ignore it. This
|
|
// is due to a top-level semicolon, an action override, or a parse error
|
|
// skipping something.
|
|
if (ADecl)
|
|
Consumer->HandleTopLevelDecl(ADecl.get());
|
|
};
|
|
// Check for any pending objective-c implementation decl.
|
|
while ((ADecl = P.FinishPendingObjCActions()))
|
|
Consumer->HandleTopLevelDecl(ADecl.get());
|
|
|
|
// Process any TopLevelDecls generated by #pragma weak.
|
|
for (llvm::SmallVector<Decl*,2>::iterator
|
|
I = S.WeakTopLevelDecls().begin(),
|
|
E = S.WeakTopLevelDecls().end(); I != E; ++I)
|
|
Consumer->HandleTopLevelDecl(DeclGroupRef(*I));
|
|
|
|
Consumer->HandleTranslationUnit(S.getASTContext());
|
|
|
|
std::swap(OldCollectStats, S.CollectStats);
|
|
if (PrintStats) {
|
|
llvm::errs() << "\nSTATISTICS:\n";
|
|
P.getActions().PrintStats();
|
|
S.getASTContext().PrintStats();
|
|
Decl::PrintStats();
|
|
Stmt::PrintStats();
|
|
Consumer->PrintStats();
|
|
}
|
|
}
|