Diff 236269

clang-tidy/CMakeLists.txt

Show All 35 Lines	target_link_libraries(clangTidy PRIVATE
clangStaticAnalyzerFrontend		clangStaticAnalyzerFrontend
)		)
endif()		endif()

# Checks.		# Checks.
# If you add a check, also add it to ClangTidyForceLinker.h in this directory.		# If you add a check, also add it to ClangTidyForceLinker.h in this directory.
add_subdirectory(android)		add_subdirectory(android)
add_subdirectory(abseil)		add_subdirectory(abseil)
		add_subdirectory(altera)
add_subdirectory(boost)		add_subdirectory(boost)
add_subdirectory(bugprone)		add_subdirectory(bugprone)
add_subdirectory(cert)		add_subdirectory(cert)
add_subdirectory(cppcoreguidelines)		add_subdirectory(cppcoreguidelines)
add_subdirectory(darwin)		add_subdirectory(darwin)
add_subdirectory(fuchsia)		add_subdirectory(fuchsia)
add_subdirectory(google)		add_subdirectory(google)
add_subdirectory(hicpp)		add_subdirectory(hicpp)
add_subdirectory(linuxkernel)		add_subdirectory(linuxkernel)
add_subdirectory(llvm)		add_subdirectory(llvm)
add_subdirectory(misc)		add_subdirectory(misc)
add_subdirectory(modernize)		add_subdirectory(modernize)
if(CLANG_ENABLE_STATIC_ANALYZER)		if(CLANG_ENABLE_STATIC_ANALYZER)
add_subdirectory(mpi)		add_subdirectory(mpi)
endif()		endif()
add_subdirectory(objc)		add_subdirectory(objc)
add_subdirectory(openmp)		add_subdirectory(openmp)
add_subdirectory(performance)		add_subdirectory(performance)
add_subdirectory(portability)		add_subdirectory(portability)
add_subdirectory(readability)		add_subdirectory(readability)
add_subdirectory(zircon)		add_subdirectory(zircon)
set(ALL_CLANG_TIDY_CHECKS		set(ALL_CLANG_TIDY_CHECKS
clangTidyAndroidModule		clangTidyAndroidModule
clangTidyAbseilModule		clangTidyAbseilModule
		clangTidyAlteraModule
clangTidyBoostModule		clangTidyBoostModule
clangTidyBugproneModule		clangTidyBugproneModule
clangTidyCERTModule		clangTidyCERTModule
clangTidyCppCoreGuidelinesModule		clangTidyCppCoreGuidelinesModule
clangTidyDarwinModule		clangTidyDarwinModule
clangTidyFuchsiaModule		clangTidyFuchsiaModule
clangTidyGoogleModule		clangTidyGoogleModule
clangTidyHICPPModule		clangTidyHICPPModule
Show All 21 Lines

clang-tidy/ClangTidyForceLinker.h

	Show All 19 Lines
	static int LLVM_ATTRIBUTE_UNUSED CERTModuleAnchorDestination =			static int LLVM_ATTRIBUTE_UNUSED CERTModuleAnchorDestination =
	CERTModuleAnchorSource;			CERTModuleAnchorSource;

	// This anchor is used to force the linker to link the AbseilModule.			// This anchor is used to force the linker to link the AbseilModule.
	extern volatile int AbseilModuleAnchorSource;			extern volatile int AbseilModuleAnchorSource;
	static int LLVM_ATTRIBUTE_UNUSED AbseilModuleAnchorDestination =			static int LLVM_ATTRIBUTE_UNUSED AbseilModuleAnchorDestination =
	AbseilModuleAnchorSource;			AbseilModuleAnchorSource;

				// This anchor is used to force the linker to link the AlteraModule.
				extern volatile int AlteraModuleAnchorSource;
				static int LLVM_ATTRIBUTE_UNUSED AlteraModuleAnchorDestination =
				AlteraModuleAnchorSource;

	// This anchor is used to force the linker to link the BoostModule.			// This anchor is used to force the linker to link the BoostModule.
	extern volatile int BoostModuleAnchorSource;			extern volatile int BoostModuleAnchorSource;
	static int LLVM_ATTRIBUTE_UNUSED BoostModuleAnchorDestination =			static int LLVM_ATTRIBUTE_UNUSED BoostModuleAnchorDestination =
	BoostModuleAnchorSource;			BoostModuleAnchorSource;

	// This anchor is used to force the linker to link the BugproneModule.			// This anchor is used to force the linker to link the BugproneModule.
	extern volatile int BugproneModuleAnchorSource;			extern volatile int BugproneModuleAnchorSource;
	static int LLVM_ATTRIBUTE_UNUSED BugproneModuleAnchorDestination =			static int LLVM_ATTRIBUTE_UNUSED BugproneModuleAnchorDestination =
	▲ Show 20 Lines • Show All 94 Lines • Show Last 20 Lines

clang-tidy/altera/AlteraTidyModule.cpp

This file was added.

				//===--- AlteraTidyModule.cpp - clang-tidy --------------------------------===//
				//
				// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
				// See https://llvm.org/LICENSE.txt for license information.
				// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
				//
				//===----------------------------------------------------------------------===//

				#include "../ClangTidy.h"
				#include "../ClangTidyModule.h"
				#include "../ClangTidyModuleRegistry.h"
				#include "UnrollLoopsCheck.h"

				using namespace clang::ast_matchers;

				namespace clang {
				namespace tidy {
				namespace altera {

				class AlteraModule : public ClangTidyModule {
				public:
				void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
				CheckFactories.registerCheck<UnrollLoopsCheck>(
				"altera-unroll-loops");
				}
				};

				} // namespace altera

				// Register the AlteraTidyModule using this statically initialized variable.
				static ClangTidyModuleRegistry::Add<altera::AlteraModule>
				X("altera-module", "Adds Altera FPGA OpenCL lint checks.");

				// This anchor is used to force the linker to link in the generated object file
				// and thus register the AlteraModule.
				volatile int AlteraModuleAnchorSource = 0;

				} // namespace tidy
				} // namespace clang

clang-tidy/altera/CMakeLists.txt

This file was added.

				set(LLVM_LINK_COMPONENTS support)

				add_clang_library(clangTidyAlteraModule
				AlteraTidyModule.cpp
				UnrollLoopsCheck.cpp

				LINK_LIBS
				clangAnalysis
				clangAST
				clangASTMatchers
				clangBasic
				clangLex
				clangTidy
				clangTidyUtils
				)

clang-tidy/altera/UnrollLoopsCheck.h

This file was added.

				//===--- UnrollLoopsCheck.h - clang-tidy ------------------------- C++ --===//
				//
				// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
				// See https://llvm.org/LICENSE.txt for license information.
				// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
				//
				//===----------------------------------------------------------------------===//

				#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ALTERA_UNROLL_LOOPS_CHECK_H
				#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ALTERA_UNROLL_LOOPS_CHECK_H

				#include "../ClangTidy.h"

				namespace clang {
				namespace tidy {
				namespace altera {

				/// Finds for, while and do..while loop statements that have not been unrolled.
				/// Unrolling these loops could increase the performance of the OpenCL kernel.
				/// Also attempts to find for, while and do..while loops that have been fully
				/// unrolled, but either have unknown bounds or a large number of iterations.
				/// The compiler will not unroll these loops, so partial unrolling is
				/// recommended in these cases.
				///
				/// For the user-facing documentation see:
				/// http://clang.llvm.org/extra/clang-tidy/checks/altera-unroll-loops.html
				class UnrollLoopsCheck : public ClangTidyCheck {
				const unsigned MaxLoopIterations;

				public:
				UnrollLoopsCheck(StringRef Name, ClangTidyContext *Context)
				: ClangTidyCheck(Name, Context),
				MaxLoopIterations(Options.get("MaxLoopIterations", 100U)) {}
				void registerMatchers(ast_matchers::MatchFinder *Finder) override;
				void check(const ast_matchers::MatchFinder::MatchResult &Result) override;

				private:
				/// The kind of unrolling, if any, applied to a given loop.
				enum UnrollType {
				// This loop has no #pragma unroll directive associated with it.
				NotUnrolled,
				// This loop has a #pragma unroll directive associated with it.
				FullyUnrolled,
				// This loop has a #pragma unroll <num> directive associated with it.
				PartiallyUnrolled
				};
				/// Returns true if the given loop statement has a large number of iterations,
				/// as determined by the integer value in the loop's condition expression,
				/// if one exists.
				bool hasLargeNumIterations(const Stmt Statement, const ASTContext Context);
				/// Checks one hand side of the binary operator to ascertain if the upper
				/// bound on the number of loops is greater than max_loop_iterations or not.
				/// If the expression is not evaluatable or not an integer, returns false.
				bool exprHasLargeNumIterations(const Expr *Expression,
				const ASTContext *Context);
				/// Returns the type of unrolling, if any, associated with the given
				/// statement.
				enum UnrollType unrollType(const Stmt Statement, ASTContext Context);
				/// Returns the condition expression within a given for statement. If there is
				/// none, or if the Statement is not a loop, then returns a NULL pointer.
				const Expr getCondExpr(const Stmt Statement);
				/// Returns True if the loop statement has known bounds.
				bool hasKnownBounds(const Stmt Statement, const ASTContext Context);
				void storeOptions(ClangTidyOptions::OptionMap &Opts);
				};

				} // namespace altera
				} // namespace tidy
				} // namespace clang

				#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ALTERA_UNROLL_LOOPS_CHECK_H

clang-tidy/altera/UnrollLoopsCheck.cpp

This file was added.

				//===--- UnrollLoopsCheck.cpp - clang-tidy --------------------------------===//
				//
				// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
				// See https://llvm.org/LICENSE.txt for license information.
				// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
				//
				//===----------------------------------------------------------------------===//

				#include "UnrollLoopsCheck.h"
				#include "clang/AST/ASTContext.h"
				#include "clang/AST/ASTTypeTraits.h"
				#include "clang/ASTMatchers/ASTMatchFinder.h"

				using namespace clang::ast_matchers;

				namespace clang {
				namespace tidy {
				namespace altera {

				void UnrollLoopsCheck::registerMatchers(MatchFinder *Finder) {
				const auto ANYLOOP = anyOf(forStmt(), whileStmt(), doStmt());
				Finder->addMatcher(stmt(allOf(ANYLOOP, // Match all loop types,
				unless(hasDescendant(forStmt())),
				unless(hasDescendant(whileStmt())),
				unless(hasDescendant(doStmt()))))
				.bind("loop"),
				this);
				}

				void UnrollLoopsCheck::check(const MatchFinder::MatchResult &Result) {
				const Stmt *MatchedLoop = Result.Nodes.getNodeAs<Stmt>("loop");
				const ASTContext *Context = Result.Context;
				Eugene.ZelenkoUnsubmitted Done Reply Inline Actions Could be const auto , because type is spelled in same sentence. See modernize-use-auto. Eugene.Zelenko:* Could be const auto *, because type is spelled in same sentence. See modernize-use-auto.
				UnrollType Unroll = unrollType(MatchedLoop, Result.Context);
				if (Unroll == NotUnrolled) {
				diag(MatchedLoop->getBeginLoc(),
				"The performance of the kernel could be improved by unrolling this "
				"loop with a #pragma unroll directive");
				return;
				}
				if (Unroll == PartiallyUnrolled) {
				return;
				}
				if (Unroll == FullyUnrolled) {
				if (hasKnownBounds(MatchedLoop, Context)) {
				if (hasLargeNumIterations(MatchedLoop, Context)) {
				diag(MatchedLoop->getBeginLoc(),
				"This loop likely has a large number of iterations and thus "
				"cannot be fully unrolled. To partially unroll this loop, use the "
				"#pragma unroll <num> directive");
				return;
				}
				return;
				}
				diag(MatchedLoop->getBeginLoc(),
				"Full unrolling was requested, but loop bounds are not known. To "
				"partially unroll this loop, use the #pragma unroll <num> directive");
				}
				}

				enum UnrollLoopsCheck::UnrollType
				UnrollLoopsCheck::unrollType(const Stmt Statement, ASTContext Context) {
				const ASTContext::DynTypedNodeList Parents = Context->getParents(*Statement);
				for (const ast_type_traits::DynTypedNode &Parent: Parents) {
				const AttributedStmt *ParentStmt = Parent.get<AttributedStmt>();
				if (!ParentStmt) {
				continue;
				}
				for (const Attr* Attribute: ParentStmt->getAttrs()) {
				const LoopHintAttr *LoopHint;
				if ((LoopHint = static_cast<const LoopHintAttr *>(Attribute))) {
				Eugene.ZelenkoUnsubmitted Done Reply Inline Actions May be merge declaration with initialization and use const auto ? Eugene.Zelenko:* May be merge declaration with initialization and use const auto *?
				switch (LoopHint->getState()) {
				case LoopHintAttr::Numeric:
				return PartiallyUnrolled;
				case LoopHintAttr::Disable:
				return NotUnrolled;
				case LoopHintAttr::Full:
				return FullyUnrolled;
				case LoopHintAttr::Enable:
				return FullyUnrolled;
				default:
				return NotUnrolled;
				}
				}
				}
				}
				return NotUnrolled;
				}

				bool UnrollLoopsCheck::hasKnownBounds(const Stmt *Statement,
				const ASTContext *Context) {
				const Expr *Conditional = getCondExpr(Statement);
				if (!Conditional) {
				return false;
				}
				if (std::string(Conditional->getStmtClassName()).compare("BinaryOperator") ==
				0) {
				const BinaryOperator *BinaryOp =
				Eugene.ZelenkoUnsubmitted Done Reply Inline Actions Could be const auto , because type is spelled in same sentence. Eugene.Zelenko:* Could be const auto *, because type is spelled in same sentence.
				static_cast<const BinaryOperator *>(Conditional);
				const Expr *LHS = BinaryOp->getLHS();
				const Expr *RHS = BinaryOp->getRHS();
				if (LHS->isEvaluatable(Context) == RHS->isEvaluatable(Context)) {
				return false; // Both sides are value dependent or constant, so loop
				// bounds are not known.
				}
				return true; // At least 1 side isn't value dependent, so we know the loop
				// bounds.
				}
				return false; // If it's not a binary operator, we don't know the loop bounds.
				}

				const Expr UnrollLoopsCheck::getCondExpr(const Stmt Statement) {
				const Expr *Conditional;
				if (isa<ForStmt>(Statement)) {
				const ForStmt ForLoop = static_cast<const ForStmt >(Statement);
				Eugene.ZelenkoUnsubmitted Done Reply Inline Actions Could be const auto , because type is spelled in same sentence. Eugene.Zelenko:* Could be const auto *, because type is spelled in same sentence.
				Conditional = ForLoop->getCond();
				}
				if (isa<WhileStmt>(Statement)) {
				const WhileStmt WhileLoop = static_cast<const WhileStmt >(Statement);
				Eugene.ZelenkoUnsubmitted Done Reply Inline Actions Could be const auto , because type is spelled in same sentence. Eugene.Zelenko:* Could be const auto *, because type is spelled in same sentence.
				Conditional = WhileLoop->getCond();
				}
				if (isa<DoStmt>(Statement)) {
				const DoStmt DoWhileLoop = static_cast<const DoStmt >(Statement);
				Eugene.ZelenkoUnsubmitted Done Reply Inline Actions Could be const auto , because type is spelled in same sentence. Eugene.Zelenko:* Could be const auto *, because type is spelled in same sentence.
				Conditional = DoWhileLoop->getCond();
				}
				return Conditional;
				}

				bool UnrollLoopsCheck::hasLargeNumIterations(const Stmt *Statement,
				const ASTContext *Context) {
				const Expr *Conditional = getCondExpr(Statement);
				if (!Conditional) {
				return false;
				}
				if (isa<BinaryOperator>(Conditional)) {
				// if (std::string(Conditional->getStmtClassName()).compare("BinaryOperator") ==
				Eugene.ZelenkoUnsubmitted Done Reply Inline Actions Could be const auto , because type is spelled in same sentence. Eugene.Zelenko:* Could be const auto *, because type is spelled in same sentence.
				// 0) {
				const BinaryOperator *BinaryOp =
				static_cast<const BinaryOperator *>(Conditional);
				const Expr *LHS = BinaryOp->getLHS();
				const Expr *RHS = BinaryOp->getRHS();
				Expr::EvalResult result;
				if (LHS->isEvaluatable(Context) && !(RHS->isEvaluatable(Context))) {
				return exprHasLargeNumIterations(LHS, Context);
				}
				if (RHS->isEvaluatable(Context) && !(LHS->isEvaluatable(Context))) {
				return exprHasLargeNumIterations(RHS, Context);
				}
				}
				return false; // Cannot check number of iteration, return false to be safe.
				}

				bool UnrollLoopsCheck::exprHasLargeNumIterations(const Expr *Expression,
				const ASTContext *Context) {
				Expr::EvalResult Result;
				if (Expression->EvaluateAsRValue(Result, *Context)) {
				if (!(Result.Val.isInt())) {
				return false; // Cannot check number of iterations, return false to be
				// safe.
				}
				if (Result.Val.getInt() > MaxLoopIterations) {
				return true; // Assumes values go from 0 to Val in increments of 1.
				}
				return false; // Number of iterations likely less than MaxLoopIterations.
				}
				// Cannot evaluate Expression as an r-value, so cannot check number of
				// iterations.
				return false;
				}

				void UnrollLoopsCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
				Options.store(Opts, "MaxLoopIterations", MaxLoopIterations);
				}

				} // namespace altera
				} // namespace tidy
				} // namespace clang

