clang-tools
15.0.0git
llvm-project
clang-tools-extra
clang-tidy
altera
UnrollLoopsCheck.h
Go to the documentation of this file.
1
//===--- UnrollLoopsCheck.h - clang-tidy ------------------------*- C++ -*-===//
2
//
3
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4
// See https://llvm.org/LICENSE.txt for license information.
5
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6
//
7
//===----------------------------------------------------------------------===//
8
9
#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ALTERA_UNROLLLOOPSCHECK_H
10
#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ALTERA_UNROLLLOOPSCHECK_H
11
12
#include "../ClangTidyCheck.h"
13
14
namespace
clang
{
15
namespace
tidy {
16
namespace
altera {
17
18
/// Finds inner loops that have not been unrolled, as well as fully unrolled
19
/// loops with unknown loop bounds or a large number of iterations.
20
///
21
/// Unrolling inner loops could improve the performance of OpenCL kernels.
22
/// However, if they have unknown loop bounds or a large number of iterations,
23
/// they cannot be fully unrolled, and should be partially unrolled.
24
///
25
/// For the user-facing documentation see:
26
/// http://clang.llvm.org/extra/clang-tidy/checks/altera/unroll-loops.html
27
class
UnrollLoopsCheck
:
public
ClangTidyCheck
{
28
public
:
29
UnrollLoopsCheck
(StringRef
Name
,
ClangTidyContext
*Context);
30
void
registerMatchers
(ast_matchers::MatchFinder *Finder)
override
;
31
void
check
(
const
ast_matchers::MatchFinder::MatchResult &Result)
override
;
32
33
private
:
34
/// Recommend partial unrolling if number of loop iterations is greater than
35
/// MaxLoopIterations.
36
const
unsigned
MaxLoopIterations;
37
/// The kind of unrolling, if any, applied to a given loop.
38
enum
UnrollType {
39
// This loop has no #pragma unroll directive associated with it.
40
NotUnrolled,
41
// This loop has a #pragma unroll directive associated with it.
42
FullyUnrolled,
43
// This loop has a #pragma unroll <num> directive associated with it.
44
PartiallyUnrolled
45
};
46
/// Attempts to extract an integer value from either side of the
47
/// BinaryOperator. Returns true and saves the result to &value if successful,
48
/// returns false otherwise.
49
bool
extractValue(
int
&Value,
const
BinaryOperator *Op,
50
const
ASTContext *Context);
51
/// Returns true if the given loop statement has a large number of iterations,
52
/// as determined by the integer value in the loop's condition expression,
53
/// if one exists.
54
bool
hasLargeNumIterations(
const
Stmt *Statement,
55
const
IntegerLiteral *CXXLoopBound,
56
const
ASTContext *Context);
57
/// Checks one hand side of the binary operator to ascertain if the upper
58
/// bound on the number of loops is greater than max_loop_iterations or not.
59
/// If the expression is not evaluatable or not an integer, returns false.
60
bool
exprHasLargeNumIterations(
const
Expr *Expression,
61
const
ASTContext *Context);
62
/// Returns the type of unrolling, if any, associated with the given
63
/// statement.
64
enum
UnrollType unrollType(
const
Stmt *Statement, ASTContext *Context);
65
/// Returns the condition expression within a given for statement. If there is
66
/// none, or if the Statement is not a loop, then returns a NULL pointer.
67
const
Expr *getCondExpr(
const
Stmt *Statement);
68
/// Returns True if the loop statement has known bounds.
69
bool
hasKnownBounds(
const
Stmt *Statement,
const
IntegerLiteral *CXXLoopBound,
70
const
ASTContext *Context);
71
void
storeOptions(
ClangTidyOptions::OptionMap
&Opts)
override
;
72
};
73
74
}
// namespace altera
75
}
// namespace tidy
76
}
// namespace clang
77
78
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ALTERA_UNROLLLOOPSCHECK_H
clang::tidy::ClangTidyOptions::OptionMap
llvm::StringMap< ClangTidyValue > OptionMap
Definition:
ClangTidyOptions.h:115
clang::tidy::altera::UnrollLoopsCheck::registerMatchers
void registerMatchers(ast_matchers::MatchFinder *Finder) override
Override this to register AST matchers with Finder.
Definition:
UnrollLoopsCheck.cpp:28
clang::tidy::ClangTidyCheck
Base class for all clang-tidy checks.
Definition:
ClangTidyCheck.h:53
clang::tidy::altera::UnrollLoopsCheck::UnrollLoopsCheck
UnrollLoopsCheck(StringRef Name, ClangTidyContext *Context)
Definition:
UnrollLoopsCheck.cpp:24
clang::tidy::ClangTidyContext
Every ClangTidyCheck reports errors through a DiagnosticsEngine provided by this context.
Definition:
ClangTidyDiagnosticConsumer.h:67
clang::tidy::altera::UnrollLoopsCheck::check
void check(const ast_matchers::MatchFinder::MatchResult &Result) override
ClangTidyChecks that register ASTMatchers should do the actual work in here.
Definition:
UnrollLoopsCheck.cpp:40
Name
Token Name
Definition:
MacroToEnumCheck.cpp:89
clang
===– Representation.cpp - ClangDoc Representation --------—*- C++ -*-===//
Definition:
ApplyReplacements.h:27
clang::tidy::altera::UnrollLoopsCheck
Finds inner loops that have not been unrolled, as well as fully unrolled loops with unknown loop boun...
Definition:
UnrollLoopsCheck.h:27
Generated on Sun Jun 26 2022 13:27:17 for clang-tools by
1.8.17