2010-03-21 05:06:02 +08:00
|
|
|
//=- AnalysisBasedWarnings.cpp - Sema warnings based on libAnalysis -*- C++ -*-=//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This file defines analysis_warnings::[Policy,Executor].
|
|
|
|
// Together they are used by Sema to issue warnings based on inexpensive
|
|
|
|
// static analysis algorithms in libAnalysis.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2010-08-13 04:07:10 +08:00
|
|
|
#include "clang/Sema/Sema.h"
|
|
|
|
#include "clang/Sema/AnalysisBasedWarnings.h"
|
2010-03-21 05:11:09 +08:00
|
|
|
#include "clang/Basic/SourceManager.h"
|
2010-08-24 15:21:54 +08:00
|
|
|
#include "clang/AST/DeclObjC.h"
|
2010-03-21 05:06:02 +08:00
|
|
|
#include "clang/AST/ExprObjC.h"
|
|
|
|
#include "clang/AST/ExprCXX.h"
|
|
|
|
#include "clang/AST/StmtObjC.h"
|
|
|
|
#include "clang/AST/StmtCXX.h"
|
|
|
|
#include "clang/Analysis/AnalysisContext.h"
|
|
|
|
#include "clang/Analysis/CFG.h"
|
|
|
|
#include "clang/Analysis/Analyses/ReachableCode.h"
|
|
|
|
#include "llvm/ADT/BitVector.h"
|
|
|
|
#include "llvm/Support/Casting.h"
|
|
|
|
|
|
|
|
using namespace clang;
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Unreachable code analysis.
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
class UnreachableCodeHandler : public reachable_code::Callback {
|
|
|
|
Sema &S;
|
|
|
|
public:
|
|
|
|
UnreachableCodeHandler(Sema &s) : S(s) {}
|
|
|
|
|
|
|
|
void HandleUnreachable(SourceLocation L, SourceRange R1, SourceRange R2) {
|
|
|
|
S.Diag(L, diag::warn_unreachable) << R1 << R2;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
/// CheckUnreachable - Check for unreachable code.
|
|
|
|
static void CheckUnreachable(Sema &S, AnalysisContext &AC) {
|
|
|
|
UnreachableCodeHandler UC(S);
|
|
|
|
reachable_code::FindUnreachableCode(AC, UC);
|
|
|
|
}
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Check for missing return value.
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2010-05-16 17:34:11 +08:00
|
|
|
enum ControlFlowKind {
|
|
|
|
UnknownFallThrough,
|
|
|
|
NeverFallThrough,
|
|
|
|
MaybeFallThrough,
|
|
|
|
AlwaysFallThrough,
|
|
|
|
NeverFallThroughOrReturn
|
|
|
|
};
|
2010-03-21 05:06:02 +08:00
|
|
|
|
|
|
|
/// CheckFallThrough - Check that we don't fall off the end of a
|
|
|
|
/// Statement that should return a value.
|
|
|
|
///
|
|
|
|
/// \returns AlwaysFallThrough iff we always fall off the end of the statement,
|
|
|
|
/// MaybeFallThrough iff we might or might not fall off the end,
|
|
|
|
/// NeverFallThroughOrReturn iff we never fall off the end of the statement or
|
|
|
|
/// return. We assume NeverFallThrough iff we never fall off the end of the
|
|
|
|
/// statement but we may return. We assume that functions not marked noreturn
|
|
|
|
/// will return.
|
|
|
|
static ControlFlowKind CheckFallThrough(AnalysisContext &AC) {
|
|
|
|
CFG *cfg = AC.getCFG();
|
2010-05-16 17:34:11 +08:00
|
|
|
if (cfg == 0) return UnknownFallThrough;
|
2010-03-21 05:06:02 +08:00
|
|
|
|
|
|
|
// The CFG leaves in dead things, and we don't want the dead code paths to
|
|
|
|
// confuse us, so we mark all live things first.
|
|
|
|
llvm::BitVector live(cfg->getNumBlockIDs());
|
|
|
|
unsigned count = reachable_code::ScanReachableFromBlock(cfg->getEntry(),
|
|
|
|
live);
|
|
|
|
|
|
|
|
bool AddEHEdges = AC.getAddEHEdges();
|
|
|
|
if (!AddEHEdges && count != cfg->getNumBlockIDs())
|
|
|
|
// When there are things remaining dead, and we didn't add EH edges
|
|
|
|
// from CallExprs to the catch clauses, we have to go back and
|
|
|
|
// mark them as live.
|
|
|
|
for (CFG::iterator I = cfg->begin(), E = cfg->end(); I != E; ++I) {
|
|
|
|
CFGBlock &b = **I;
|
|
|
|
if (!live[b.getBlockID()]) {
|
|
|
|
if (b.pred_begin() == b.pred_end()) {
|
|
|
|
if (b.getTerminator() && isa<CXXTryStmt>(b.getTerminator()))
|
|
|
|
// When not adding EH edges from calls, catch clauses
|
|
|
|
// can otherwise seem dead. Avoid noting them as dead.
|
|
|
|
count += reachable_code::ScanReachableFromBlock(b, live);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Now we know what is live, we check the live precessors of the exit block
|
|
|
|
// and look for fall through paths, being careful to ignore normal returns,
|
|
|
|
// and exceptional paths.
|
|
|
|
bool HasLiveReturn = false;
|
|
|
|
bool HasFakeEdge = false;
|
|
|
|
bool HasPlainEdge = false;
|
|
|
|
bool HasAbnormalEdge = false;
|
|
|
|
for (CFGBlock::pred_iterator I=cfg->getExit().pred_begin(),
|
|
|
|
E = cfg->getExit().pred_end();
|
|
|
|
I != E;
|
|
|
|
++I) {
|
|
|
|
CFGBlock& B = **I;
|
|
|
|
if (!live[B.getBlockID()])
|
|
|
|
continue;
|
|
|
|
if (B.size() == 0) {
|
|
|
|
if (B.getTerminator() && isa<CXXTryStmt>(B.getTerminator())) {
|
|
|
|
HasAbnormalEdge = true;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
// A labeled empty statement, or the entry block...
|
|
|
|
HasPlainEdge = true;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
Stmt *S = B[B.size()-1];
|
|
|
|
if (isa<ReturnStmt>(S)) {
|
|
|
|
HasLiveReturn = true;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (isa<ObjCAtThrowStmt>(S)) {
|
|
|
|
HasFakeEdge = true;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (isa<CXXThrowExpr>(S)) {
|
|
|
|
HasFakeEdge = true;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (const AsmStmt *AS = dyn_cast<AsmStmt>(S)) {
|
|
|
|
if (AS->isMSAsm()) {
|
|
|
|
HasFakeEdge = true;
|
|
|
|
HasLiveReturn = true;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (isa<CXXTryStmt>(S)) {
|
|
|
|
HasAbnormalEdge = true;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool NoReturnEdge = false;
|
|
|
|
if (CallExpr *C = dyn_cast<CallExpr>(S)) {
|
2010-04-30 15:10:06 +08:00
|
|
|
if (std::find(B.succ_begin(), B.succ_end(), &cfg->getExit())
|
|
|
|
== B.succ_end()) {
|
2010-03-21 05:06:02 +08:00
|
|
|
HasAbnormalEdge = true;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
Expr *CEE = C->getCallee()->IgnoreParenCasts();
|
2010-03-31 04:24:48 +08:00
|
|
|
if (getFunctionExtInfo(CEE->getType()).getNoReturn()) {
|
2010-03-21 05:06:02 +08:00
|
|
|
NoReturnEdge = true;
|
|
|
|
HasFakeEdge = true;
|
|
|
|
} else if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(CEE)) {
|
|
|
|
ValueDecl *VD = DRE->getDecl();
|
|
|
|
if (VD->hasAttr<NoReturnAttr>()) {
|
|
|
|
NoReturnEdge = true;
|
|
|
|
HasFakeEdge = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2010-05-18 07:51:52 +08:00
|
|
|
// FIXME: Remove this hack once temporaries and their destructors are
|
|
|
|
// modeled correctly by the CFG.
|
|
|
|
if (CXXExprWithTemporaries *E = dyn_cast<CXXExprWithTemporaries>(S)) {
|
|
|
|
for (unsigned I = 0, N = E->getNumTemporaries(); I != N; ++I) {
|
|
|
|
const FunctionDecl *FD = E->getTemporary(I)->getDestructor();
|
|
|
|
if (FD->hasAttr<NoReturnAttr>() ||
|
|
|
|
FD->getType()->getAs<FunctionType>()->getNoReturnAttr()) {
|
|
|
|
NoReturnEdge = true;
|
|
|
|
HasFakeEdge = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2010-03-21 05:06:02 +08:00
|
|
|
// FIXME: Add noreturn message sends.
|
|
|
|
if (NoReturnEdge == false)
|
|
|
|
HasPlainEdge = true;
|
|
|
|
}
|
|
|
|
if (!HasPlainEdge) {
|
|
|
|
if (HasLiveReturn)
|
|
|
|
return NeverFallThrough;
|
|
|
|
return NeverFallThroughOrReturn;
|
|
|
|
}
|
|
|
|
if (HasAbnormalEdge || HasFakeEdge || HasLiveReturn)
|
|
|
|
return MaybeFallThrough;
|
|
|
|
// This says AlwaysFallThrough for calls to functions that are not marked
|
|
|
|
// noreturn, that don't return. If people would like this warning to be more
|
|
|
|
// accurate, such functions should be marked as noreturn.
|
|
|
|
return AlwaysFallThrough;
|
|
|
|
}
|
|
|
|
|
2010-07-27 05:25:24 +08:00
|
|
|
namespace {
|
|
|
|
|
2010-03-21 05:06:02 +08:00
|
|
|
struct CheckFallThroughDiagnostics {
|
|
|
|
unsigned diag_MaybeFallThrough_HasNoReturn;
|
|
|
|
unsigned diag_MaybeFallThrough_ReturnsNonVoid;
|
|
|
|
unsigned diag_AlwaysFallThrough_HasNoReturn;
|
|
|
|
unsigned diag_AlwaysFallThrough_ReturnsNonVoid;
|
|
|
|
unsigned diag_NeverFallThroughOrReturn;
|
|
|
|
bool funMode;
|
2010-03-23 08:13:23 +08:00
|
|
|
|
2010-04-17 07:28:44 +08:00
|
|
|
static CheckFallThroughDiagnostics MakeForFunction(const Decl *Func) {
|
2010-03-21 05:06:02 +08:00
|
|
|
CheckFallThroughDiagnostics D;
|
|
|
|
D.diag_MaybeFallThrough_HasNoReturn =
|
|
|
|
diag::warn_falloff_noreturn_function;
|
|
|
|
D.diag_MaybeFallThrough_ReturnsNonVoid =
|
|
|
|
diag::warn_maybe_falloff_nonvoid_function;
|
|
|
|
D.diag_AlwaysFallThrough_HasNoReturn =
|
|
|
|
diag::warn_falloff_noreturn_function;
|
|
|
|
D.diag_AlwaysFallThrough_ReturnsNonVoid =
|
|
|
|
diag::warn_falloff_nonvoid_function;
|
2010-04-17 07:28:44 +08:00
|
|
|
|
|
|
|
// Don't suggest that virtual functions be marked "noreturn", since they
|
|
|
|
// might be overridden by non-noreturn functions.
|
|
|
|
bool isVirtualMethod = false;
|
|
|
|
if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Func))
|
|
|
|
isVirtualMethod = Method->isVirtual();
|
|
|
|
|
|
|
|
if (!isVirtualMethod)
|
|
|
|
D.diag_NeverFallThroughOrReturn =
|
|
|
|
diag::warn_suggest_noreturn_function;
|
|
|
|
else
|
|
|
|
D.diag_NeverFallThroughOrReturn = 0;
|
|
|
|
|
2010-03-21 05:06:02 +08:00
|
|
|
D.funMode = true;
|
|
|
|
return D;
|
|
|
|
}
|
2010-03-23 08:13:23 +08:00
|
|
|
|
2010-03-21 05:06:02 +08:00
|
|
|
static CheckFallThroughDiagnostics MakeForBlock() {
|
|
|
|
CheckFallThroughDiagnostics D;
|
|
|
|
D.diag_MaybeFallThrough_HasNoReturn =
|
|
|
|
diag::err_noreturn_block_has_return_expr;
|
|
|
|
D.diag_MaybeFallThrough_ReturnsNonVoid =
|
|
|
|
diag::err_maybe_falloff_nonvoid_block;
|
|
|
|
D.diag_AlwaysFallThrough_HasNoReturn =
|
|
|
|
diag::err_noreturn_block_has_return_expr;
|
|
|
|
D.diag_AlwaysFallThrough_ReturnsNonVoid =
|
|
|
|
diag::err_falloff_nonvoid_block;
|
|
|
|
D.diag_NeverFallThroughOrReturn =
|
|
|
|
diag::warn_suggest_noreturn_block;
|
|
|
|
D.funMode = false;
|
|
|
|
return D;
|
|
|
|
}
|
2010-03-23 08:13:23 +08:00
|
|
|
|
2010-03-21 05:06:02 +08:00
|
|
|
bool checkDiagnostics(Diagnostic &D, bool ReturnsVoid,
|
|
|
|
bool HasNoReturn) const {
|
|
|
|
if (funMode) {
|
|
|
|
return (D.getDiagnosticLevel(diag::warn_maybe_falloff_nonvoid_function)
|
|
|
|
== Diagnostic::Ignored || ReturnsVoid)
|
|
|
|
&& (D.getDiagnosticLevel(diag::warn_noreturn_function_has_return_expr)
|
|
|
|
== Diagnostic::Ignored || !HasNoReturn)
|
|
|
|
&& (D.getDiagnosticLevel(diag::warn_suggest_noreturn_block)
|
|
|
|
== Diagnostic::Ignored || !ReturnsVoid);
|
|
|
|
}
|
2010-03-23 08:13:23 +08:00
|
|
|
|
2010-03-21 05:06:02 +08:00
|
|
|
// For blocks.
|
|
|
|
return ReturnsVoid && !HasNoReturn
|
|
|
|
&& (D.getDiagnosticLevel(diag::warn_suggest_noreturn_block)
|
|
|
|
== Diagnostic::Ignored || !ReturnsVoid);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2010-07-27 05:25:24 +08:00
|
|
|
}
|
|
|
|
|
2010-03-21 05:06:02 +08:00
|
|
|
/// CheckFallThroughForFunctionDef - Check that we don't fall off the end of a
|
|
|
|
/// function that should return a value. Check that we don't fall off the end
|
|
|
|
/// of a noreturn function. We assume that functions and blocks not marked
|
|
|
|
/// noreturn will return.
|
|
|
|
static void CheckFallThroughForBody(Sema &S, const Decl *D, const Stmt *Body,
|
|
|
|
QualType BlockTy,
|
|
|
|
const CheckFallThroughDiagnostics& CD,
|
|
|
|
AnalysisContext &AC) {
|
|
|
|
|
|
|
|
bool ReturnsVoid = false;
|
|
|
|
bool HasNoReturn = false;
|
|
|
|
|
|
|
|
if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
|
|
|
|
ReturnsVoid = FD->getResultType()->isVoidType();
|
|
|
|
HasNoReturn = FD->hasAttr<NoReturnAttr>() ||
|
2010-03-31 04:24:48 +08:00
|
|
|
FD->getType()->getAs<FunctionType>()->getNoReturnAttr();
|
2010-03-21 05:06:02 +08:00
|
|
|
}
|
|
|
|
else if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) {
|
|
|
|
ReturnsVoid = MD->getResultType()->isVoidType();
|
|
|
|
HasNoReturn = MD->hasAttr<NoReturnAttr>();
|
|
|
|
}
|
|
|
|
else if (isa<BlockDecl>(D)) {
|
2010-03-23 08:13:23 +08:00
|
|
|
if (const FunctionType *FT =
|
2010-03-21 05:06:02 +08:00
|
|
|
BlockTy->getPointeeType()->getAs<FunctionType>()) {
|
|
|
|
if (FT->getResultType()->isVoidType())
|
|
|
|
ReturnsVoid = true;
|
|
|
|
if (FT->getNoReturnAttr())
|
|
|
|
HasNoReturn = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Diagnostic &Diags = S.getDiagnostics();
|
|
|
|
|
|
|
|
// Short circuit for compilation speed.
|
|
|
|
if (CD.checkDiagnostics(Diags, ReturnsVoid, HasNoReturn))
|
|
|
|
return;
|
2010-03-23 08:13:23 +08:00
|
|
|
|
2010-03-21 05:06:02 +08:00
|
|
|
// FIXME: Function try block
|
|
|
|
if (const CompoundStmt *Compound = dyn_cast<CompoundStmt>(Body)) {
|
|
|
|
switch (CheckFallThrough(AC)) {
|
2010-05-16 17:34:11 +08:00
|
|
|
case UnknownFallThrough:
|
|
|
|
break;
|
|
|
|
|
2010-03-21 05:06:02 +08:00
|
|
|
case MaybeFallThrough:
|
|
|
|
if (HasNoReturn)
|
|
|
|
S.Diag(Compound->getRBracLoc(),
|
|
|
|
CD.diag_MaybeFallThrough_HasNoReturn);
|
|
|
|
else if (!ReturnsVoid)
|
|
|
|
S.Diag(Compound->getRBracLoc(),
|
|
|
|
CD.diag_MaybeFallThrough_ReturnsNonVoid);
|
|
|
|
break;
|
|
|
|
case AlwaysFallThrough:
|
|
|
|
if (HasNoReturn)
|
|
|
|
S.Diag(Compound->getRBracLoc(),
|
|
|
|
CD.diag_AlwaysFallThrough_HasNoReturn);
|
|
|
|
else if (!ReturnsVoid)
|
|
|
|
S.Diag(Compound->getRBracLoc(),
|
|
|
|
CD.diag_AlwaysFallThrough_ReturnsNonVoid);
|
|
|
|
break;
|
|
|
|
case NeverFallThroughOrReturn:
|
2010-04-17 07:28:44 +08:00
|
|
|
if (ReturnsVoid && !HasNoReturn && CD.diag_NeverFallThroughOrReturn)
|
2010-03-21 05:06:02 +08:00
|
|
|
S.Diag(Compound->getLBracLoc(),
|
|
|
|
CD.diag_NeverFallThroughOrReturn);
|
|
|
|
break;
|
|
|
|
case NeverFallThrough:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// AnalysisBasedWarnings - Worker object used by Sema to execute analysis-based
|
|
|
|
// warnings on a function, method, or block.
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2010-03-23 08:13:23 +08:00
|
|
|
clang::sema::AnalysisBasedWarnings::Policy::Policy() {
|
2010-03-21 05:06:02 +08:00
|
|
|
enableCheckFallThrough = 1;
|
2010-03-23 08:13:23 +08:00
|
|
|
enableCheckUnreachable = 0;
|
|
|
|
}
|
2010-03-21 05:06:02 +08:00
|
|
|
|
2010-03-23 08:13:23 +08:00
|
|
|
clang::sema::AnalysisBasedWarnings::AnalysisBasedWarnings(Sema &s) : S(s) {
|
|
|
|
Diagnostic &D = S.getDiagnostics();
|
|
|
|
DefaultPolicy.enableCheckUnreachable = (unsigned)
|
2010-03-21 05:06:02 +08:00
|
|
|
(D.getDiagnosticLevel(diag::warn_unreachable) != Diagnostic::Ignored);
|
|
|
|
}
|
|
|
|
|
2010-03-23 08:13:23 +08:00
|
|
|
void clang::sema::
|
|
|
|
AnalysisBasedWarnings::IssueWarnings(sema::AnalysisBasedWarnings::Policy P,
|
2010-04-09 02:51:44 +08:00
|
|
|
const Decl *D, QualType BlockTy) {
|
2010-03-23 08:13:23 +08:00
|
|
|
|
2010-03-21 05:06:02 +08:00
|
|
|
assert(BlockTy.isNull() || isa<BlockDecl>(D));
|
2010-03-21 05:11:09 +08:00
|
|
|
|
2010-03-21 05:06:02 +08:00
|
|
|
// We avoid doing analysis-based warnings when there are errors for
|
|
|
|
// two reasons:
|
|
|
|
// (1) The CFGs often can't be constructed (if the body is invalid), so
|
|
|
|
// don't bother trying.
|
|
|
|
// (2) The code already has problems; running the analysis just takes more
|
|
|
|
// time.
|
2010-05-01 05:49:25 +08:00
|
|
|
Diagnostic &Diags = S.getDiagnostics();
|
|
|
|
|
|
|
|
if (Diags.hasErrorOccurred() || Diags.hasFatalErrorOccurred())
|
2010-03-23 08:13:23 +08:00
|
|
|
return;
|
|
|
|
|
|
|
|
// Do not do any analysis for declarations in system headers if we are
|
|
|
|
// going to just ignore them.
|
2010-05-01 05:49:25 +08:00
|
|
|
if (Diags.getSuppressSystemWarnings() &&
|
2010-03-23 08:13:23 +08:00
|
|
|
S.SourceMgr.isInSystemHeader(D->getLocation()))
|
|
|
|
return;
|
|
|
|
|
2010-08-25 13:56:39 +08:00
|
|
|
// For code in dependent contexts, we'll do this at instantiation time.
|
|
|
|
if (cast<DeclContext>(D)->isDependentContext())
|
|
|
|
return;
|
2010-03-21 05:06:02 +08:00
|
|
|
|
|
|
|
const Stmt *Body = D->getBody();
|
|
|
|
assert(Body);
|
|
|
|
|
|
|
|
// Don't generate EH edges for CallExprs as we'd like to avoid the n^2
|
|
|
|
// explosion for destrutors that can result and the compile time hit.
|
2010-07-19 21:16:50 +08:00
|
|
|
AnalysisContext AC(D, 0, false);
|
2010-03-21 05:06:02 +08:00
|
|
|
|
|
|
|
// Warning: check missing 'return'
|
2010-03-23 08:13:23 +08:00
|
|
|
if (P.enableCheckFallThrough) {
|
2010-03-21 05:06:02 +08:00
|
|
|
const CheckFallThroughDiagnostics &CD =
|
|
|
|
(isa<BlockDecl>(D) ? CheckFallThroughDiagnostics::MakeForBlock()
|
2010-04-17 07:28:44 +08:00
|
|
|
: CheckFallThroughDiagnostics::MakeForFunction(D));
|
2010-03-21 05:06:02 +08:00
|
|
|
CheckFallThroughForBody(S, D, Body, BlockTy, CD, AC);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Warning: check for unreachable code
|
2010-04-09 02:51:44 +08:00
|
|
|
if (P.enableCheckUnreachable)
|
2010-03-21 05:06:02 +08:00
|
|
|
CheckUnreachable(S, AC);
|
|
|
|
}
|
2010-08-25 13:56:39 +08:00
|
|
|
|
|
|
|
void clang::sema::
|
|
|
|
AnalysisBasedWarnings::IssueWarnings(sema::AnalysisBasedWarnings::Policy P,
|
|
|
|
const BlockExpr *E) {
|
|
|
|
return IssueWarnings(P, E->getBlockDecl(), E->getType());
|
|
|
|
}
|
|
|
|
|
|
|
|
void clang::sema::
|
|
|
|
AnalysisBasedWarnings::IssueWarnings(sema::AnalysisBasedWarnings::Policy P,
|
|
|
|
const ObjCMethodDecl *D) {
|
|
|
|
return IssueWarnings(P, D, QualType());
|
|
|
|
}
|
|
|
|
|
|
|
|
void clang::sema::
|
|
|
|
AnalysisBasedWarnings::IssueWarnings(sema::AnalysisBasedWarnings::Policy P,
|
|
|
|
const FunctionDecl *D) {
|
|
|
|
return IssueWarnings(P, D, QualType());
|
|
|
|
}
|