docs/ReleaseNotes.rst

	Show First 20 Lines • Show All 61 Lines • ▼ Show 20 Lines
	Improvements to clang-rename			Improvements to clang-rename
	----------------------------			----------------------------

	The improvements are...			The improvements are...

	Improvements to clang-tidy			Improvements to clang-tidy
	--------------------------			--------------------------

				- New :doc:`altera <clang-tidy/modules/altera>` module.

				Includes checks related to OpenCL for FPGA coding guidelines, based on the
				`Altera SDK for OpenCL: Best Practices Guide
				<https://www.altera.com/en_US/pdfs/literature/hb/opencl-sdk/aocl_optimization_guide.pdf>`_.

				- New :doc:`altera-unroll-loops
				<clang-tidy/checks/altera-unroll-loops>` check.

				Finds inner loops that have not been unrolled, as well as fully unrolled loops
				Eugene.ZelenkoUnsubmitted Done Reply Inline Actions Please synchronize with first statement in documentation. Eugene.Zelenko: Please synchronize with first statement in documentation.
				with unknown loops bounds or a large number of iterations.

	- New :doc:`bugprone-dynamic-static-initializers			- New :doc:`bugprone-dynamic-static-initializers
	<clang-tidy/checks/bugprone-dynamic-static-initializers>` check.			<clang-tidy/checks/bugprone-dynamic-static-initializers>` check.

	Finds instances where variables with static storage are initialized			Finds instances where variables with static storage are initialized
	dynamically in header files.			dynamically in header files.

	- New :doc:`bugprone-infinite-loop			- New :doc:`bugprone-infinite-loop
	<clang-tidy/checks/bugprone-infinite-loop>` check.			<clang-tidy/checks/bugprone-infinite-loop>` check.
	▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

