Skip to content

Commit e60da46

Browse files
spavloffspavloff
committed
[Analysis] Avoid some warnings about exit from noreturn function
Compiler sometimes issues warnings on exit from 'noreturn' functions, in the code like: [[noreturn]] extern void nonreturnable(); void (*func_ptr)(); [[noreturn]] void foo() { func_ptr = nonreturnable; (*func_ptr)(); } where exit cannot take place because the function pointer is actually a pointer to noreturn function. This change introduces small data analysis that can remove some of the warnings in the cases when compiler can prove that the set of reaching definitions consists of noreturn functions only.
1 parent 21491ed commit e60da46

File tree

2 files changed

+221
-0
lines changed

2 files changed

+221
-0
lines changed

‎clang/lib/Sema/AnalysisBasedWarnings.cpp‎

Lines changed: 114 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -37,6 +37,7 @@
3737
#include "clang/Analysis/AnalysisDeclContext.h"
3838
#include "clang/Analysis/CFG.h"
3939
#include "clang/Analysis/CFGStmtMap.h"
40+
#include "clang/Analysis/FlowSensitive/DataflowWorklist.h"
4041
#include "clang/Basic/Diagnostic.h"
4142
#include "clang/Basic/DiagnosticSema.h"
4243
#include "clang/Basic/SourceLocation.h"
@@ -401,6 +402,108 @@ static bool isNoexcept(const FunctionDecl *FD) {
401402
return false;
402403
}
403404

405+
/// Checks if the given variable, which is assumed to be a function pointer, is
406+
/// initialized with a function having 'noreturn' attribute.
407+
static bool isInitializedWithNoReturn(const VarDecl *VD) {
408+
if (const Expr *Init = VD->getInit()) {
409+
if (auto *ListInit = dyn_cast<InitListExpr>(Init);
410+
ListInit && ListInit->getNumInits() > 0)
411+
Init = ListInit->getInit(0);
412+
if (auto *DeclRef = dyn_cast<DeclRefExpr>(Init->IgnoreParenCasts()))
413+
if (auto *FD = dyn_cast<FunctionDecl>(DeclRef->getDecl()))
414+
return FD->isNoReturn();
415+
}
416+
return false;
417+
}
418+
419+
/// Checks if the given expression is a reference to a function with
420+
/// 'noreturn' attribute.
421+
static bool isReferenceToNoReturn(const Expr *E) {
422+
if (auto *DRef = dyn_cast<DeclRefExpr>(E->IgnoreParenCasts()))
423+
if (auto *FD = dyn_cast<FunctionDecl>(DRef->getDecl()))
424+
return FD->isNoReturn();
425+
return false;
426+
}
427+
428+
namespace {
429+
430+
/// Looks for statements, that can define value of the given variable.
431+
struct TransferFunctions : public StmtVisitor<TransferFunctions> {
432+
const VarDecl *Var;
433+
std::optional<bool> AllValuesAreNoReturn;
434+
435+
TransferFunctions(const VarDecl *VD) : Var(VD) {}
436+
437+
void VisitDeclStmt(DeclStmt *DS) {
438+
for (auto *DI : DS->decls())
439+
if (auto *VD = dyn_cast<VarDecl>(DI))
440+
if (VarDecl *Def = VD->getDefinition())
441+
if (Def == Var)
442+
AllValuesAreNoReturn = isInitializedWithNoReturn(Def);
443+
}
444+
445+
void VisitUnaryOperator(UnaryOperator *UO) {
446+
if (UO->getOpcode() == UO_AddrOf) {
447+
if (auto *DRef =
448+
dyn_cast<DeclRefExpr>(UO->getSubExpr()->IgnoreParenCasts()))
449+
if (DRef->getDecl() == Var)
450+
AllValuesAreNoReturn = false;
451+
}
452+
}
453+
454+
void VisitBinaryOperator(BinaryOperator *BO) {
455+
if (BO->getOpcode() == BO_Assign)
456+
if (auto *DRef = dyn_cast<DeclRefExpr>(BO->getLHS()->IgnoreParenCasts()))
457+
if (DRef->getDecl() == Var)
458+
AllValuesAreNoReturn = isReferenceToNoReturn(BO->getRHS());
459+
}
460+
461+
void VisitCallExpr(CallExpr *CE) {
462+
for (CallExpr::arg_iterator I = CE->arg_begin(), E = CE->arg_end(); I != E;
463+
++I) {
464+
const Expr *Arg = *I;
465+
if (Arg->isGLValue() && !Arg->getType().isConstQualified())
466+
if (auto *DRef = dyn_cast<DeclRefExpr>(Arg->IgnoreParenCasts()))
467+
if (auto VD = dyn_cast<VarDecl>(DRef->getDecl()))
468+
if (VD->getDefinition() == Var)
469+
AllValuesAreNoReturn = false;
470+
}
471+
}
472+
};
473+
} // namespace
474+
475+
// Checks if all possible values of the given variable are functions with
476+
// 'noreturn' attribute.
477+
static bool areAllValuesNoReturn(const VarDecl *VD, const CFGBlock &VarBlk,
478+
AnalysisDeclContext &AC) {
479+
// The set of possible values of a constant variable is determined by
480+
// its initializer.
481+
if (VD->getType().isConstant(AC.getASTContext())) {
482+
if (const VarDecl *Def = VD->getDefinition())
483+
return isInitializedWithNoReturn(Def);
484+
return false;
485+
}
486+
487+
// Scan function statements for definitions of the given variable.
488+
TransferFunctions TF(VD);
489+
BackwardDataflowWorklist Worklist(*AC.getCFG(), AC);
490+
Worklist.enqueueBlock(&VarBlk);
491+
while (const CFGBlock *B = Worklist.dequeue()) {
492+
for (CFGBlock::const_reverse_iterator ri = B->rbegin(), re = B->rend();
493+
ri != re; ++ri) {
494+
if (std::optional<CFGStmt> cs = ri->getAs<CFGStmt>()) {
495+
const Stmt *S = cs->getStmt();
496+
TF.Visit(const_cast<Stmt *>(S));
497+
if (TF.AllValuesAreNoReturn)
498+
return *TF.AllValuesAreNoReturn;
499+
}
500+
}
501+
Worklist.enqueuePredecessors(B);
502+
}
503+
504+
return false;
505+
}
506+
404507
//===----------------------------------------------------------------------===//
405508
// Check for missing return value.
406509
//===----------------------------------------------------------------------===//
@@ -527,6 +630,17 @@ static ControlFlowKind CheckFallThrough(AnalysisDeclContext &AC) {
527630
HasAbnormalEdge = true;
528631
continue;
529632
}
633+
if (auto *Call = dyn_cast<CallExpr>(S)) {
634+
const Expr *Callee = Call->getCallee();
635+
if (Callee->getType()->isPointerType())
636+
if (auto *DeclRef =
637+
dyn_cast<DeclRefExpr>(Callee->IgnoreParenImpCasts()))
638+
if (auto *VD = dyn_cast<VarDecl>(DeclRef->getDecl()))
639+
if (areAllValuesNoReturn(VD, B, AC)) {
640+
HasAbnormalEdge = true;
641+
continue;
642+
}
643+
}
530644

