34eb20725d
Summary:
The patch is generated using clang-tidy misc-use-override check.
This command was used:
tools/clang/tools/extra/clang-tidy/tool/run-clang-tidy.py \
-checks='-*,misc-use-override' -header-filter='llvm|clang' -j=32 -fix
Reviewers: dblaikie
Reviewed By: dblaikie
Subscribers: klimek, cfe-commits
Differential Revision: http://reviews.llvm.org/D8926
llvm-svn: 234678
75 lines
2.6 KiB
C++
75 lines
2.6 KiB
C++
//===-- ModelInjector.h -----------------------------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
///
|
|
/// \file
|
|
/// \brief This file defines the clang::ento::ModelInjector class which implements the
|
|
/// clang::CodeInjector interface. This class is responsible for injecting
|
|
/// function definitions that were synthesized from model files.
|
|
///
|
|
/// Model files allow definitions of functions to be lazily constituted for functions
|
|
/// which lack bodies in the original source code. This allows the analyzer
|
|
/// to more precisely analyze code that calls such functions, analyzing the
|
|
/// artificial definitions (which typically approximate the semantics of the
|
|
/// called function) when called by client code. These definitions are
|
|
/// reconstituted lazily, on-demand, by the static analyzer engine.
|
|
///
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_CLANG_SA_FRONTEND_MODELINJECTOR_H
|
|
#define LLVM_CLANG_SA_FRONTEND_MODELINJECTOR_H
|
|
|
|
#include "clang/Analysis/CodeInjector.h"
|
|
#include "llvm/ADT/IntrusiveRefCntPtr.h"
|
|
#include "llvm/ADT/StringMap.h"
|
|
#include <map>
|
|
#include <memory>
|
|
#include <vector>
|
|
|
|
namespace clang {
|
|
|
|
class CompilerInstance;
|
|
class ASTUnit;
|
|
class ASTReader;
|
|
class NamedDecl;
|
|
class Module;
|
|
|
|
namespace ento {
|
|
class ModelInjector : public CodeInjector {
|
|
public:
|
|
ModelInjector(CompilerInstance &CI);
|
|
Stmt *getBody(const FunctionDecl *D) override;
|
|
Stmt *getBody(const ObjCMethodDecl *D) override;
|
|
|
|
private:
|
|
/// \brief Synthesize a body for a declaration
|
|
///
|
|
/// This method first looks up the appropriate model file based on the
|
|
/// model-path configuration option and the name of the declaration that is
|
|
/// looked up. If no model were synthesized yet for a function with that name
|
|
/// it will create a new compiler instance to parse the model file using the
|
|
/// ASTContext, Preprocessor, SourceManager of the original compiler instance.
|
|
/// The former resources are shared between the two compiler instance, so the
|
|
/// newly created instance have to "leak" these objects, since they are owned
|
|
/// by the original instance.
|
|
///
|
|
/// The model-path should be either an absolute path or relative to the
|
|
/// working directory of the compiler.
|
|
void onBodySynthesis(const NamedDecl *D);
|
|
|
|
CompilerInstance &CI;
|
|
|
|
// FIXME: double memoization is redundant, with memoization both here and in
|
|
// BodyFarm.
|
|
llvm::StringMap<Stmt *> Bodies;
|
|
};
|
|
}
|
|
}
|
|
|
|
#endif
|