docs/clang-tidy/checks/altera-unroll-loops.rst

This file was added.

				.. title:: clang-tidy - altera-unroll-loops

				altera-unroll-loops
				=================

				Checks for inner loops that have not been unrolled. Unrolling
				these loops could improve the performance of OpenCL kernels.

				Also checks for fully unrolled loops with a large number of
				iterations, or unknown loop bounds. These loops cannot be fully
				unrolled, and should be partially unrolled.

				Based on the `Altera SDK for OpenCL: Best Practices Guide
				<https://www.altera.com/en_US/pdfs/literature/hb/opencl-sdk/aocl_optimization_guide.pdf>`_.

				.. code-block:: c++

				for (int i = 0; i < 10; i++) { // ok: outer loops should not be unrolled
				int j = 0;
				do { // warning: this inner do..while loop should be unrolled
				j++;
				} while (j < 15);

				int k = 0;
				#pragma unroll
				while (k < 20) { // ok: this inner loop is already unrolled
				k++;
				}
				}

				#pragma unroll
				for (int i = 0; i < 1000; ++i) { // warning: this loop is too large and cannot be fully unrolled
				printf("%d", i);
				}

				#pragma unroll 5
				for (int i = 0; i < 1000; ++i) { // ok: this loop is large, but is partially unrolled
				printf("%d", i);
				}

				std::vector<int> someVector (100, 0);
				int i = 0;
				#pragma unroll
				while (i < someVector.size()) { // warning: this loop has unknown bounds and cannot be fully unrolled
				someVector[i]++;
				}

				#pragma unroll
				while (true) { // warning: this loop has unknown bounds and cannot be fully unrolled
				printf("In loop");
				}

				#pragma unroll
				while (i < 5) { // warning: this loop has unknown bounds and cannot be fully unrolled
				printf("In loop");
				}

				#pragma unroll 5
				while (i < someVector.size()) { // ok: this loop has unknown bounds, but is partially unrolled
				someVector[i]++;
				}

				Options
				-------

				.. option:: MaxLoopIterations

				Defines the maximum number of loop iterations that a fully unrolled loop
				can have.
				Eugene.ZelenkoUnsubmitted Done Reply Inline Actions Please document default value. Eugene.Zelenko: Please document default value.

				In practice, this refers to the integer value of the upper bound
				within the loop statement's condition expression.