531645
HasPlainEdge = true;
532646
}

‎clang/test/SemaCXX/noreturn-vars.cpp‎

Lines changed: 107 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,107 @@
1+
// RUN: %clang_cc1 -fsyntax-only %s -verify
2+
3+
[[noreturn]] extern void noret();
4+
[[noreturn]] extern void noret2();
5+
extern void ordinary();
6+
7+
typedef void (*func_type)(void);
8+
9+
// Constant initialization.
10+
11+
void (* const const_fptr)() = noret;
12+
[[noreturn]] void test_global_const() {
13+
const_fptr();
14+
}
15+
16+
const func_type const_fptr_cast = (func_type)noret2;
17+
[[noreturn]] void test_global_cast() {
18+
const_fptr_cast();
19+
}
20+
21+
void (* const const_fptr_list)() = {noret};
22+
[[noreturn]] void test_global_list() {
23+
const_fptr_list();
24+
}
25+
26+
const func_type const_fptr_fcast = func_type(noret2);
27+
[[noreturn]] void test_global_fcast() {
28+
const_fptr_fcast();
29+
}
30+
31+
[[noreturn]] void test_local_const() {
32+
void (* const fptr)() = noret;
33+
fptr();
34+
}
35+
36+
// Global variable assignment.
37+
void (*global_fptr)() = noret;
38+
39+
[[noreturn]] void test_global_noassign() {
40+
global_fptr();
41+
} // expected-warning {{function declared 'noreturn' should not return}}
42+
43+
[[noreturn]] void test_global_assign() {
44+
global_fptr = noret;
45+
global_fptr();
46+
}
47+
48+
[[noreturn]] void test_global_override() {
49+
global_fptr = ordinary;
50+
global_fptr = noret;
51+
global_fptr();
52+
}
53+
54+
[[noreturn]] void test_global_switch_01(int x) {
55+
switch(x) {
56+
case 1:
57+
global_fptr = noret;
58+
break;
59+
default:
60+
global_fptr = noret2;
61+
break;
62+
}
63+
global_fptr();
64+
}
65+
66+
[[noreturn]] void test_global_switch_02(int x) {
67+
switch(x) {
68+
case 1:
69+
global_fptr = ordinary;
70+
break;
71+
default:
72+
global_fptr = noret;
73+
break;
74+
}
75+
global_fptr();
76+
}
77+
78+
// Local variable assignment.
79+
80+
[[noreturn]] void test_local_init() {
81+
func_type func_ptr = noret;
82+
func_ptr();
83+
}
84+
85+
[[noreturn]] void test_local_assign() {
86+
void (*func_ptr)(void);
87+
func_ptr = noret;
88+
func_ptr();
89+
}
90+
91+
// Escaped value.
92+
93+
extern void abc_01(func_type &);
94+
extern void abc_02(func_type *);
95+
96+
[[noreturn]] void test_escape_ref() {
97+
func_type func_ptr = noret;
98+
abc_01(func_ptr);
99+
func_ptr();
100+
} // expected-warning {{function declared 'noreturn' should not return}}
101+
102+
[[noreturn]] void test_escape_addr() {
103+
func_type func_ptr = noret;
104+
abc_02(&func_ptr);
105+
func_ptr();
106+
} // expected-warning {{function declared 'noreturn' should not return}}
107+

0 commit comments

Comments
 (0)