bool WebCLValidatorAction::initialize(clang::CompilerInstance &instance)
{
if (!WebCLAction::initialize(instance))
return false;
rewriter_ = new clang::Rewriter(
instance.getSourceManager(), instance.getLangOpts());
if (!rewriter_) {
reporter_->fatal("Internal error. Can't create rewriter.\n");
return false;
}
transformer_ = new WebCLTransformer(instance, *rewriter_);
if (!transformer_) {
reporter_->fatal("Internal error. Can't create AST transformer.\n");
return false;
}
// Consumer must be allocated dynamically. The framework deletes
// it.
consumer_ = new WebCLConsumer(instance, *rewriter_, *transformer_);
if (!consumer_) {
reporter_->fatal("Internal error. Can't create AST consumer.\n");
return false;
}
sema_ = new clang::Sema(
instance.getPreprocessor(), instance.getASTContext(), *consumer_);
if (!sema_) {
reporter_->fatal("Internal error. Can't create semantic actions.\n");
return false;
}
return true;
}
int TypeUtils::sizeOfPointer(const clang::CompilerInstance &ci, clang::QualType qt)
{
if (!qt.getTypePtrOrNull())
return -1;
// HACK: What's a better way of getting the size of a pointer ?
auto &astContext = ci.getASTContext();
return astContext.getTypeSize(astContext.getPointerType(qt));
}
std::unique_ptr<clang::ASTConsumer>
ClangTidyASTConsumerFactory::CreateASTConsumer(
clang::CompilerInstance &Compiler, StringRef File) {
// FIXME: Move this to a separate method, so that CreateASTConsumer doesn't
// modify Compiler.
Context.setSourceManager(&Compiler.getSourceManager());
Context.setCurrentFile(File);
Context.setASTContext(&Compiler.getASTContext());
std::vector<std::unique_ptr<ClangTidyCheck>> Checks;
CheckFactories->createChecks(&Context, Checks);
ast_matchers::MatchFinder::MatchFinderOptions FinderOptions;
if (auto *P = Context.getCheckProfileData())
FinderOptions.CheckProfiling.emplace(P->Records);
std::unique_ptr<ast_matchers::MatchFinder> Finder(
new ast_matchers::MatchFinder(std::move(FinderOptions)));
for (auto &Check : Checks) {
Check->registerMatchers(&*Finder);
Check->registerPPCallbacks(Compiler);
}
std::vector<std::unique_ptr<ASTConsumer>> Consumers;
if (!Checks.empty())
Consumers.push_back(Finder->newASTConsumer());
AnalyzerOptionsRef AnalyzerOptions = Compiler.getAnalyzerOpts();
// FIXME: Remove this option once clang's cfg-temporary-dtors option defaults
// to true.
AnalyzerOptions->Config["cfg-temporary-dtors"] =
Context.getOptions().AnalyzeTemporaryDtors ? "true" : "false";
GlobList &Filter = Context.getChecksFilter();
AnalyzerOptions->CheckersControlList = getCheckersControlList(Filter);
if (!AnalyzerOptions->CheckersControlList.empty()) {
setStaticAnalyzerCheckerOpts(Context.getOptions(), AnalyzerOptions);
AnalyzerOptions->AnalysisStoreOpt = RegionStoreModel;
AnalyzerOptions->AnalysisDiagOpt = PD_NONE;
AnalyzerOptions->AnalyzeNestedBlocks = true;
AnalyzerOptions->eagerlyAssumeBinOpBifurcation = true;
std::unique_ptr<ento::AnalysisASTConsumer> AnalysisConsumer =
ento::CreateAnalysisConsumer(Compiler);
AnalysisConsumer->AddDiagnosticConsumer(
new AnalyzerDiagnosticConsumer(Context));
Consumers.push_back(std::move(AnalysisConsumer));
}
return llvm::make_unique<ClangTidyASTConsumer>(
std::move(Consumers), std::move(Finder), std::move(Checks));
}
bool parseAST(const char* szSourceCodeFilePath, clang::ast_matchers::MatchFinder finder)
{
// create the compiler instance setup for this file as main file
prepareCompilerforFile(szSourceCodeFilePath);
std::unique_ptr<clang::ASTConsumer> pAstConsumer (finder.newASTConsumer());
clang::DiagnosticConsumer& diagConsumer = m_CompilerInstance.getDiagnosticClient();
diagConsumer.BeginSourceFile(m_CompilerInstance.getLangOpts(), &m_CompilerInstance.getPreprocessor());
clang::ParseAST(m_CompilerInstance.getPreprocessor(), pAstConsumer.get(), m_CompilerInstance.getASTContext());
diagConsumer.EndSourceFile();
return diagConsumer.getNumErrors() != 0;
}
virtual std::unique_ptr<clang::ASTConsumer> CreateASTConsumer(
clang::CompilerInstance &Compiler, llvm::StringRef InFile)
{
return std::unique_ptr<clang::ASTConsumer>(
new FindNamedClassConsumer(&Compiler.getASTContext()));
}
virtual std::unique_ptr<clang::ASTConsumer> CreateASTConsumer(
clang::CompilerInstance &Compiler, llvm::StringRef InFile)
{
return std::unique_ptr<clang::ASTConsumer>(new fxc::Driver(Compiler.getASTContext(), Compiler.getDiagnostics()));
}
std::unique_ptr< clang::ASTConsumer > CreateASTConsumer(clang::CompilerInstance & compiler, llvm::StringRef inFile )
{
return std::unique_ptr< clang::ASTConsumer >( new MetricsCalculatorASTConsumer( &compiler.getASTContext() ) );
}
bool QtUtils::isTooBigForQList(clang::QualType qt, const clang::CompilerInstance &ci)
{
return (int)ci.getASTContext().getTypeSize(qt) <= TypeUtils::sizeOfPointer(ci, qt);
}
clang::ASTContext& GetASTContext() { return m_CompilerInstance.getASTContext(); }