docs/clang-tidy/checks/list.rst

Show All 16 Lines	.. toctree::
abseil-no-internal-dependencies		abseil-no-internal-dependencies
abseil-no-namespace		abseil-no-namespace
abseil-redundant-strcat-calls		abseil-redundant-strcat-calls
abseil-str-cat-append		abseil-str-cat-append
abseil-string-find-startswith		abseil-string-find-startswith
abseil-time-comparison		abseil-time-comparison
abseil-time-subtraction		abseil-time-subtraction
abseil-upgrade-duration-conversions		abseil-upgrade-duration-conversions
		altera-unroll-loops
android-cloexec-accept		android-cloexec-accept
android-cloexec-accept4		android-cloexec-accept4
android-cloexec-creat		android-cloexec-creat
android-cloexec-dup		android-cloexec-dup
android-cloexec-epoll-create		android-cloexec-epoll-create
android-cloexec-epoll-create1		android-cloexec-epoll-create1
android-cloexec-fopen		android-cloexec-fopen
android-cloexec-inotify-init		android-cloexec-inotify-init
▲ Show 20 Lines • Show All 351 Lines • Show Last 20 Lines

docs/clang-tidy/index.rst

	Show First 20 Lines • Show All 53 Lines • ▼ Show 20 Lines

	There are currently the following groups of checks:			There are currently the following groups of checks:

	====================== =========================================================			====================== =========================================================
	Name prefix Description			Name prefix Description
	====================== =========================================================			====================== =========================================================
	``abseil-`` Checks related to Abseil library.			``abseil-`` Checks related to Abseil library.
	``android-`` Checks related to Android.			``android-`` Checks related to Android.
				``altera-`` Checks related to OpenCL programming for FPGAs.
	``boost-`` Checks related to Boost library.			``boost-`` Checks related to Boost library.
	``bugprone-`` Checks that target bugprone code constructs.			``bugprone-`` Checks that target bugprone code constructs.
	``cert-`` Checks related to CERT Secure Coding Guidelines.			``cert-`` Checks related to CERT Secure Coding Guidelines.
	``cppcoreguidelines-`` Checks related to C++ Core Guidelines.			``cppcoreguidelines-`` Checks related to C++ Core Guidelines.
	``clang-analyzer-`` Clang Static Analyzer checks.			``clang-analyzer-`` Clang Static Analyzer checks.
	``fuchsia-`` Checks related to Fuchsia coding conventions.			``fuchsia-`` Checks related to Fuchsia coding conventions.
	``google-`` Checks related to Google coding conventions.			``google-`` Checks related to Google coding conventions.
	``hicpp-`` Checks related to High Integrity C++ Coding Standard.			``hicpp-`` Checks related to High Integrity C++ Coding Standard.
	▲ Show 20 Lines • Show All 269 Lines • Show Last 20 Lines

