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
14namespace clang::tidy::altera {
15
16/// Finds inner loops that have not been unrolled, as well as fully unrolled
17/// loops with unknown loop bounds or a large number of iterations.
18///
19/// Unrolling inner loops could improve the performance of OpenCL kernels.
20/// However, if they have unknown loop bounds or a large number of iterations,
21/// they cannot be fully unrolled, and should be partially unrolled.
22///
23/// For the user-facing documentation see:
24/// http://clang.llvm.org/extra/clang-tidy/checks/altera/unroll-loops.html
25class UnrollLoopsCheck : public ClangTidyCheck {
26public:
27 UnrollLoopsCheck(StringRef Name, ClangTidyContext *Context);
28 void registerMatchers(ast_matchers::MatchFinder *Finder) override;
29 void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
30
31private:
32 /// Recommend partial unrolling if number of loop iterations is greater than
33 /// MaxLoopIterations.
34 const unsigned MaxLoopIterations;
35 /// The kind of unrolling, if any, applied to a given loop.
36 enum UnrollType {
37 // This loop has no #pragma unroll directive associated with it.
38 NotUnrolled,
39 // This loop has a #pragma unroll directive associated with it.
40 FullyUnrolled,
41 // This loop has a #pragma unroll <num> directive associated with it.
42 PartiallyUnrolled
43 };
44 /// Attempts to extract an integer value from either side of the
45 /// BinaryOperator. Returns true and saves the result to &value if successful,
46 /// returns false otherwise.
47 bool extractValue(int &Value, const BinaryOperator *Op,
48 const ASTContext *Context);
49 /// Returns true if the given loop statement has a large number of iterations,
50 /// as determined by the integer value in the loop's condition expression,
51 /// if one exists.
52 bool hasLargeNumIterations(const Stmt *Statement,
53 const IntegerLiteral *CXXLoopBound,
54 const ASTContext *Context);
55 /// Checks one hand side of the binary operator to ascertain if the upper
56 /// bound on the number of loops is greater than max_loop_iterations or not.
57 /// If the expression is not evaluatable or not an integer, returns false.
58 bool exprHasLargeNumIterations(const Expr *Expression,
59 const ASTContext *Context) const;
60 /// Returns the type of unrolling, if any, associated with the given
61 /// statement.
62 enum UnrollType unrollType(const Stmt *Statement, ASTContext *Context);
63 /// Returns the condition expression within a given for statement. If there is
64 /// none, or if the Statement is not a loop, then returns a NULL pointer.
65 const Expr *getCondExpr(const Stmt *Statement);
66 /// Returns True if the loop statement has known bounds.
67 bool hasKnownBounds(const Stmt *Statement, const IntegerLiteral *CXXLoopBound,
68 const ASTContext *Context);
69 void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
70};
71
72} // namespace clang::tidy::altera
73
74#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ALTERA_UNROLLLOOPSCHECK_H
75

source code of clang-tools-extra/clang-tidy/altera/UnrollLoopsCheck.h