mirror of
https://github.com/llvm/llvm-project.git
synced 2025-05-10 05:16:08 +00:00
14f779c4d6
their implementations are unavailable. Start by simulating dispatch_sync(). This change is largely a bunch of plumbing around something very simple. We use AnalysisDeclContext to conjure up a fake function body (using the current ASTContext) when one does not exist. This is controlled under the analyzer-config option "faux-bodies", which is off by default. The plumbing in this patch is largely to pass the necessary machinery around. CallEvent needs the AnalysisDeclContextManager to get the function definition, as one may get conjured up lazily. BugReporter and PathDiagnosticLocation needed to be relaxed to handle invalid locations, as the conjured body has no real source locations. We do some primitive recovery in diagnostic generation to generate some reasonable locations (for arrows and events), but it can be improved. llvm-svn: 164339
118 lines
3.8 KiB
C++
118 lines
3.8 KiB
C++
//===-- AnalyzerOptions.cpp - Analysis Engine Options -----------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file contains special accessors for analyzer configuration options
|
|
// with string representations.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "clang/StaticAnalyzer/Core/AnalyzerOptions.h"
|
|
#include "llvm/ADT/StringSwitch.h"
|
|
|
|
using namespace clang;
|
|
using namespace llvm;
|
|
|
|
bool
|
|
AnalyzerOptions::mayInlineCXXMemberFunction(CXXInlineableMemberKind K) const {
|
|
if (IPAMode < Inlining)
|
|
return false;
|
|
|
|
if (!CXXMemberInliningMode) {
|
|
static const char *ModeKey = "c++-inlining";
|
|
std::string ModeStr = Config.lookup(ModeKey);
|
|
|
|
CXXInlineableMemberKind &MutableMode =
|
|
const_cast<CXXInlineableMemberKind &>(CXXMemberInliningMode);
|
|
|
|
MutableMode = llvm::StringSwitch<CXXInlineableMemberKind>(ModeStr)
|
|
.Case("", CIMK_MemberFunctions)
|
|
.Case("constructors", CIMK_Constructors)
|
|
.Case("destructors", CIMK_Destructors)
|
|
.Case("none", CIMK_None)
|
|
.Case("methods", CIMK_MemberFunctions)
|
|
.Default(CXXInlineableMemberKind());
|
|
|
|
if (!MutableMode) {
|
|
// FIXME: We should emit a warning here about an unknown inlining kind,
|
|
// but the AnalyzerOptions doesn't have access to a diagnostic engine.
|
|
MutableMode = CIMK_None;
|
|
}
|
|
}
|
|
|
|
return CXXMemberInliningMode >= K;
|
|
}
|
|
|
|
bool AnalyzerOptions::getBooleanOption(StringRef Name, bool DefaultVal) const {
|
|
// FIXME: We should emit a warning here if the value is something other than
|
|
// "true", "false", or the empty string (meaning the default value),
|
|
// but the AnalyzerOptions doesn't have access to a diagnostic engine.
|
|
return llvm::StringSwitch<bool>(Config.lookup(Name))
|
|
.Case("true", true)
|
|
.Case("false", false)
|
|
.Default(DefaultVal);
|
|
}
|
|
|
|
bool AnalyzerOptions::includeTemporaryDtorsInCFG() const {
|
|
if (!IncludeTemporaryDtorsInCFG.hasValue())
|
|
const_cast<llvm::Optional<bool> &>(IncludeTemporaryDtorsInCFG) =
|
|
getBooleanOption("cfg-temporary-dtors", /*Default=*/false);
|
|
|
|
return *IncludeTemporaryDtorsInCFG;
|
|
}
|
|
|
|
bool AnalyzerOptions::mayInlineCXXStandardLibrary() const {
|
|
if (!InlineCXXStandardLibrary.hasValue())
|
|
const_cast<llvm::Optional<bool> &>(InlineCXXStandardLibrary) =
|
|
getBooleanOption("c++-stdlib-inlining", /*Default=*/true);
|
|
|
|
return *InlineCXXStandardLibrary;
|
|
}
|
|
|
|
bool AnalyzerOptions::mayInlineTemplateFunctions() const {
|
|
if (!InlineTemplateFunctions.hasValue())
|
|
const_cast<llvm::Optional<bool> &>(InlineTemplateFunctions) =
|
|
getBooleanOption("c++-template-inlining", /*Default=*/true);
|
|
|
|
return *InlineTemplateFunctions;
|
|
}
|
|
|
|
bool AnalyzerOptions::mayInlineObjCMethod() const {
|
|
if (!ObjCInliningMode.hasValue())
|
|
const_cast<llvm::Optional<bool> &>(ObjCInliningMode) =
|
|
getBooleanOption("objc-inlining", /*Default=*/true);
|
|
|
|
return *ObjCInliningMode;
|
|
}
|
|
|
|
int AnalyzerOptions::getOptionAsInteger(StringRef Name, int DefaultVal) const {
|
|
std::string OptStr = Config.lookup(Name);
|
|
if (OptStr.empty())
|
|
return DefaultVal;
|
|
|
|
int Res = DefaultVal;
|
|
assert(StringRef(OptStr).getAsInteger(10, Res) == false &&
|
|
"analyzer-config option should be numeric.");
|
|
|
|
return Res;
|
|
}
|
|
|
|
unsigned AnalyzerOptions::getAlwaysInlineSize() const {
|
|
if (!AlwaysInlineSize.hasValue()) {
|
|
unsigned DefaultSize = 3;
|
|
const_cast<Optional<unsigned> &>(AlwaysInlineSize) =
|
|
getOptionAsInteger("ipa-always-inline-size", DefaultSize);
|
|
}
|
|
|
|
return AlwaysInlineSize.getValue();
|
|
}
|
|
|
|
bool AnalyzerOptions::shouldSynthesizeBodies() const {
|
|
return getBooleanOption("faux-bodies", false);
|
|
}
|