test/clang-tidy/checkers/altera-unroll-loops.cpp

This file was added.

				// RUN: %check_clang_tidy %s altera-unroll-loops %t -- -config="{CheckOptions: [{key: "altera-unroll-loops.MaxLoopIterations", value: 50}]}" -header-filter=.* "--" --include opencl-c.h -cl-std=CL1.2 -c

				// Inner loops should be unrolled
				__kernel void nested_simple_loops(__global int *A) {
				for (int i = 0; i < 1000; ++i) {
				for (int j = 0; j < 2000; ++j) {
				// CHECK-MESSAGES: :[[@LINE-1]]:9: warning: The performance of the kernel could be improved by unrolling this loop with a #pragma unroll directive [altera-unroll-loops]
				A[0] += i + j;
				}
				}

				for (int i = 0; i < 1000; ++i) {
				int j = 0;
				while (j < 2000) {
				// CHECK-MESSAGES: :[[@LINE-1]]:9: warning: The performance of the kernel could be improved by unrolling this loop with a #pragma unroll directive [altera-unroll-loops]
				A[1] += i + j;
				j++;
				}
				}

				for (int i = 0; i < 1000; ++i) {
				int j = 0;
				do {
				// CHECK-MESSAGES: :[[@LINE-1]]:9: warning: The performance of the kernel could be improved by unrolling this loop with a #pragma unroll directive [altera-unroll-loops]
				A[2] += i + j;
				j++;
				} while (j < 2000);
				}

				int i = 0;
				while (i < 1000) {
				for (int j = 0; j < 2000; ++j) {
				// CHECK-MESSAGES: :[[@LINE-1]]:9: warning: The performance of the kernel could be improved by unrolling this loop with a #pragma unroll directive [altera-unroll-loops]
				A[3] += i + j;
				}
				i++;
				}

				i = 0;
				while (i < 1000) {
				int j = 0;
				while (j < 2000) {
				// CHECK-MESSAGES: :[[@LINE-1]]:9: warning: The performance of the kernel could be improved by unrolling this loop with a #pragma unroll directive [altera-unroll-loops]
				A[4] += i + j;
				j++;
				}
				i++;
				}

				i = 0;
				while (i < 1000) {
				int j = 0;
				do {
				// CHECK-MESSAGES: :[[@LINE-1]]:9: warning: The performance of the kernel could be improved by unrolling this loop with a #pragma unroll directive [altera-unroll-loops]
				A[5] += i + j;
				j++;
				} while (j < 2000);
				i++;
				}

				i = 0;
				do {
				for (int j = 0; j < 2000; ++j) {
				// CHECK-MESSAGES: :[[@LINE-1]]:9: warning: The performance of the kernel could be improved by unrolling this loop with a #pragma unroll directive [altera-unroll-loops]
				A[6] += i + j;
				}
				i++;
				} while (i < 1000);

				i = 0;
				do {
				int j = 0;
				while (j < 2000) {
				// CHECK-MESSAGES: :[[@LINE-1]]:9: warning: The performance of the kernel could be improved by unrolling this loop with a #pragma unroll directive [altera-unroll-loops]
				A[7] += i + j;
				j++;
				}
				i++;
				} while (i < 1000);

				i = 0;
				do {
				int j = 0;
				do {
				// CHECK-MESSAGES: :[[@LINE-1]]:9: warning: The performance of the kernel could be improved by unrolling this loop with a #pragma unroll directive [altera-unroll-loops]
				A[8] += i + j;
				j++;
				} while (j < 2000);
				i++;
				} while (i < 1000);

				for (int i = 0; i < 100; ++i) {
				// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: The performance of the kernel could be improved by unrolling this loop with a #pragma unroll directive [altera-unroll-loops]
				printf("Hello");
				}

				i = 0;
				while (i < 100) {
				// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: The performance of the kernel could be improved by unrolling this loop with a #pragma unroll directive [altera-unroll-loops]
				i++;
				}

				i = 0;
				do {
				// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: The performance of the kernel could be improved by unrolling this loop with a #pragma unroll directive [altera-unroll-loops]
				i++;
				} while (i < 100);
				}

				// These loops are all correctly unrolled
				__kernel void unrolled_nested_simple_loops(__global int *A) {
				for (int i = 0; i < 1000; ++i) {
				#pragma unroll
				for (int j = 0; j < 50; ++j) {
				A[0] += i + j;
				}
				}

				for (int i = 0; i < 1000; ++i) {
				int j = 0;
				#pragma unroll
				while (j < 50) {
				A[1] += i + j;
				j++;
				}
				}

				for (int i = 0; i < 1000; ++i) {
				int j = 0;
				#pragma unroll
				do {
				A[2] += i + j;
				j++;
				} while (j < 50);
				}

				int i = 0;
				while (i < 1000) {
				#pragma unroll
				for (int j = 0; j < 50; ++j) {
				A[3] += i + j;
				}
				i++;
				}

				i = 0;
				while (i < 1000) {
				int j = 0;
				#pragma unroll
				while (50 > j) {
				A[4] += i + j;
				j++;
				}
				i++;
				}

				i = 0;
				while (1000 > i) {
				int j = 0;
				#pragma unroll
				do {
				A[5] += i + j;
				j++;
				} while (j < 50);
				i++;
				}

				i = 0;
				do {
				#pragma unroll
				for (int j = 0; j < 50; ++j) {
				A[6] += i + j;
				}
				i++;
				} while (i < 1000);

				i = 0;
				do {
				int j = 0;
				#pragma unroll
				while (j < 50) {
				A[7] += i + j;
				j++;
				}
				i++;
				} while (i < 1000);

				i = 0;
				do {
				int j = 0;
				#pragma unroll
				do {
				A[8] += i + j;
				j++;
				} while (j < 50);
				i++;
				} while (i < 1000);
				}

				__kernel void unrolled_nested_simple_loops_large_num_iterations(__global int *A) {
				for (int i = 0; i < 1000; ++i) {
				#pragma unroll
				for (int j = 0; j < 51; ++j) {
				// CHECK-MESSAGES: :[[@LINE-1]]:9: warning: This loop likely has a large number of iterations and thus cannot be fully unrolled. To partially unroll this loop, use the #pragma unroll <num> directive [altera-unroll-loops]
				A[0] += i + j;
				}
				}

				for (int i = 0; i < 1000; ++i) {
				int j = 0;
				#pragma unroll
				while (j < 51) {
				// CHECK-MESSAGES: :[[@LINE-1]]:9: warning: This loop likely has a large number of iterations and thus cannot be fully unrolled. To partially unroll this loop, use the #pragma unroll <num> directive [altera-unroll-loops]
				A[1] += i + j;
				j++;
				}
				}

				for (int i = 0; i < 1000; ++i) {
				int j = 0;
				#pragma unroll
				do {
				// CHECK-MESSAGES: :[[@LINE-1]]:9: warning: This loop likely has a large number of iterations and thus cannot be fully unrolled. To partially unroll this loop, use the #pragma unroll <num> directive [altera-unroll-loops]
				A[2] += i + j;
				j++;
				} while (j < 51);
				}

				int i = 0;
				while (i < 1000) {
				#pragma unroll
				for (int j = 0; j < 51; ++j) {
				// CHECK-MESSAGES: :[[@LINE-1]]:9: warning: This loop likely has a large number of iterations and thus cannot be fully unrolled. To partially unroll this loop, use the #pragma unroll <num> directive [altera-unroll-loops]
				A[3] += i + j;
				}
				i++;
				}

				i = 0;
				while (i < 1000) {
				int j = 0;
				#pragma unroll
				while (51 > j) {
				// CHECK-MESSAGES: :[[@LINE-1]]:9: warning: This loop likely has a large number of iterations and thus cannot be fully unrolled. To partially unroll this loop, use the #pragma unroll <num> directive [altera-unroll-loops]
				A[4] += i + j;
				j++;
				}
				i++;
				}

				i = 0;
				while (1000 > i) {
				int j = 0;
				#pragma unroll
				do {
				// CHECK-MESSAGES: :[[@LINE-1]]:9: warning: This loop likely has a large number of iterations and thus cannot be fully unrolled. To partially unroll this loop, use the #pragma unroll <num> directive [altera-unroll-loops]
				A[5] += i + j;
				j++;
				} while (j < 51);
				i++;
				}

				i = 0;
				do {
				#pragma unroll
				for (int j = 0; j < 51; ++j) {
				// CHECK-MESSAGES: :[[@LINE-1]]:9: warning: This loop likely has a large number of iterations and thus cannot be fully unrolled. To partially unroll this loop, use the #pragma unroll <num> directive [altera-unroll-loops]
				A[6] += i + j;
				}
				i++;
				} while (i < 1000);

				i = 0;
				do {
				int j = 0;
				#pragma unroll
				while (j < 51) {
				// CHECK-MESSAGES: :[[@LINE-1]]:9: warning: This loop likely has a large number of iterations and thus cannot be fully unrolled. To partially unroll this loop, use the #pragma unroll <num> directive [altera-unroll-loops]
				A[7] += i + j;
				j++;
				}
				i++;
				} while (i < 1000);

				i = 0;
				do {
				int j = 0;
				#pragma unroll
				do {
				// CHECK-MESSAGES: :[[@LINE-1]]:9: warning: This loop likely has a large number of iterations and thus cannot be fully unrolled. To partially unroll this loop, use the #pragma unroll <num> directive [altera-unroll-loops]
				A[8] += i + j;
				j++;
				} while (j < 51);
				i++;
				} while (i < 1000);
				}

				__kernel void fully_unrolled_unknown_bounds(int vectorSize) {
				int someVector[101];

				// There is no loop condition
				#pragma unroll
				for (;;) {
				// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: Full unrolling was requested, but loop bounds are not known. To partially unroll this loop, use the #pragma unroll <num> directive [altera-unroll-loops]
				printf("%d", someVector);
				}

				// Infinite loop
				#pragma unroll
				while (true) {
				// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: Full unrolling was requested, but loop bounds are not known. To partially unroll this loop, use the #pragma unroll <num> directive [altera-unroll-loops]
				printf("%d", someVector);
				}

				#pragma unroll
				do {
				// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: Full unrolling was requested, but loop bounds are not known. To partially unroll this loop, use the #pragma unroll <num> directive [altera-unroll-loops]
				printf("%d", someVector);
				} while (true);

				#pragma unroll
				while (1 < 5) {
				// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: Full unrolling was requested, but loop bounds are not known. To partially unroll this loop, use the #pragma unroll <num> directive [altera-unroll-loops]
				printf("%d", someVector);
				}

				#pragma unroll
				do {
				// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: Full unrolling was requested, but loop bounds are not known. To partially unroll this loop, use the #pragma unroll <num> directive [altera-unroll-loops]
				printf("%d", someVector);
				} while (1 < 5);

				#pragma unroll
				for (int i = 0; 1 < 5; ++i) {
				// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: Full unrolling was requested, but loop bounds are not known. To partially unroll this loop, use the #pragma unroll <num> directive [altera-unroll-loops]
				someVector[i]++;
				}

				// Both sides are value-dependent
				#pragma unroll
				for (int i = 0; i < vectorSize; ++i) {
				// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: Full unrolling was requested, but loop bounds are not known. To partially unroll this loop, use the #pragma unroll <num> directive [altera-unroll-loops]
				printf("%d", someVector);
				}

				int j = 0;
				#pragma unroll
				while (j < vectorSize) {
				// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: Full unrolling was requested, but loop bounds are not known. To partially unroll this loop, use the #pragma unroll <num> directive [altera-unroll-loops]
				printf("%d", someVector);
				}

				#pragma unroll
				do {
				// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: Full unrolling was requested, but loop bounds are not known. To partially unroll this loop, use the #pragma unroll <num> directive [altera-unroll-loops]
				printf("%d", someVector);
				} while (j < vectorSize);
				}
				// There are no fix-its for this check

This is an archive of the discontinued LLVM Phabricator instance.

[clang-tidy] new altera unroll loops check
ClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents

Diff 236269

clang-tidy/CMakeLists.txt

clang-tidy/ClangTidyForceLinker.h

clang-tidy/altera/AlteraTidyModule.cpp

clang-tidy/altera/CMakeLists.txt

clang-tidy/altera/UnrollLoopsCheck.h

clang-tidy/altera/UnrollLoopsCheck.cpp

docs/ReleaseNotes.rst

docs/clang-tidy/checks/altera-unroll-loops.rst

docs/clang-tidy/checks/list.rst

docs/clang-tidy/index.rst

test/clang-tidy/checkers/altera-unroll-loops.cpp

This is an archive of the discontinued LLVM Phabricator instance.

[clang-tidy] new altera unroll loops checkClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents

Diff 236269

clang-tidy/CMakeLists.txt

clang-tidy/ClangTidyForceLinker.h

clang-tidy/altera/AlteraTidyModule.cpp

clang-tidy/altera/CMakeLists.txt

clang-tidy/altera/UnrollLoopsCheck.h

clang-tidy/altera/UnrollLoopsCheck.cpp

docs/ReleaseNotes.rst

docs/clang-tidy/checks/altera-unroll-loops.rst

docs/clang-tidy/checks/list.rst

docs/clang-tidy/index.rst

test/clang-tidy/checkers/altera-unroll-loops.cpp

[clang-tidy] new altera unroll loops check
ClosedPublic