This is an archive of the discontinued LLVM Phabricator instance.

Differential D127684

[NFC] Use `https` instead of `http` in the `LLVM.org` URLs
AbandonedPublic

Authored by sunshaoce on Jun 13 2022, 12:45 PM.

Details

Reviewers
deadalnix
bollu
JDevlieghere
lebedev.ri
ldionne
jhenderson
aartbik
MaskRay
sscalpone
ftynse
aaron.ballman
rafauler
Amir
maksfb
jdoerfert
sstefan1
nicolasvasilache
Group Reviewers
Restricted Project
Restricted Project
Restricted Project

Diff Detail

Event Timeline

sunshaoce created this revision.Jun 13 2022, 12:45 PM
Herald added a reviewer: deadalnix. · View Herald TranscriptJun 13 2022, 12:46 PM
Herald added a reviewer: bollu. · View Herald Transcript
Herald added a reviewer: JDevlieghere. · View Herald Transcript
Herald added a reviewer: lebedev.ri. · View Herald Transcript
Herald added a reviewer: lebedev.ri. · View Herald Transcript
Herald added a reviewer: ldionne. · View Herald Transcript
Herald added a reviewer: jhenderson. · View Herald Transcript
Herald added a reviewer: lebedev.ri. · View Herald Transcript
Herald added a reviewer: aartbik. · View Herald Transcript
Herald added a reviewer: MaskRay. · View Herald Transcript
Herald added a reviewer: sscalpone. · View Herald Transcript
Herald added a reviewer: ftynse. · View Herald Transcript
Herald added a reviewer: aaron.ballman. · View Herald Transcript
Herald added a reviewer: aartbik. · View Herald Transcript
Herald added a reviewer: lebedev.ri. · View Herald Transcript
Herald added a reviewer: lebedev.ri. · View Herald Transcript
Herald added a reviewer: rafauler. · View Herald Transcript
Herald added a reviewer: Amir. · View Herald Transcript
Herald added a reviewer: maksfb. · View Herald Transcript
Herald added projects: Restricted Project, Restricted Project, Restricted Project, Restricted Project. · View Herald Transcript
Herald added a reviewer: Restricted Project. · View Herald Transcript
Herald added subscribers: libc-commits, libcxx-commits, jsji and 100 others. · View Herald Transcript
sunshaoce requested review of this revision.Jun 13 2022, 12:46 PM
Herald added a reviewer: jdoerfert. · View Herald TranscriptJun 13 2022, 12:46 PM
Herald added a reviewer: jdoerfert. · View Herald Transcript
Herald added a reviewer: sstefan1. · View Herald Transcript
Herald added a reviewer: nicolasvasilache. · View Herald Transcript
Herald added projects: Restricted Project, Restricted Project, Restricted Project, Restricted Project, Restricted Project, Restricted Project, Restricted Project, Restricted Project, Restricted Project. · View Herald Transcript
Herald added a reviewer: Restricted Project. · View Herald Transcript
Herald added a reviewer: Restricted Project. · View Herald Transcript
Herald added subscribers: cfe-commits, llvm-commits, openmp-commits and 10 others. · View Herald Transcript
philnik added a subscriber: philnik.Jun 13 2022, 12:49 PM

Could you do this on a per-project basis? More than 1000 files is way to much to sift through.

efriedma added a subscriber: efriedma.Jun 13 2022, 2:58 PM

A couple notes skimming the changes:

  1. If you're going to update URLs, please verify the new URLs are actually valid.
  2. Some of the "URLs" you're updating aren't actually URLs. For example, the xmlns attribute in SVG files must be the exact string written in the standard; changing it could make the file unreadable.
Harbormaster completed remote builds in B169537: Diff 436526.Jun 13 2022, 5:07 PM
martong removed a subscriber: martong.Jun 13 2022, 11:54 PM
sunshaoce updated this revision to Diff 436738.Jun 14 2022, 4:59 AM

Change to only modify *.llvm.org

sunshaoce retitled this revision from [NFC] Use `https` instead of `http` in the urls to [NFC] Use `https` instead of `http` in the `LLVM.org` URLs.Jun 14 2022, 5:00 AM
Harbormaster completed remote builds in B169687: Diff 436738.Jun 14 2022, 6:05 AM
JDevlieghere requested changes to this revision.Jun 14 2022, 8:40 AM

+1 on breaking this down per sub-project and creating separate patches for review.

I sampled the patch and about a quarter or so of the links I tried didn't work, even before the change. There's no point in generating churn by changing those, but there's also little value in keeping them around, and fixing them is beyond the scope of this patch. I'm inclined to say let's leave them be, but I'm curious to hear what others think about that.

This revision now requires changes to proceed.Jun 14 2022, 8:40 AM
sunshaoce abandoned this revision.Jun 14 2022, 8:46 AM

Thanks for comments!

Revision Contents

PathSize
.github/
2 lines
workflows/
2 lines
4 lines
bolt/
docs/
2 lines
clang-tools-extra/
2 lines
clang-include-fixer/
find-all-symbols/
tool/
2 lines
tool/
2 lines
2 lines
clang-tidy/
2 lines
2 lines
abseil/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
altera/
2 lines
2 lines
2 lines
2 lines
2 lines
android/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
boost/
2 lines
bugprone/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
cert/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
concurrency/
2 lines
2 lines
cppcoreguidelines/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
darwin/
2 lines
2 lines
fuchsia/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
google/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
hicpp/
2 lines
2 lines
2 lines
2 lines
linuxkernel/
2 lines
llvm/
2 lines
2 lines
2 lines
2 lines
llvmlibc/
2 lines
2 lines
2 lines
misc/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
modernize/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
mpi/
2 lines
2 lines
objc/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
openmp/
2 lines
2 lines
performance/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
portability/
2 lines
2 lines
2 lines
readability/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
tool/
2 lines
2 lines
2 lines
2 lines
zircon/
2 lines
docs/
clang-tidy/
2 lines
clang/
10 lines
docs/
2 lines
4 lines
2 lines
analyzer/
3 lines
user-docs/
10 lines
2 lines
include/
clang/
AST/
8 lines
Basic/
8 lines
Format/
2 lines
StaticAnalyzer/
Core/
PathSensitive/
2 lines
Tooling/
2 lines
lib/
Analysis/
2 lines
2 lines
Basic/
Targets/
2 lines
CodeGen/
2 lines
Format/
2 lines
2 lines
FrontendTool/
2 lines
StaticAnalyzer/
Checkers/
2 lines
2 lines
Tooling/
2 lines
test/
Analysis/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
5 lines
6 lines
2 lines
3 lines
2 lines
CodeGen/
2 lines
CodeGenCUDA/
2 lines
CodeGenCXX/
2 lines
2 lines
CodeGenObjCXX/
2 lines
CodeGenOpenCL/
2 lines
Driver/
2 lines
Frontend/
2 lines
Lexer/
2 lines
Misc/
3 lines
PCH/
2 lines
Parser/
2 lines
2 lines
Preprocessor/
2 lines
4 lines
Sema/
2 lines
2 lines
SemaCXX/
2 lines
3 lines
2 lines
2 lines
2 lines
98 lines
SemaObjC/
2 lines
tools/
clang-check/
2 lines
clang-format-vs/
ClangFormat/
4 lines
2 lines
clang-format/
2 lines
clang-fuzzer/
6 lines
scan-build-py/
2 lines
scan-build/
bin/
4 lines
unittests/
Format/
2 lines
2 lines
utils/
4 lines
www/
analyzer/
6 lines
demo/
2 lines
4 lines
14 lines
compiler-rt/
cmake/
Modules/
2 lines
lib/
asan/
2 lines
tests/
2 lines
2 lines
4 lines
fuzzer/
2 lines
memprof/
2 lines
sanitizer_common/
4 lines
tests/
2 lines
tsan/
rtl-old/
2 lines
2 lines
rtl/
2 lines
2 lines
test/
asan/
TestCases/
2 lines
cfi/
2 lines
lsan/
TestCases/
2 lines
sanitizer_common/
TestCases/
Linux/
2 lines
www/
6 lines
flang/
docs/
2 lines
libclc/
generic/
lib/
integer/
2 lines
libcxx/
2 lines
docs/
2 lines
DesignDocs/
6 lines
6 lines
test/
std/
input.output/
filesystems/
fs.op.funcs/
fs.op.create_directory/
2 lines
2 lines
strings/
basic.string/
string.capacity/
2 lines
libcxxabi/
fuzz/
2 lines
libunwind/
docs/
4 lines
lldb/
docs/
2 lines
resources/
12 lines
2 lines
use/
3 lines
examples/
scripting/
2 lines
test/
API/
commands/
command/
script/
2 lines
2 lines
expression/
ir-interpreter/
2 lines
functionalities/
process_group/
2 lines
lang/
c/
bitfields/
8 lines
modules/
2 lines
cpp/
class-template-parameter-pack/
2 lines
objc/
modules/
4 lines
python_api/
default-constructor/
2 lines
sbdata/
2 lines
test_runner/
test/
2 lines
tools/
lldb-vscode/
attach/
4 lines
launch/
2 lines
llvm/
2 lines
2 lines
docs/
10 lines
Frontend/
2 lines
2 lines
10 lines
4 lines
3 lines
3 lines
6 lines
2 lines
Proposals/
8 lines
78 lines
2 lines
2 lines
2 lines
include/
llvm-c/
4 lines
llvm/
Analysis/
4 lines
2 lines
Bitcode/
4 lines
ExecutionEngine/
2 lines
IR/
2 lines
2 lines
Support/
2 lines
Transforms/
IPO/
2 lines
Utils/
2 lines
Vectorize/
2 lines
lib/
Analysis/
2 lines
CodeGen/
2 lines
4 lines
2 lines
ExecutionEngine/
Orc/
2 lines
RuntimeDyld/
4 lines
ObjectYAML/
2 lines
Support/
2 lines
Target/
AMDGPU/
2 lines
2 lines
2 lines
ARM/
3 lines
PowerPC/
2 lines
4 lines
4 lines
Transforms/
IPO/
2 lines
Instrumentation/
2 lines
2 lines
Scalar/
2 lines
6 lines
Utils/
2 lines
Vectorize/
2 lines
6 lines
test/
Analysis/
MemorySSA/
2 lines
2 lines
Bitcode/
2 lines
CodeGen/
AArch64/
2 lines
AMDGPU/
2 lines
2 lines
2 lines
2 lines
ARM/
2 lines
AVR/
2 lines
Mips/
3 lines
SystemZ/
2 lines
X86/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
3 lines
2 lines
3 lines
3 lines
3 lines
2 lines
2 lines
5 lines
3 lines
4 lines
DebugInfo/
Generic/
2 lines
ExecutionEngine/
MCJIT/
remote/
2 lines
MC/
ARM/
2 lines
ELF/
2 lines
Transforms/
Attributor/
ArgumentPromotion/
2 lines
2 lines
2 lines
GVN/
2 lines
InstCombine/
3 lines
3 lines
3 lines
3 lines
2 lines
InstSimplify/
3 lines
2 lines
LICM/
2 lines
LoopRotate/
2 lines
LoopStrengthReduce/
2 lines
LoopVectorize/
2 lines
SeparateConstOffsetFromGEP/
NVPTX/
2 lines
SimplifyCFG/
2 lines
tools/
llvm-cov/
2 lines
unittests/
ADT/
2 lines
IR/
2 lines
utils/
2 lines
crosstool/
3 lines
emacs/
2 lines
2 lines
2 lines
gn/
build/
4 lines
docs/
2 lines
lint/
2 lines
lit/
3 lines
lit/
formats/
2 lines
4 lines
vim/
ftplugin/
2 lines
3 lines
2 lines
indent/
2 lines
syntax/
2 lines
2 lines
2 lines
2 lines
2 lines
mlir/
2 lines
docs/
Dialects/
2 lines
2 lines
2 lines
Rationale/
4 lines
24 lines
2 lines
2 lines
include/
mlir/
Dialect/
Vector/
IR/
6 lines
lib/
Transforms/
2 lines
test/
IR/
3 lines
openmp/
libomptarget/
2 lines
runtime/
src/
i18n/
2 lines
polly/
2 lines
docs/
13 lines
3 lines
lib/
External/
ppcg/
2 lines
Support/
2 lines
test/
CodeGen/
2 lines
2 lines
www/
4 lines
10 lines
2 lines
third-party/
benchmark/
2 lines
utils/
bazel/
llvm-project-overlay/
llvm/
2 lines

Diff 436738

.github/PULL_REQUEST_TEMPLATE.md

# **DO NOT FILE A PULL REQUEST** # **DO NOT FILE A PULL REQUEST**
This repository does not accept pull requests. Please follow http://llvm.org/docs/Contributing.html#how-to-submit-a-patch for contribution to LLVM. This repository does not accept pull requests. Please follow https://llvm.org/docs/Contributing.html#how-to-submit-a-patch for contribution to LLVM.
# **DO NOT FILE A PULL REQUEST** # **DO NOT FILE A PULL REQUEST**

.github/workflows/repo-lockdown.yml

Show All 10 Lines action:
runs-on: ubuntu-latest runs-on: ubuntu-latest
if: github.repository == 'llvm/llvm-project' if: github.repository == 'llvm/llvm-project'
steps: steps:
- uses: dessant/repo-lockdown@v2 - uses: dessant/repo-lockdown@v2
with: with:
process-only: 'prs' process-only: 'prs'
pr-comment: > pr-comment: >
This repository does not accept pull requests. This repository does not accept pull requests.
Please follow http://llvm.org/docs/Contributing.html#how-to-submit-a-patch for contribution to LLVM. Please follow https://llvm.org/docs/Contributing.html#how-to-submit-a-patch for contribution to LLVM.

README.md

Show All 17 Lines
Welcome to the LLVM project! Welcome to the LLVM project!
The LLVM project has multiple components. The core of the project is The LLVM project has multiple components. The core of the project is
itself called "LLVM". This contains all of the tools, libraries, and header itself called "LLVM". This contains all of the tools, libraries, and header
files needed to process intermediate representations and convert them into files needed to process intermediate representations and convert them into
object files. Tools include an assembler, disassembler, bitcode analyzer, and object files. Tools include an assembler, disassembler, bitcode analyzer, and
bitcode optimizer. It also contains basic regression tests. bitcode optimizer. It also contains basic regression tests.
C-like languages use the [Clang](http://clang.llvm.org/) frontend. This C-like languages use the [Clang](https://clang.llvm.org/) frontend. This
component compiles C, C++, Objective-C, and Objective-C++ code into LLVM bitcode component compiles C, C++, Objective-C, and Objective-C++ code into LLVM bitcode
-- and from there into object files, using LLVM. -- and from there into object files, using LLVM.
Other components include: Other components include:
the [libc++ C++ standard library](https://libcxx.llvm.org), the [libc++ C++ standard library](https://libcxx.llvm.org),
the [LLD linker](https://lld.llvm.org), and more. the [LLD linker](https://lld.llvm.org), and more.
### Getting the Source Code and Building LLVM ### Getting the Source Code and Building LLVM
The LLVM Getting Started documentation may be out of date. The [Clang The LLVM Getting Started documentation may be out of date. The [Clang
Getting Started](http://clang.llvm.org/get_started.html) page might have more Getting Started](https://clang.llvm.org/get_started.html) page might have more
accurate information. accurate information.
This is an example work-flow and configuration to get and build the LLVM source: This is an example work-flow and configuration to get and build the LLVM source:
1. Checkout LLVM (including related sub-projects like Clang): 1. Checkout LLVM (including related sub-projects like Clang):
* ``git clone https://github.com/llvm/llvm-project.git`` * ``git clone https://github.com/llvm/llvm-project.git``
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

bolt/docs/OptimizingClang.md

Show All 17 Lines
In this tutorial we will first build Clang with PGO and LTO, and then will show steps on how to In this tutorial we will first build Clang with PGO and LTO, and then will show steps on how to
apply BOLT optimizations to make Clang up to 15% faster. We will also analyze where apply BOLT optimizations to make Clang up to 15% faster. We will also analyze where
the compile-time performance gains are coming from, and verify that the speed-ups are the compile-time performance gains are coming from, and verify that the speed-ups are
sustainable while building other applications. sustainable while building other applications.
## Building Clang ## Building Clang
The process of getting Clang sources and performing the build is very similar to the The process of getting Clang sources and performing the build is very similar to the
one described at http://clang.llvm.org/get_started.html. For completeness, we provide the detailed steps one described at https://clang.llvm.org/get_started.html. For completeness, we provide the detailed steps
on how to obtain and build Clang in [Bootstrapping Clang-7 with PGO and LTO](#bootstrapping-clang-7-with-pgo-and-lto) section. on how to obtain and build Clang in [Bootstrapping Clang-7 with PGO and LTO](#bootstrapping-clang-7-with-pgo-and-lto) section.
The only difference from the standard Clang build is that we require the `-Wl,-q` flag to be present during The only difference from the standard Clang build is that we require the `-Wl,-q` flag to be present during
the final link. This option saves relocation metadata in the executable file, but does not affect the final link. This option saves relocation metadata in the executable file, but does not affect
the generated code in any way. the generated code in any way.
## Optimizing Clang with BOLT ## Optimizing Clang with BOLT
▲ Show 20 Lines • Show All 255 Lines • Show Last 20 Lines

clang-tools-extra/README.txt

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Clang Tools repository // Clang Tools repository
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
Welcome to the repository of extra Clang Tools. This repository holds tools Welcome to the repository of extra Clang Tools. This repository holds tools
that are developed as part of the LLVM compiler infrastructure project and the that are developed as part of the LLVM compiler infrastructure project and the
Clang frontend. These tools are kept in a separate "extra" repository to Clang frontend. These tools are kept in a separate "extra" repository to
allow lighter weight checkouts of the core Clang codebase. allow lighter weight checkouts of the core Clang codebase.
All discussion regarding Clang, Clang-based tools, and code in this repository All discussion regarding Clang, Clang-based tools, and code in this repository
should be held using the standard Clang forum: should be held using the standard Clang forum:
https://discourse.llvm.org/c/clang https://discourse.llvm.org/c/clang
Code review for this tree should take place on the standard Clang patch and Code review for this tree should take place on the standard Clang patch and
commit lists: commit lists:
http://lists.llvm.org/mailman/listinfo/cfe-commits https://lists.llvm.org/mailman/listinfo/cfe-commits
If you find a bug in these tools, please file it in the LLVM bug tracker: If you find a bug in these tools, please file it in the LLVM bug tracker:
https://github.com/llvm/llvm-project/issues/ https://github.com/llvm/llvm-project/issues/

clang-tools-extra/clang-include-fixer/find-all-symbols/tool/run-find-all-symbols.py

Show All 13 Lines
Runs find-all-symbols over all files in a compilation database. Runs find-all-symbols over all files in a compilation database.
Example invocations. Example invocations.
- Run find-all-symbols on all files in the current working directory. - Run find-all-symbols on all files in the current working directory.
run-find-all-symbols.py <source-file> run-find-all-symbols.py <source-file>
Compilation database setup: Compilation database setup:
http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html https://clang.llvm.org/docs/HowToSetupToolingForLLVM.html
""" """
import argparse import argparse
import json import json
import multiprocessing import multiprocessing
import os import os
import Queue import Queue
import shutil import shutil
▲ Show 20 Lines • Show All 96 Lines • Show Last 20 Lines

clang-tools-extra/clang-include-fixer/tool/clang-include-fixer.el

;;; clang-include-fixer.el --- Emacs integration of the clang include fixer -*- lexical-binding: t; -*- ;;; clang-include-fixer.el --- Emacs integration of the clang include fixer -*- lexical-binding: t; -*-
;; Keywords: tools, c ;; Keywords: tools, c
;; Package-Requires: ((cl-lib "0.5") (json "1.2") (let-alist "1.0.4")) ;; Package-Requires: ((cl-lib "0.5") (json "1.2") (let-alist "1.0.4"))
;;; Commentary: ;;; Commentary:
;; This package allows Emacs users to invoke the 'clang-include-fixer' within ;; This package allows Emacs users to invoke the 'clang-include-fixer' within
;; Emacs. 'clang-include-fixer' provides an automated way of adding #include ;; Emacs. 'clang-include-fixer' provides an automated way of adding #include
;; directives for missing symbols in one translation unit, see ;; directives for missing symbols in one translation unit, see
;; <http://clang.llvm.org/extra/clang-include-fixer.html>. ;; <https://clang.llvm.org/extra/clang-include-fixer.html>.
;;; Code: ;;; Code:
(require 'cl-lib) (require 'cl-lib)
(require 'json) (require 'json)
(require 'let-alist) (require 'let-alist)
(defgroup clang-include-fixer nil (defgroup clang-include-fixer nil
▲ Show 20 Lines • Show All 441 Lines • Show Last 20 Lines

clang-tools-extra/clang-include-fixer/tool/clang-include-fixer.py

# This file is a minimal clang-include-fixer vim-integration. To install: # This file is a minimal clang-include-fixer vim-integration. To install:
# - Change 'binary' if clang-include-fixer is not on the path (see below). # - Change 'binary' if clang-include-fixer is not on the path (see below).
# - Add to your .vimrc: # - Add to your .vimrc:
# #
# noremap <leader>cf :pyf path/to/llvm/source/tools/clang/tools/extra/clang-include-fixer/tool/clang-include-fixer.py<cr> # noremap <leader>cf :pyf path/to/llvm/source/tools/clang/tools/extra/clang-include-fixer/tool/clang-include-fixer.py<cr>
# #
# This enables clang-include-fixer for NORMAL and VISUAL mode. Change # This enables clang-include-fixer for NORMAL and VISUAL mode. Change
# "<leader>cf" to another binding if you need clang-include-fixer on a # "<leader>cf" to another binding if you need clang-include-fixer on a
# different key. # different key.
# #
# To set up clang-include-fixer, see # To set up clang-include-fixer, see
# http://clang.llvm.org/extra/clang-include-fixer.html # https://clang.llvm.org/extra/clang-include-fixer.html
# #
# With this integration you can press the bound key and clang-include-fixer will # With this integration you can press the bound key and clang-include-fixer will
# be run on the current buffer. # be run on the current buffer.
# #
# It operates on the current, potentially unsaved buffer and does not create # It operates on the current, potentially unsaved buffer and does not create
# or save any files. To revert a fix, just undo. # or save any files. To revert a fix, just undo.
from __future__ import print_function from __future__ import print_function
▲ Show 20 Lines • Show All 199 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/ClangTidy.cpp

//===--- tools/extra/clang-tidy/ClangTidy.cpp - Clang tidy tool -----------===// //===--- tools/extra/clang-tidy/ClangTidy.cpp - Clang tidy tool -----------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// ///
/// \file This file implements a clang-tidy tool. /// \file This file implements a clang-tidy tool.
/// ///
/// This tool uses the Clang Tooling infrastructure, see /// This tool uses the Clang Tooling infrastructure, see
/// http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html /// https://clang.llvm.org/docs/HowToSetupToolingForLLVM.html
/// for details on setting it up with LLVM source tree. /// for details on setting it up with LLVM source tree.
/// ///
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "ClangTidy.h" #include "ClangTidy.h"
#include "ClangTidyCheck.h" #include "ClangTidyCheck.h"
#include "ClangTidyDiagnosticConsumer.h" #include "ClangTidyDiagnosticConsumer.h"
#include "ClangTidyModuleRegistry.h" #include "ClangTidyModuleRegistry.h"
▲ Show 20 Lines • Show All 608 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/ClangTidyDiagnosticConsumer.cpp

//===--- tools/extra/clang-tidy/ClangTidyDiagnosticConsumer.cpp ----------=== // //===--- tools/extra/clang-tidy/ClangTidyDiagnosticConsumer.cpp ----------=== //
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// ///
/// \file This file implements ClangTidyDiagnosticConsumer, ClangTidyContext /// \file This file implements ClangTidyDiagnosticConsumer, ClangTidyContext
/// and ClangTidyError classes. /// and ClangTidyError classes.
/// ///
/// This tool uses the Clang Tooling infrastructure, see /// This tool uses the Clang Tooling infrastructure, see
/// http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html /// https://clang.llvm.org/docs/HowToSetupToolingForLLVM.html
/// for details on setting it up with LLVM source tree. /// for details on setting it up with LLVM source tree.
/// ///
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "ClangTidyDiagnosticConsumer.h" #include "ClangTidyDiagnosticConsumer.h"
#include "ClangTidyOptions.h" #include "ClangTidyOptions.h"
#include "GlobList.h" #include "GlobList.h"
#include "NoLintDirectiveHandler.h" #include "NoLintDirectiveHandler.h"
▲ Show 20 Lines • Show All 769 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/abseil/CleanupCtadCheck.h

Show All 14 Lines
namespace tidy { namespace tidy {
namespace abseil { namespace abseil {
/// Suggests switching the initialization pattern of `absl::Cleanup` /// Suggests switching the initialization pattern of `absl::Cleanup`
/// instances from the factory function to class template argument /// instances from the factory function to class template argument
/// deduction (CTAD), in C++17 and higher. /// deduction (CTAD), in C++17 and higher.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/abseil-cleanup-ctad.html /// https://clang.llvm.org/extra/clang-tidy/checks/abseil-cleanup-ctad.html
class CleanupCtadCheck : public utils::TransformerClangTidyCheck { class CleanupCtadCheck : public utils::TransformerClangTidyCheck {
public: public:
CleanupCtadCheck(StringRef Name, ClangTidyContext *Context); CleanupCtadCheck(StringRef Name, ClangTidyContext *Context);
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus17; return LangOpts.CPlusPlus17;
} }
}; };
} // namespace abseil } // namespace abseil
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_CLEANUPCTADCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_CLEANUPCTADCHECK_H

clang-tools-extra/clang-tidy/abseil/DurationAdditionCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace abseil { namespace abseil {
/// Checks for cases where addition should be performed in the /// Checks for cases where addition should be performed in the
/// ``absl::Time`` domain. /// ``absl::Time`` domain.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/abseil-duration-addition.html /// https://clang.llvm.org/extra/clang-tidy/checks/abseil-duration-addition.html
class DurationAdditionCheck : public ClangTidyCheck { class DurationAdditionCheck : public ClangTidyCheck {
public: public:
DurationAdditionCheck(StringRef Name, ClangTidyContext *Context) DurationAdditionCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace abseil } // namespace abseil
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_TIMEADDITIONCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_TIMEADDITIONCHECK_H

clang-tools-extra/clang-tidy/abseil/DurationComparisonCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace abseil { namespace abseil {
/// Prefer comparison in the absl::Duration domain instead of the numeric /// Prefer comparison in the absl::Duration domain instead of the numeric
/// domain. /// domain.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/abseil-duration-comparison.html /// https://clang.llvm.org/extra/clang-tidy/checks/abseil-duration-comparison.html
class DurationComparisonCheck : public ClangTidyCheck { class DurationComparisonCheck : public ClangTidyCheck {
public: public:
DurationComparisonCheck(StringRef Name, ClangTidyContext *Context) DurationComparisonCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace abseil } // namespace abseil
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_DURATIONCOMPARISONCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_DURATIONCOMPARISONCHECK_H

clang-tools-extra/clang-tidy/abseil/DurationConversionCastCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace abseil { namespace abseil {
/// Checks for casts of ``absl::Duration`` conversion functions, and recommends /// Checks for casts of ``absl::Duration`` conversion functions, and recommends
/// the right conversion function instead. /// the right conversion function instead.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/abseil-duration-conversion-cast.html /// https://clang.llvm.org/extra/clang-tidy/checks/abseil-duration-conversion-cast.html
class DurationConversionCastCheck : public ClangTidyCheck { class DurationConversionCastCheck : public ClangTidyCheck {
public: public:
DurationConversionCastCheck(StringRef Name, ClangTidyContext *Context) DurationConversionCastCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace abseil } // namespace abseil
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_DURATIONCONVERSIONCASTCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_DURATIONCONVERSIONCASTCHECK_H

clang-tools-extra/clang-tidy/abseil/DurationDivisionCheck.h

//===--- DurationDivisionCheck.h - clang-tidy--------------------*- C++ -*-===// //===--- DurationDivisionCheck.h - clang-tidy--------------------*- C++ -*-===//
Lint: Lint
Inline Actions

clang-format suggested style edits found:

Lint: Lint: clang-format suggested style edits found:
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_DURATIONDIVISIONCHECK_H_ #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_DURATIONDIVISIONCHECK_H_
#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_DURATIONDIVISIONCHECK_H_ #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_DURATIONDIVISIONCHECK_H_
#include "../ClangTidyCheck.h" #include "../ClangTidyCheck.h"
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace abseil { namespace abseil {
// Find potential incorrect uses of integer division of absl::Duration objects. // Find potential incorrect uses of integer division of absl::Duration objects.
// //
// For the user-facing documentation see: // For the user-facing documentation see:
// http://clang.llvm.org/extra/clang-tidy/checks/abseil-duration-division.html // https://clang.llvm.org/extra/clang-tidy/checks/abseil-duration-division.html
class DurationDivisionCheck : public ClangTidyCheck { class DurationDivisionCheck : public ClangTidyCheck {
public: public:
using ClangTidyCheck::ClangTidyCheck; using ClangTidyCheck::ClangTidyCheck;
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace abseil } // namespace abseil
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_DURATIONDIVISIONCHECK_H_ #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_DURATIONDIVISIONCHECK_H_

clang-tools-extra/clang-tidy/abseil/DurationFactoryFloatCheck.h

Show All 15 Lines
namespace abseil { namespace abseil {
/// This check finds cases where `Duration` factories are being called with /// This check finds cases where `Duration` factories are being called with
/// floating point arguments, but could be called using integer arguments. /// floating point arguments, but could be called using integer arguments.
/// It handles explicit casts and floating point literals with no fractional /// It handles explicit casts and floating point literals with no fractional
/// component. /// component.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/abseil-duration-factory-float.html /// https://clang.llvm.org/extra/clang-tidy/checks/abseil-duration-factory-float.html
class DurationFactoryFloatCheck : public ClangTidyCheck { class DurationFactoryFloatCheck : public ClangTidyCheck {
public: public:
DurationFactoryFloatCheck(StringRef Name, ClangTidyContext *Context) DurationFactoryFloatCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace abseil } // namespace abseil
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_DURATIONFACTORYFLOATCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_DURATIONFACTORYFLOATCHECK_H

clang-tools-extra/clang-tidy/abseil/DurationFactoryScaleCheck.h

Show All 15 Lines
namespace abseil { namespace abseil {
/// This check finds cases where the incorrect `Duration` factory function is /// This check finds cases where the incorrect `Duration` factory function is
/// being used by looking for scaling constants inside the factory argument /// being used by looking for scaling constants inside the factory argument
/// and suggesting a more appropriate factory. It also looks for the special /// and suggesting a more appropriate factory. It also looks for the special
/// case of zero and suggests `ZeroDuration()`. /// case of zero and suggests `ZeroDuration()`.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/abseil-duration-factory-scale.html /// https://clang.llvm.org/extra/clang-tidy/checks/abseil-duration-factory-scale.html
class DurationFactoryScaleCheck : public ClangTidyCheck { class DurationFactoryScaleCheck : public ClangTidyCheck {
public: public:
DurationFactoryScaleCheck(StringRef Name, ClangTidyContext *Context) DurationFactoryScaleCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace abseil } // namespace abseil
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_DURATIONFACTORYSCALECHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_DURATIONFACTORYSCALECHECK_H

clang-tools-extra/clang-tidy/abseil/DurationSubtractionCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace abseil { namespace abseil {
/// Checks for cases where subtraction should be performed in the /// Checks for cases where subtraction should be performed in the
/// `absl::Duration` domain. /// `absl::Duration` domain.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/abseil-duration-subtraction.html /// https://clang.llvm.org/extra/clang-tidy/checks/abseil-duration-subtraction.html
class DurationSubtractionCheck : public ClangTidyCheck { class DurationSubtractionCheck : public ClangTidyCheck {
public: public:
DurationSubtractionCheck(StringRef Name, ClangTidyContext *Context) DurationSubtractionCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace abseil } // namespace abseil
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_DURATIONSUBTRACTIONCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_DURATIONSUBTRACTIONCHECK_H

clang-tools-extra/clang-tidy/abseil/DurationUnnecessaryConversionCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace abseil { namespace abseil {
/// Finds and fixes cases where ``absl::Duration`` values are being converted /// Finds and fixes cases where ``absl::Duration`` values are being converted
/// to numeric types and back again. /// to numeric types and back again.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/abseil-duration-unnecessary-conversion.html /// https://clang.llvm.org/extra/clang-tidy/checks/abseil-duration-unnecessary-conversion.html
class DurationUnnecessaryConversionCheck : public ClangTidyCheck { class DurationUnnecessaryConversionCheck : public ClangTidyCheck {
public: public:
DurationUnnecessaryConversionCheck(StringRef Name, ClangTidyContext *Context) DurationUnnecessaryConversionCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace abseil } // namespace abseil
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_TIMEDOUBLECONVERSIONCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_TIMEDOUBLECONVERSIONCHECK_H

clang-tools-extra/clang-tidy/abseil/FasterStrsplitDelimiterCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace abseil { namespace abseil {
/// Finds instances of absl::StrSplit() or absl::MaxSplits() where the delimiter /// Finds instances of absl::StrSplit() or absl::MaxSplits() where the delimiter
/// is a single character string literal and replaces it with a character. /// is a single character string literal and replaces it with a character.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/abseil-faster-strsplit-delimiter.html /// https://clang.llvm.org/extra/clang-tidy/checks/abseil-faster-strsplit-delimiter.html
class FasterStrsplitDelimiterCheck : public ClangTidyCheck { class FasterStrsplitDelimiterCheck : public ClangTidyCheck {
public: public:
FasterStrsplitDelimiterCheck(StringRef Name, ClangTidyContext *Context) FasterStrsplitDelimiterCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace abseil } // namespace abseil
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_FASTERSTRSPLITDELIMITERCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_FASTERSTRSPLITDELIMITERCHECK_H

clang-tools-extra/clang-tidy/abseil/NoInternalDependenciesCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace abseil { namespace abseil {
/// Finds instances where the user depends on internal details and warns them /// Finds instances where the user depends on internal details and warns them
/// against doing so. /// against doing so.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/abseil-no-internal-dependencies.html /// https://clang.llvm.org/extra/clang-tidy/checks/abseil-no-internal-dependencies.html
class NoInternalDependenciesCheck : public ClangTidyCheck { class NoInternalDependenciesCheck : public ClangTidyCheck {
public: public:
NoInternalDependenciesCheck(StringRef Name, ClangTidyContext *Context) NoInternalDependenciesCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace abseil } // namespace abseil
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_NOINTERNALDEPSCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_NOINTERNALDEPSCHECK_H

clang-tools-extra/clang-tidy/abseil/NoNamespaceCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace abseil { namespace abseil {
/// This check ensures users don't open namespace absl, as that violates /// This check ensures users don't open namespace absl, as that violates
/// Abseil's compatibility guidelines. /// Abseil's compatibility guidelines.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/abseil-no-namespace.html /// https://clang.llvm.org/extra/clang-tidy/checks/abseil-no-namespace.html
class NoNamespaceCheck : public ClangTidyCheck { class NoNamespaceCheck : public ClangTidyCheck {
public: public:
NoNamespaceCheck(StringRef Name, ClangTidyContext *Context) NoNamespaceCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace abseil } // namespace abseil
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_NONAMESPACECHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_NONAMESPACECHECK_H

clang-tools-extra/clang-tidy/abseil/RedundantStrcatCallsCheck.h

//===--- RedundantStrcatCallsCheck.h - clang-tidy----------------*- C++ -*-===// //===--- RedundantStrcatCallsCheck.h - clang-tidy----------------*- C++ -*-===//
Lint: Lint
Inline Actions

clang-format suggested style edits found:

Lint: Lint: clang-format suggested style edits found:
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_REDUNDANTSTRCATCALLSCHECK_H #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_REDUNDANTSTRCATCALLSCHECK_H
#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_REDUNDANTSTRCATCALLSCHECK_H #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_REDUNDANTSTRCATCALLSCHECK_H
#include "../ClangTidyCheck.h" #include "../ClangTidyCheck.h"
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace abseil { namespace abseil {
/// Flags redundant calls to absl::StrCat when the result is being passed to /// Flags redundant calls to absl::StrCat when the result is being passed to
/// another call of absl::StrCat/absl::StrAppend. Also suggests a fix to /// another call of absl::StrCat/absl::StrAppend. Also suggests a fix to
/// collapse the calls. /// collapse the calls.
/// Example: /// Example:
/// StrCat(1, StrCat(2, 3)) ==> StrCat(1, 2, 3) /// StrCat(1, StrCat(2, 3)) ==> StrCat(1, 2, 3)
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/abseil-redundant-strcat-calls.html /// https://clang.llvm.org/extra/clang-tidy/checks/abseil-redundant-strcat-calls.html
class RedundantStrcatCallsCheck : public ClangTidyCheck { class RedundantStrcatCallsCheck : public ClangTidyCheck {
public: public:
RedundantStrcatCallsCheck(StringRef Name, ClangTidyContext *Context) RedundantStrcatCallsCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace abseil } // namespace abseil
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_REDUNDANTSTRCATCALLSCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_REDUNDANTSTRCATCALLSCHECK_H

clang-tools-extra/clang-tidy/abseil/StrCatAppendCheck.h

//===--- StrCatAppendCheck.h - clang-tidy------------------------*- C++ -*-===// //===--- StrCatAppendCheck.h - clang-tidy------------------------*- C++ -*-===//
Lint: Lint
Inline Actions

clang-format suggested style edits found:

Lint: Lint: clang-format suggested style edits found:
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_STRCATAPPENDCHECK_H #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_STRCATAPPENDCHECK_H
#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_STRCATAPPENDCHECK_H #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_STRCATAPPENDCHECK_H
#include "../ClangTidyCheck.h" #include "../ClangTidyCheck.h"
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace abseil { namespace abseil {
/// Flags uses of absl::StrCat to append to a string. Suggests absl::StrAppend /// Flags uses of absl::StrCat to append to a string. Suggests absl::StrAppend
/// should be used instead. /// should be used instead.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/abseil-str-cat-append.html /// https://clang.llvm.org/extra/clang-tidy/checks/abseil-str-cat-append.html
class StrCatAppendCheck : public ClangTidyCheck { class StrCatAppendCheck : public ClangTidyCheck {
public: public:
StrCatAppendCheck(StringRef Name, ClangTidyContext *Context) StrCatAppendCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace abseil } // namespace abseil
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_STRCATAPPENDCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_STRCATAPPENDCHECK_H

clang-tools-extra/clang-tidy/abseil/StringFindStrContainsCheck.h

Show All 14 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace abseil { namespace abseil {
/// Finds s.find(...) == string::npos comparisons (for various string-like /// Finds s.find(...) == string::npos comparisons (for various string-like
/// types) and suggests replacing with absl::StrContains. /// types) and suggests replacing with absl::StrContains.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/abseil-string-find-str-contains.html /// https://clang.llvm.org/extra/clang-tidy/checks/abseil-string-find-str-contains.html
class StringFindStrContainsCheck : public utils::TransformerClangTidyCheck { class StringFindStrContainsCheck : public utils::TransformerClangTidyCheck {
public: public:
StringFindStrContainsCheck(StringRef Name, ClangTidyContext *Context); StringFindStrContainsCheck(StringRef Name, ClangTidyContext *Context);
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override; bool isLanguageVersionSupported(const LangOptions &LangOpts) const override;
void storeOptions(ClangTidyOptions::OptionMap &Opts) override; void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
private: private:
const std::vector<StringRef> StringLikeClassesOption; const std::vector<StringRef> StringLikeClassesOption;
const StringRef AbseilStringsMatchHeaderOption; const StringRef AbseilStringsMatchHeaderOption;
}; };
} // namespace abseil } // namespace abseil
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_STRINGFINDSTRCONTAINSCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_STRINGFINDSTRCONTAINSCHECK_H

clang-tools-extra/clang-tidy/abseil/TimeComparisonCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace abseil { namespace abseil {
/// Prefer comparison in the `absl::Time` domain instead of the numeric /// Prefer comparison in the `absl::Time` domain instead of the numeric
/// domain. /// domain.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/abseil-time-comparison.html /// https://clang.llvm.org/extra/clang-tidy/checks/abseil-time-comparison.html
class TimeComparisonCheck : public ClangTidyCheck { class TimeComparisonCheck : public ClangTidyCheck {
public: public:
TimeComparisonCheck(StringRef Name, ClangTidyContext *Context) TimeComparisonCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace abseil } // namespace abseil
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_TIMECOMPARECHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_TIMECOMPARECHECK_H

clang-tools-extra/clang-tidy/abseil/TimeSubtractionCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace abseil { namespace abseil {
/// Finds and fixes `absl::Time` subtraction expressions to do subtraction /// Finds and fixes `absl::Time` subtraction expressions to do subtraction
/// in the time domain instead of the numeric domain. /// in the time domain instead of the numeric domain.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/abseil-time-subtraction.html /// https://clang.llvm.org/extra/clang-tidy/checks/abseil-time-subtraction.html
class TimeSubtractionCheck : public ClangTidyCheck { class TimeSubtractionCheck : public ClangTidyCheck {
public: public:
TimeSubtractionCheck(StringRef Name, ClangTidyContext *Context) TimeSubtractionCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
private: private:
void emitDiagnostic(const Expr* Node, llvm::StringRef Replacement); void emitDiagnostic(const Expr* Node, llvm::StringRef Replacement);
}; };
} // namespace abseil } // namespace abseil
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_TIMESUBTRACTIONCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_TIMESUBTRACTIONCHECK_H

clang-tools-extra/clang-tidy/abseil/UpgradeDurationConversionsCheck.h

//===--- UpgradeDurationConversionsCheck.h - clang-tidy ---------*- C++ -*-===// //===--- UpgradeDurationConversionsCheck.h - clang-tidy ---------*- C++ -*-===//
Lint: Lint
Inline Actions

clang-format suggested style edits found:

Lint: Lint: clang-format suggested style edits found:
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_UPGRADEDURATIONCONVERSIONSCHECK_H #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_UPGRADEDURATIONCONVERSIONSCHECK_H
#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_UPGRADEDURATIONCONVERSIONSCHECK_H #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_UPGRADEDURATIONCONVERSIONSCHECK_H
#include "../ClangTidyCheck.h" #include "../ClangTidyCheck.h"
#include "clang/Basic/SourceLocation.h" #include "clang/Basic/SourceLocation.h"
#include "llvm/ADT/DenseSet.h" #include "llvm/ADT/DenseSet.h"
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace abseil { namespace abseil {
/// Finds deprecated uses of `absl::Duration` arithmetic operators and factories. /// Finds deprecated uses of `absl::Duration` arithmetic operators and factories.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/abseil-upgrade-duration-conversions.html /// https://clang.llvm.org/extra/clang-tidy/checks/abseil-upgrade-duration-conversions.html
class UpgradeDurationConversionsCheck : public ClangTidyCheck { class UpgradeDurationConversionsCheck : public ClangTidyCheck {
public: public:
UpgradeDurationConversionsCheck(StringRef Name, ClangTidyContext *Context) UpgradeDurationConversionsCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
Show All 11 Lines

clang-tools-extra/clang-tidy/add_new_check.py

Show First 20 Lines • Show All 79 Lines • ▼ Show 20 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace %(namespace)s { namespace %(namespace)s {
/// FIXME: Write a short description. /// FIXME: Write a short description.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/%(check_name_dashes)s.html /// https://clang.llvm.org/extra/clang-tidy/checks/%(check_name_dashes)s.html
class %(check_name)s : public ClangTidyCheck { class %(check_name)s : public ClangTidyCheck {
public: public:
%(check_name)s(StringRef Name, ClangTidyContext *Context) %(check_name)s(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
▲ Show 20 Lines • Show All 483 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/altera/IdDependentBackwardBranchCheck.h

Show All 14 Lines
namespace tidy { namespace tidy {
namespace altera { namespace altera {
/// Finds ID-dependent variables and fields used within loops, and warns of /// Finds ID-dependent variables and fields used within loops, and warns of
/// their usage. Using these variables in loops can lead to performance /// their usage. Using these variables in loops can lead to performance
/// degradation. /// degradation.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/altera-id-dependent-backward-branch.html /// https://clang.llvm.org/extra/clang-tidy/checks/altera-id-dependent-backward-branch.html
class IdDependentBackwardBranchCheck : public ClangTidyCheck { class IdDependentBackwardBranchCheck : public ClangTidyCheck {
private: private:
enum LoopType { UnknownLoop = -1, DoLoop = 0, WhileLoop = 1, ForLoop = 2 }; enum LoopType { UnknownLoop = -1, DoLoop = 0, WhileLoop = 1, ForLoop = 2 };
// Stores information necessary for printing out source of error. // Stores information necessary for printing out source of error.
struct IdDependencyRecord { struct IdDependencyRecord {
IdDependencyRecord(const VarDecl *Declaration, SourceLocation Location, IdDependencyRecord(const VarDecl *Declaration, SourceLocation Location,
const llvm::Twine &Message) const llvm::Twine &Message)
: VariableDeclaration(Declaration), Location(Location), : VariableDeclaration(Declaration), Location(Location),
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/altera/KernelNameRestrictionCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace altera { namespace altera {
/// Finds kernel files and include directives whose filename is `kernel.cl`, /// Finds kernel files and include directives whose filename is `kernel.cl`,
/// `Verilog.cl`, or `VHDL.cl`. /// `Verilog.cl`, or `VHDL.cl`.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/altera-kernel-name-restriction.html /// https://clang.llvm.org/extra/clang-tidy/checks/altera-kernel-name-restriction.html
class KernelNameRestrictionCheck : public ClangTidyCheck { class KernelNameRestrictionCheck : public ClangTidyCheck {
public: public:
KernelNameRestrictionCheck(StringRef Name, ClangTidyContext *Context) KernelNameRestrictionCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP, void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
Preprocessor *) override; Preprocessor *) override;
}; };
} // namespace altera } // namespace altera
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ALTERA_KERNEL_NAME_RESTRICTION_CHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ALTERA_KERNEL_NAME_RESTRICTION_CHECK_H

clang-tools-extra/clang-tidy/altera/SingleWorkItemBarrierCheck.h

Show All 14 Lines
namespace tidy { namespace tidy {
namespace altera { namespace altera {
/// Detects OpenCL kernel functions that call a barrier but do not call an /// Detects OpenCL kernel functions that call a barrier but do not call an
/// ID-function function. These functions will be treated as single work-item /// ID-function function. These functions will be treated as single work-item
/// kernels, which may be inefficient or cause an error. /// kernels, which may be inefficient or cause an error.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/opencl-single-work-item-barrier.html /// https://clang.llvm.org/extra/clang-tidy/checks/opencl-single-work-item-barrier.html
class SingleWorkItemBarrierCheck : public ClangTidyCheck { class SingleWorkItemBarrierCheck : public ClangTidyCheck {
const unsigned AOCVersion; const unsigned AOCVersion;
public: public:
SingleWorkItemBarrierCheck(StringRef Name, ClangTidyContext *Context) SingleWorkItemBarrierCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context), : ClangTidyCheck(Name, Context),
AOCVersion(Options.get("AOCVersion", 1600U)) {} AOCVersion(Options.get("AOCVersion", 1600U)) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
Show All 9 Lines

clang-tools-extra/clang-tidy/altera/StructPackAlignCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace altera { namespace altera {
/// Finds structs that are inefficiently packed or aligned, and recommends /// Finds structs that are inefficiently packed or aligned, and recommends
/// packing and/or aligning of said structs as needed. /// packing and/or aligning of said structs as needed.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/altera-struct-pack-align.html /// https://clang.llvm.org/extra/clang-tidy/checks/altera-struct-pack-align.html
class StructPackAlignCheck : public ClangTidyCheck { class StructPackAlignCheck : public ClangTidyCheck {
public: public:
StructPackAlignCheck(StringRef Name, ClangTidyContext *Context) StructPackAlignCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context), : ClangTidyCheck(Name, Context),
MaxConfiguredAlignment(Options.get("MaxConfiguredAlignment", 128)) {} MaxConfiguredAlignment(Options.get("MaxConfiguredAlignment", 128)) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
void storeOptions(ClangTidyOptions::OptionMap &Opts) override; void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
Show All 11 Lines

clang-tools-extra/clang-tidy/altera/UnrollLoopsCheck.h

Show All 17 Lines
/// Finds inner loops that have not been unrolled, as well as fully unrolled /// Finds inner loops that have not been unrolled, as well as fully unrolled
/// loops with unknown loop bounds or a large number of iterations. /// loops with unknown loop bounds or a large number of iterations.
/// ///
/// Unrolling inner loops could improve the performance of OpenCL kernels. /// Unrolling inner loops could improve the performance of OpenCL kernels.
/// However, if they have unknown loop bounds or a large number of iterations, /// However, if they have unknown loop bounds or a large number of iterations,
/// they cannot be fully unrolled, and should be partially unrolled. /// they cannot be fully unrolled, and should be partially unrolled.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/altera-unroll-loops.html /// https://clang.llvm.org/extra/clang-tidy/checks/altera-unroll-loops.html
class UnrollLoopsCheck : public ClangTidyCheck { class UnrollLoopsCheck : public ClangTidyCheck {
public: public:
UnrollLoopsCheck(StringRef Name, ClangTidyContext *Context); UnrollLoopsCheck(StringRef Name, ClangTidyContext *Context);
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
private: private:
/// Recommend partial unrolling if number of loop iterations is greater than /// Recommend partial unrolling if number of loop iterations is greater than
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/android/CloexecAccept4Check.h

Show All 12 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace android { namespace android {
/// Finds code that uses accept4() without using the SOCK_CLOEXEC flag. /// Finds code that uses accept4() without using the SOCK_CLOEXEC flag.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/android-cloexec-accept4.html /// https://clang.llvm.org/extra/clang-tidy/checks/android-cloexec-accept4.html
class CloexecAccept4Check : public CloexecCheck { class CloexecAccept4Check : public CloexecCheck {
public: public:
CloexecAccept4Check(StringRef Name, ClangTidyContext *Context) CloexecAccept4Check(StringRef Name, ClangTidyContext *Context)
: CloexecCheck(Name, Context) {} : CloexecCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace android } // namespace android
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_ACCEPT4_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_ACCEPT4_H

clang-tools-extra/clang-tidy/android/CloexecAcceptCheck.h

Show All 12 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace android { namespace android {
/// accept() is better to be replaced by accept4(). /// accept() is better to be replaced by accept4().
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/android-cloexec-accept.html /// https://clang.llvm.org/extra/clang-tidy/checks/android-cloexec-accept.html
class CloexecAcceptCheck : public CloexecCheck { class CloexecAcceptCheck : public CloexecCheck {
public: public:
CloexecAcceptCheck(StringRef Name, ClangTidyContext *Context) CloexecAcceptCheck(StringRef Name, ClangTidyContext *Context)
: CloexecCheck(Name, Context) {} : CloexecCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace android } // namespace android
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_ACCEPT_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_ACCEPT_H

clang-tools-extra/clang-tidy/android/CloexecCreatCheck.h

Show All 12 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace android { namespace android {
/// creat() is better to be replaced by open(). /// creat() is better to be replaced by open().
/// Find the usage of creat() and redirect user to use open(). /// Find the usage of creat() and redirect user to use open().
/// http://clang.llvm.org/extra/clang-tidy/checks/android-cloexec-creat.html /// https://clang.llvm.org/extra/clang-tidy/checks/android-cloexec-creat.html
class CloexecCreatCheck : public CloexecCheck { class CloexecCreatCheck : public CloexecCheck {
public: public:
CloexecCreatCheck(StringRef Name, ClangTidyContext *Context) CloexecCreatCheck(StringRef Name, ClangTidyContext *Context)
: CloexecCheck(Name, Context) {} : CloexecCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace android } // namespace android
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_CREAT_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_CREAT_H

clang-tools-extra/clang-tidy/android/CloexecDupCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace android { namespace android {
/// dup() is better to be replaced by fcntl(), which has close-on-exec flag. /// dup() is better to be replaced by fcntl(), which has close-on-exec flag.
/// Find the usage of dup() and redirect user to use fcntl(). /// Find the usage of dup() and redirect user to use fcntl().
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/android-cloexec-dup.html /// https://clang.llvm.org/extra/clang-tidy/checks/android-cloexec-dup.html
class CloexecDupCheck : public CloexecCheck { class CloexecDupCheck : public CloexecCheck {
public: public:
CloexecDupCheck(StringRef Name, ClangTidyContext *Context) CloexecDupCheck(StringRef Name, ClangTidyContext *Context)
: CloexecCheck(Name, Context) {} : CloexecCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace android } // namespace android
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_DUP_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_DUP_H

clang-tools-extra/clang-tidy/android/CloexecEpollCreate1Check.h

Show All 12 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace android { namespace android {
/// Finds code that uses epoll_create1() without using the EPOLL_CLOEXEC flag. /// Finds code that uses epoll_create1() without using the EPOLL_CLOEXEC flag.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/android-cloexec-epoll-create1.html /// https://clang.llvm.org/extra/clang-tidy/checks/android-cloexec-epoll-create1.html
class CloexecEpollCreate1Check : public CloexecCheck { class CloexecEpollCreate1Check : public CloexecCheck {
public: public:
CloexecEpollCreate1Check(StringRef Name, ClangTidyContext *Context) CloexecEpollCreate1Check(StringRef Name, ClangTidyContext *Context)
: CloexecCheck(Name, Context) {} : CloexecCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace android } // namespace android
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_EPOLL_CREATE1_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_EPOLL_CREATE1_H

clang-tools-extra/clang-tidy/android/CloexecEpollCreateCheck.h

Show All 12 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace android { namespace android {
/// epoll_create() is better to be replaced by epoll_create1(). /// epoll_create() is better to be replaced by epoll_create1().
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/android-cloexec-epoll-create.html /// https://clang.llvm.org/extra/clang-tidy/checks/android-cloexec-epoll-create.html
class CloexecEpollCreateCheck : public CloexecCheck { class CloexecEpollCreateCheck : public CloexecCheck {
public: public:
CloexecEpollCreateCheck(StringRef Name, ClangTidyContext *Context) CloexecEpollCreateCheck(StringRef Name, ClangTidyContext *Context)
: CloexecCheck(Name, Context) {} : CloexecCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace android } // namespace android
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_EPOLL_CREATE_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_EPOLL_CREATE_H

clang-tools-extra/clang-tidy/android/CloexecFopenCheck.h

Show All 15 Lines
namespace android { namespace android {
/// fopen() is suggested to include "e" in their mode string; like "re" would be /// fopen() is suggested to include "e" in their mode string; like "re" would be
/// better than "r". /// better than "r".
/// ///
/// This check only works when corresponding argument is StringLiteral. No /// This check only works when corresponding argument is StringLiteral. No
/// constant propagation. /// constant propagation.
/// ///
/// http://clang.llvm.org/extra/clang-tidy/checks/android-cloexec-fopen.html /// https://clang.llvm.org/extra/clang-tidy/checks/android-cloexec-fopen.html
class CloexecFopenCheck : public CloexecCheck { class CloexecFopenCheck : public CloexecCheck {
public: public:
CloexecFopenCheck(StringRef Name, ClangTidyContext *Context) CloexecFopenCheck(StringRef Name, ClangTidyContext *Context)
: CloexecCheck(Name, Context) {} : CloexecCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace android } // namespace android
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_FOPEN_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_FOPEN_H

clang-tools-extra/clang-tidy/android/CloexecInotifyInit1Check.h

Show All 12 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace android { namespace android {
/// Finds code that uses inotify_init1() without using the IN_CLOEXEC flag. /// Finds code that uses inotify_init1() without using the IN_CLOEXEC flag.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/android-cloexec-inotify-init1.html /// https://clang.llvm.org/extra/clang-tidy/checks/android-cloexec-inotify-init1.html
class CloexecInotifyInit1Check : public CloexecCheck { class CloexecInotifyInit1Check : public CloexecCheck {
public: public:
CloexecInotifyInit1Check(StringRef Name, ClangTidyContext *Context) CloexecInotifyInit1Check(StringRef Name, ClangTidyContext *Context)
: CloexecCheck(Name, Context) {} : CloexecCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace android } // namespace android
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_INOTIFY_INIT1_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_INOTIFY_INIT1_H

clang-tools-extra/clang-tidy/android/CloexecInotifyInitCheck.h

Show All 12 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace android { namespace android {
/// inotify_init() is better to be replaced by inotify_init1(). /// inotify_init() is better to be replaced by inotify_init1().
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/android-cloexec-inotify-init.html /// https://clang.llvm.org/extra/clang-tidy/checks/android-cloexec-inotify-init.html
class CloexecInotifyInitCheck : public CloexecCheck { class CloexecInotifyInitCheck : public CloexecCheck {
public: public:
CloexecInotifyInitCheck(StringRef Name, ClangTidyContext *Context) CloexecInotifyInitCheck(StringRef Name, ClangTidyContext *Context)
: CloexecCheck(Name, Context) {} : CloexecCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace android } // namespace android
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_INOTIFY_INIT_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_INOTIFY_INIT_H

clang-tools-extra/clang-tidy/android/CloexecMemfdCreateCheck.h

Show All 12 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace android { namespace android {
/// Finds code that uses memfd_create() without using the MFD_CLOEXEC flag. /// Finds code that uses memfd_create() without using the MFD_CLOEXEC flag.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/android-cloexec-memfd-create.html /// https://clang.llvm.org/extra/clang-tidy/checks/android-cloexec-memfd-create.html
class CloexecMemfdCreateCheck : public CloexecCheck { class CloexecMemfdCreateCheck : public CloexecCheck {
public: public:
CloexecMemfdCreateCheck(StringRef Name, ClangTidyContext *Context) CloexecMemfdCreateCheck(StringRef Name, ClangTidyContext *Context)
: CloexecCheck(Name, Context) {} : CloexecCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace android } // namespace android
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_MEMFD_CREATE_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_MEMFD_CREATE_H

clang-tools-extra/clang-tidy/android/CloexecPipe2Check.h

Show All 12 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace android { namespace android {
/// Finds code that uses pipe2() without using the O_CLOEXEC flag. /// Finds code that uses pipe2() without using the O_CLOEXEC flag.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/android-cloexec-pipe2.html /// https://clang.llvm.org/extra/clang-tidy/checks/android-cloexec-pipe2.html
class CloexecPipe2Check : public CloexecCheck { class CloexecPipe2Check : public CloexecCheck {
public: public:
CloexecPipe2Check(StringRef Name, ClangTidyContext *Context) CloexecPipe2Check(StringRef Name, ClangTidyContext *Context)
: CloexecCheck(Name, Context) {} : CloexecCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace android } // namespace android
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_PIPE2_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_PIPE2_H

clang-tools-extra/clang-tidy/android/CloexecPipeCheck.h

Show All 12 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace android { namespace android {
/// Suggests to replace calls to pipe() with calls to pipe2(). /// Suggests to replace calls to pipe() with calls to pipe2().
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/android-cloexec-pipe.html /// https://clang.llvm.org/extra/clang-tidy/checks/android-cloexec-pipe.html
class CloexecPipeCheck : public CloexecCheck { class CloexecPipeCheck : public CloexecCheck {
public: public:
CloexecPipeCheck(StringRef Name, ClangTidyContext *Context) CloexecPipeCheck(StringRef Name, ClangTidyContext *Context)
: CloexecCheck(Name, Context) {} : CloexecCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace android } // namespace android
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_PIPE_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_PIPE_H

clang-tools-extra/clang-tidy/android/CloexecSocketCheck.h

Show All 12 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace android { namespace android {
/// Finds code that uses socket() without using the SOCK_CLOEXEC flag. /// Finds code that uses socket() without using the SOCK_CLOEXEC flag.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/android-cloexec-socket.html /// https://clang.llvm.org/extra/clang-tidy/checks/android-cloexec-socket.html
class CloexecSocketCheck : public CloexecCheck { class CloexecSocketCheck : public CloexecCheck {
public: public:
CloexecSocketCheck(StringRef Name, ClangTidyContext *Context) CloexecSocketCheck(StringRef Name, ClangTidyContext *Context)
: CloexecCheck(Name, Context) {} : CloexecCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace android } // namespace android
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_SOCKET_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_SOCKET_H

clang-tools-extra/clang-tidy/boost/UseToStringCheck.h

Show All 14 Lines
namespace tidy { namespace tidy {
namespace boost { namespace boost {
/// Finds calls to ``boost::lexical_cast<std::string>`` and /// Finds calls to ``boost::lexical_cast<std::string>`` and
/// ``boost::lexical_cast<std::wstring>`` and replaces them with /// ``boost::lexical_cast<std::wstring>`` and replaces them with
/// ``std::to_string`` and ``std::to_wstring`` calls. /// ``std::to_string`` and ``std::to_wstring`` calls.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/boost-use-to-string.html /// https://clang.llvm.org/extra/clang-tidy/checks/boost-use-to-string.html
class UseToStringCheck : public ClangTidyCheck { class UseToStringCheck : public ClangTidyCheck {
public: public:
UseToStringCheck(StringRef Name, ClangTidyContext *Context) UseToStringCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace boost } // namespace boost
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BOOST_USE_TO_STRING_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BOOST_USE_TO_STRING_H

clang-tools-extra/clang-tidy/bugprone/BadSignalToKillThreadCheck.h

Show All 12 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace bugprone { namespace bugprone {
/// Finds ``pthread_kill`` function calls when thread is terminated by /// Finds ``pthread_kill`` function calls when thread is terminated by
/// ``SIGTERM`` signal. /// ``SIGTERM`` signal.
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-bad-signal-to-kill-thread.html /// https://clang.llvm.org/extra/clang-tidy/checks/bugprone-bad-signal-to-kill-thread.html
class BadSignalToKillThreadCheck : public ClangTidyCheck { class BadSignalToKillThreadCheck : public ClangTidyCheck {
public: public:
BadSignalToKillThreadCheck(StringRef Name, ClangTidyContext *Context) BadSignalToKillThreadCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP, void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
Preprocessor *ModuleExpanderPP) override; Preprocessor *ModuleExpanderPP) override;
Optional<unsigned> SigtermValue; Optional<unsigned> SigtermValue;
}; };
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_BADSIGNALTOKILLTHREADCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_BADSIGNALTOKILLTHREADCHECK_H

clang-tools-extra/clang-tidy/bugprone/BranchCloneCheck.h

Show All 16 Lines
/// A check for detecting if/else if/else chains where two or more branches are /// A check for detecting if/else if/else chains where two or more branches are
/// Type I clones of each other (that is, they contain identical code), for /// Type I clones of each other (that is, they contain identical code), for
/// detecting switch statements where two or more consecutive branches are /// detecting switch statements where two or more consecutive branches are
/// Type I clones of each other, and for detecting conditional operators where /// Type I clones of each other, and for detecting conditional operators where
/// the true and false expressions are Type I clones of each other. /// the true and false expressions are Type I clones of each other.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-branch-clone.html /// https://clang.llvm.org/extra/clang-tidy/checks/bugprone-branch-clone.html
class BranchCloneCheck : public ClangTidyCheck { class BranchCloneCheck : public ClangTidyCheck {
public: public:
BranchCloneCheck(StringRef Name, ClangTidyContext *Context) BranchCloneCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_BRANCHCLONECHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_BRANCHCLONECHECK_H

clang-tools-extra/clang-tidy/bugprone/CopyConstructorInitCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace bugprone { namespace bugprone {
/// Finds copy constructors where the ctor don't call the copy constructor of /// Finds copy constructors where the ctor don't call the copy constructor of
/// the base class. /// the base class.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/misc-copy-constructor-init.html /// https://clang.llvm.org/extra/clang-tidy/checks/misc-copy-constructor-init.html
class CopyConstructorInitCheck : public ClangTidyCheck { class CopyConstructorInitCheck : public ClangTidyCheck {
public: public:
CopyConstructorInitCheck(StringRef Name, ClangTidyContext *Context) CopyConstructorInitCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_COPY_CONSTRUCTOR_INIT_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_COPY_CONSTRUCTOR_INIT_H

clang-tools-extra/clang-tidy/bugprone/DanglingHandleCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace bugprone { namespace bugprone {
/// Detect dangling references in value handlers like /// Detect dangling references in value handlers like
/// std::experimental::string_view. /// std::experimental::string_view.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-dangling-handle.html /// https://clang.llvm.org/extra/clang-tidy/checks/bugprone-dangling-handle.html
class DanglingHandleCheck : public ClangTidyCheck { class DanglingHandleCheck : public ClangTidyCheck {
public: public:
DanglingHandleCheck(StringRef Name, ClangTidyContext *Context); DanglingHandleCheck(StringRef Name, ClangTidyContext *Context);
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
void storeOptions(ClangTidyOptions::OptionMap &Opts) override; void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
private: private:
Show All 12 Lines

clang-tools-extra/clang-tidy/bugprone/EasilySwappableParametersCheck.h

Show All 14 Lines
namespace tidy { namespace tidy {
namespace bugprone { namespace bugprone {
/// Finds function definitions where parameters of convertible types follow /// Finds function definitions where parameters of convertible types follow
/// each other directly, making call sites prone to calling the function with /// each other directly, making call sites prone to calling the function with
/// swapped (or badly ordered) arguments. /// swapped (or badly ordered) arguments.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-easily-swappable-parameters.html /// https://clang.llvm.org/extra/clang-tidy/checks/bugprone-easily-swappable-parameters.html
class EasilySwappableParametersCheck : public ClangTidyCheck { class EasilySwappableParametersCheck : public ClangTidyCheck {
public: public:
EasilySwappableParametersCheck(StringRef Name, ClangTidyContext *Context); EasilySwappableParametersCheck(StringRef Name, ClangTidyContext *Context);
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
void storeOptions(ClangTidyOptions::OptionMap &Opts) override; void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
/// The minimum length of an adjacent swappable parameter range required for /// The minimum length of an adjacent swappable parameter range required for
Show All 35 Lines

clang-tools-extra/clang-tidy/bugprone/ExceptionEscapeCheck.h

Show All 17 Lines
namespace bugprone { namespace bugprone {
/// Finds functions which should not throw exceptions: Destructors, move /// Finds functions which should not throw exceptions: Destructors, move
/// constructors, move assignment operators, the main() function, /// constructors, move assignment operators, the main() function,
/// swap() functions, functions marked with throw() or noexcept and functions /// swap() functions, functions marked with throw() or noexcept and functions
/// given as option to the checker. /// given as option to the checker.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-exception-escape.html /// https://clang.llvm.org/extra/clang-tidy/checks/bugprone-exception-escape.html
class ExceptionEscapeCheck : public ClangTidyCheck { class ExceptionEscapeCheck : public ClangTidyCheck {
public: public:
ExceptionEscapeCheck(StringRef Name, ClangTidyContext *Context); ExceptionEscapeCheck(StringRef Name, ClangTidyContext *Context);
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus && LangOpts.CXXExceptions; return LangOpts.CPlusPlus && LangOpts.CXXExceptions;
} }
void storeOptions(ClangTidyOptions::OptionMap &Opts) override; void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
Show All 15 Lines

clang-tools-extra/clang-tidy/bugprone/FoldInitTypeCheck.h

Show All 17 Lines
/// Find and flag invalid initializer values in folds, e.g. std::accumulate. /// Find and flag invalid initializer values in folds, e.g. std::accumulate.
/// Example: /// Example:
/// \code /// \code
/// auto v = {65536L * 65536 * 65536}; /// auto v = {65536L * 65536 * 65536};
/// std::accumulate(begin(v), end(v), 0 /* int type is too small */); /// std::accumulate(begin(v), end(v), 0 /* int type is too small */);
/// \endcode /// \endcode
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-fold-init-type.html /// https://clang.llvm.org/extra/clang-tidy/checks/bugprone-fold-init-type.html
class FoldInitTypeCheck : public ClangTidyCheck { class FoldInitTypeCheck : public ClangTidyCheck {
public: public:
FoldInitTypeCheck(StringRef Name, ClangTidyContext *Context) FoldInitTypeCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
private: private:
Show All 9 Lines

clang-tools-extra/clang-tidy/bugprone/ForwardDeclarationNamespaceCheck.h

Show All 30 Lines
/// // warning : no definition found for 'A', but a definition with the same /// // warning : no definition found for 'A', but a definition with the same
/// name 'A' found in another namespace 'nb::' /// name 'A' found in another namespace 'nb::'
/// \endcode /// \endcode
/// ///
/// This check can only generate warnings, but it can't suggest fixes at this /// This check can only generate warnings, but it can't suggest fixes at this
/// point. /// point.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-forward-declaration-namespace.html /// https://clang.llvm.org/extra/clang-tidy/checks/bugprone-forward-declaration-namespace.html
class ForwardDeclarationNamespaceCheck : public ClangTidyCheck { class ForwardDeclarationNamespaceCheck : public ClangTidyCheck {
public: public:
ForwardDeclarationNamespaceCheck(StringRef Name, ClangTidyContext *Context) ForwardDeclarationNamespaceCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
void onEndOfTranslationUnit() override; void onEndOfTranslationUnit() override;
Show All 11 Lines

clang-tools-extra/clang-tidy/bugprone/ForwardingReferenceOverloadCheck.h

Show All 19 Lines
/// reference is passed to the constructor, the forwarding reference parameter /// reference is passed to the constructor, the forwarding reference parameter
/// can be a perfect match while the const reference parameter of the copy /// can be a perfect match while the const reference parameter of the copy
/// constructor can't. The forwarding reference constructor will be called, /// constructor can't. The forwarding reference constructor will be called,
/// which can lead to confusion. /// which can lead to confusion.
/// For detailed description of this problem see: Scott Meyers, Effective Modern /// For detailed description of this problem see: Scott Meyers, Effective Modern
/// C++ Design, item 26. /// C++ Design, item 26.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-forwarding-reference-overload.html /// https://clang.llvm.org/extra/clang-tidy/checks/bugprone-forwarding-reference-overload.html
class ForwardingReferenceOverloadCheck : public ClangTidyCheck { class ForwardingReferenceOverloadCheck : public ClangTidyCheck {
public: public:
ForwardingReferenceOverloadCheck(StringRef Name, ClangTidyContext *Context) ForwardingReferenceOverloadCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus11; return LangOpts.CPlusPlus11;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_FORWARDINGREFERENCEOVERLOADCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_FORWARDINGREFERENCEOVERLOADCHECK_H

clang-tools-extra/clang-tidy/bugprone/ImplicitWideningOfMultiplicationResultCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace bugprone { namespace bugprone {
/// Diagnoses instances of an implicit widening of multiplication result. /// Diagnoses instances of an implicit widening of multiplication result.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-implicit-widening-of-multiplication-result.html /// https://clang.llvm.org/extra/clang-tidy/checks/bugprone-implicit-widening-of-multiplication-result.html
class ImplicitWideningOfMultiplicationResultCheck : public ClangTidyCheck { class ImplicitWideningOfMultiplicationResultCheck : public ClangTidyCheck {
const ast_matchers::MatchFinder::MatchResult *Result; const ast_matchers::MatchFinder::MatchResult *Result;
bool ShouldUseCXXStaticCast; bool ShouldUseCXXStaticCast;
bool ShouldUseCXXHeader; bool ShouldUseCXXHeader;
llvm::Optional<FixItHint> includeStddefHeader(SourceLocation File); llvm::Optional<FixItHint> includeStddefHeader(SourceLocation File);
void handleImplicitCastExpr(const ImplicitCastExpr *ICE); void handleImplicitCastExpr(const ImplicitCastExpr *ICE);
Show All 22 Lines

clang-tools-extra/clang-tidy/bugprone/InfiniteLoopCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace bugprone { namespace bugprone {
/// Finds obvious infinite loops (loops where the condition variable is /// Finds obvious infinite loops (loops where the condition variable is
/// not changed at all). /// not changed at all).
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-infinite-loop.html /// https://clang.llvm.org/extra/clang-tidy/checks/bugprone-infinite-loop.html
class InfiniteLoopCheck : public ClangTidyCheck { class InfiniteLoopCheck : public ClangTidyCheck {
public: public:
InfiniteLoopCheck(StringRef Name, ClangTidyContext *Context) InfiniteLoopCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_INFINITELOOPCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_INFINITELOOPCHECK_H

clang-tools-extra/clang-tidy/bugprone/IntegerDivisionCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace bugprone { namespace bugprone {
/// Finds cases where integer division in a floating point context is likely to /// Finds cases where integer division in a floating point context is likely to
/// cause unintended loss of precision. /// cause unintended loss of precision.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-integer-division.html /// https://clang.llvm.org/extra/clang-tidy/checks/bugprone-integer-division.html
class IntegerDivisionCheck : public ClangTidyCheck { class IntegerDivisionCheck : public ClangTidyCheck {
public: public:
IntegerDivisionCheck(StringRef Name, ClangTidyContext *Context) IntegerDivisionCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_INTEGER_DIVISION_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_INTEGER_DIVISION_H

clang-tools-extra/clang-tidy/bugprone/LambdaFunctionNameCheck.h

Show All 14 Lines
namespace tidy { namespace tidy {
namespace bugprone { namespace bugprone {
/// Detect when __func__ or __FUNCTION__ is being used from within a lambda. In /// Detect when __func__ or __FUNCTION__ is being used from within a lambda. In
/// that context, those expressions expand to the name of the call operator /// that context, those expressions expand to the name of the call operator
/// (i.e., `operator()`). /// (i.e., `operator()`).
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-lambda-function-name.html /// https://clang.llvm.org/extra/clang-tidy/checks/bugprone-lambda-function-name.html
class LambdaFunctionNameCheck : public ClangTidyCheck { class LambdaFunctionNameCheck : public ClangTidyCheck {
public: public:
struct SourceRangeLessThan { struct SourceRangeLessThan {
bool operator()(const SourceRange &L, const SourceRange &R) const { bool operator()(const SourceRange &L, const SourceRange &R) const {
if (L.getBegin() == R.getBegin()) { if (L.getBegin() == R.getBegin()) {
return L.getEnd() < R.getEnd(); return L.getEnd() < R.getEnd();
} }
return L.getBegin() < R.getBegin(); return L.getBegin() < R.getBegin();
Show All 20 Lines

clang-tools-extra/clang-tidy/bugprone/MisplacedOperatorInStrlenInAllocCheck.h

Show All 14 Lines
namespace tidy { namespace tidy {
namespace bugprone { namespace bugprone {
/// Finds cases where ``1`` is added to the string in the argument to a function /// Finds cases where ``1`` is added to the string in the argument to a function
/// in the ``strlen()`` family instead of the result and value is used as an /// in the ``strlen()`` family instead of the result and value is used as an
/// argument to a memory allocation function. /// argument to a memory allocation function.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-misplaced-operator-in-strlen-in-alloc.html /// https://clang.llvm.org/extra/clang-tidy/checks/bugprone-misplaced-operator-in-strlen-in-alloc.html
class MisplacedOperatorInStrlenInAllocCheck : public ClangTidyCheck { class MisplacedOperatorInStrlenInAllocCheck : public ClangTidyCheck {
public: public:
MisplacedOperatorInStrlenInAllocCheck(StringRef Name, ClangTidyContext *Context) MisplacedOperatorInStrlenInAllocCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_MISPLACED_OPERATOR_IN_STRLEN_IN_ALLOC_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_MISPLACED_OPERATOR_IN_STRLEN_IN_ALLOC_H

clang-tools-extra/clang-tidy/bugprone/MisplacedPointerArithmeticInAllocCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace bugprone { namespace bugprone {
/// Finds cases where an integer is added to or subracted from the result of a /// Finds cases where an integer is added to or subracted from the result of a
/// memory allocation function instead of its argument. /// memory allocation function instead of its argument.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-misplaced-operator-in-alloc.html /// https://clang.llvm.org/extra/clang-tidy/checks/bugprone-misplaced-operator-in-alloc.html
class MisplacedPointerArithmeticInAllocCheck : public ClangTidyCheck { class MisplacedPointerArithmeticInAllocCheck : public ClangTidyCheck {
public: public:
MisplacedPointerArithmeticInAllocCheck(StringRef Name, MisplacedPointerArithmeticInAllocCheck(StringRef Name,
ClangTidyContext *Context) ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_MISPLACED_OPERATOR_IN_ALLOC_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_MISPLACED_OPERATOR_IN_ALLOC_H

clang-tools-extra/clang-tidy/bugprone/MisplacedWideningCastCheck.h

Show All 20 Lines
/// such cast is ineffective. /// such cast is ineffective.
/// ///
/// There is one option: /// There is one option:
/// ///
/// - `CheckImplicitCasts`: Whether to check implicit casts as well which may /// - `CheckImplicitCasts`: Whether to check implicit casts as well which may
// be the most common case. Enabled by default. // be the most common case. Enabled by default.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-misplaced-widening-cast.html /// https://clang.llvm.org/extra/clang-tidy/checks/bugprone-misplaced-widening-cast.html
class MisplacedWideningCastCheck : public ClangTidyCheck { class MisplacedWideningCastCheck : public ClangTidyCheck {
public: public:
MisplacedWideningCastCheck(StringRef Name, ClangTidyContext *Context); MisplacedWideningCastCheck(StringRef Name, ClangTidyContext *Context);
void storeOptions(ClangTidyOptions::OptionMap &Opts) override; void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
private: private:
const bool CheckImplicitCasts; const bool CheckImplicitCasts;
}; };
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif #endif

clang-tools-extra/clang-tidy/bugprone/MoveForwardingReferenceCheck.h

Show All 26 Lines
/// the function that takes the forwarding reference as its parameter is called /// the function that takes the forwarding reference as its parameter is called
/// with an lvalue, that lvalue will be moved from (and hence placed into an /// with an lvalue, that lvalue will be moved from (and hence placed into an
/// indeterminate state) even though no std::move was applied to the lvalue at /// indeterminate state) even though no std::move was applied to the lvalue at
/// the call site. /// the call site.
// //
/// The check suggests replacing the std::move with a std::forward. /// The check suggests replacing the std::move with a std::forward.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-move-forwarding-reference.html /// https://clang.llvm.org/extra/clang-tidy/checks/bugprone-move-forwarding-reference.html
class MoveForwardingReferenceCheck : public ClangTidyCheck { class MoveForwardingReferenceCheck : public ClangTidyCheck {
public: public:
MoveForwardingReferenceCheck(StringRef Name, ClangTidyContext *Context) MoveForwardingReferenceCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus11; return LangOpts.CPlusPlus11;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_MOVEFORWARDINGREFERENCECHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_MOVEFORWARDINGREFERENCECHECK_H

clang-tools-extra/clang-tidy/bugprone/MultipleStatementMacroCheck.h

Show All 14 Lines
namespace tidy { namespace tidy {
namespace bugprone { namespace bugprone {
/// Detect multiple statement macros that are used in unbraced conditionals. /// Detect multiple statement macros that are used in unbraced conditionals.
/// Only the first statement of the macro will be inside the conditional and the /// Only the first statement of the macro will be inside the conditional and the
/// other ones will be executed unconditionally. /// other ones will be executed unconditionally.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-multiple-statement-macro.html /// https://clang.llvm.org/extra/clang-tidy/checks/bugprone-multiple-statement-macro.html
class MultipleStatementMacroCheck : public ClangTidyCheck { class MultipleStatementMacroCheck : public ClangTidyCheck {
public: public:
MultipleStatementMacroCheck(StringRef Name, ClangTidyContext *Context) MultipleStatementMacroCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_MULTIPLE_STATEMENT_MACRO_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_MULTIPLE_STATEMENT_MACRO_H

clang-tools-extra/clang-tidy/bugprone/NoEscapeCheck.h

Show All 14 Lines
namespace tidy { namespace tidy {
namespace bugprone { namespace bugprone {
/// Block arguments in `dispatch_async()` and `dispatch_after()` are guaranteed /// Block arguments in `dispatch_async()` and `dispatch_after()` are guaranteed
/// to escape. If those blocks capture any pointers with the `noescape` /// to escape. If those blocks capture any pointers with the `noescape`
/// attribute, then we warn the user of their error. /// attribute, then we warn the user of their error.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-no-escape.html /// https://clang.llvm.org/extra/clang-tidy/checks/bugprone-no-escape.html
class NoEscapeCheck : public ClangTidyCheck { class NoEscapeCheck : public ClangTidyCheck {
public: public:
NoEscapeCheck(StringRef Name, ClangTidyContext *Context) NoEscapeCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.Blocks; return LangOpts.Blocks;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_NOESCAPECHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_NOESCAPECHECK_H

clang-tools-extra/clang-tidy/bugprone/NotNullTerminatedResultCheck.h

Show All 16 Lines
/// Finds function calls where it is possible to cause a not null-terminated /// Finds function calls where it is possible to cause a not null-terminated
/// result. Usually the proper length of a string is 'strlen(src) + 1' or /// result. Usually the proper length of a string is 'strlen(src) + 1' or
/// equal length of this expression, because the null terminator needs an extra /// equal length of this expression, because the null terminator needs an extra
/// space. Without the null terminator it can result in undefined behaviour /// space. Without the null terminator it can result in undefined behaviour
/// when the string is read. /// when the string is read.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-not-null-terminated-result.html /// https://clang.llvm.org/extra/clang-tidy/checks/bugprone-not-null-terminated-result.html
class NotNullTerminatedResultCheck : public ClangTidyCheck { class NotNullTerminatedResultCheck : public ClangTidyCheck {
public: public:
NotNullTerminatedResultCheck(StringRef Name, ClangTidyContext *Context); NotNullTerminatedResultCheck(StringRef Name, ClangTidyContext *Context);
void storeOptions(ClangTidyOptions::OptionMap &Opts) override; void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP, void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
Preprocessor *ModuleExpanderPP) override; Preprocessor *ModuleExpanderPP) override;
Show All 34 Lines

clang-tools-extra/clang-tidy/bugprone/ParentVirtualCallCheck.h

Show All 12 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace bugprone { namespace bugprone {
/// Finds calls to grand..-parent virtual methods instead of parent's. /// Finds calls to grand..-parent virtual methods instead of parent's.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-parent-virtual-call.html /// https://clang.llvm.org/extra/clang-tidy/checks/bugprone-parent-virtual-call.html
class ParentVirtualCallCheck : public ClangTidyCheck { class ParentVirtualCallCheck : public ClangTidyCheck {
public: public:
ParentVirtualCallCheck(StringRef Name, ClangTidyContext *Context) ParentVirtualCallCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_PARENTVIRTUALCALLCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_PARENTVIRTUALCALLCHECK_H

clang-tools-extra/clang-tidy/bugprone/RedundantBranchConditionCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace bugprone { namespace bugprone {
/// Finds condition variables in nested `if` statements that were also checked /// Finds condition variables in nested `if` statements that were also checked
/// in the outer `if` statement and were not changed. /// in the outer `if` statement and were not changed.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-redundant-branch-condition.html /// https://clang.llvm.org/extra/clang-tidy/checks/bugprone-redundant-branch-condition.html
class RedundantBranchConditionCheck : public ClangTidyCheck { class RedundantBranchConditionCheck : public ClangTidyCheck {
public: public:
RedundantBranchConditionCheck(StringRef Name, ClangTidyContext *Context) RedundantBranchConditionCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
llvm::Optional<TraversalKind> getCheckTraversalKind() const override { llvm::Optional<TraversalKind> getCheckTraversalKind() const override {
return TK_IgnoreUnlessSpelledInSource; return TK_IgnoreUnlessSpelledInSource;
} }
}; };
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_REDUNDANTBRANCHCONDITIONCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_REDUNDANTBRANCHCONDITIONCHECK_H

clang-tools-extra/clang-tidy/bugprone/ReservedIdentifierCheck.h

Show All 23 Lines
/// * identifiers that begin with an underscore followed by an uppercase letter; /// * identifiers that begin with an underscore followed by an uppercase letter;
/// * identifiers in the global namespace that begin with an underscore. /// * identifiers in the global namespace that begin with an underscore.
/// ///
/// The C standard additionally reserves names beginning with a double /// The C standard additionally reserves names beginning with a double
/// underscore, while the C++ standard strengthens this to reserve names with a /// underscore, while the C++ standard strengthens this to reserve names with a
/// double underscore occurring anywhere. /// double underscore occurring anywhere.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-reserved-identifier.html /// https://clang.llvm.org/extra/clang-tidy/checks/bugprone-reserved-identifier.html
class ReservedIdentifierCheck final : public RenamerClangTidyCheck { class ReservedIdentifierCheck final : public RenamerClangTidyCheck {
const bool Invert; const bool Invert;
const std::vector<StringRef> AllowedIdentifiers; const std::vector<StringRef> AllowedIdentifiers;
public: public:
ReservedIdentifierCheck(StringRef Name, ClangTidyContext *Context); ReservedIdentifierCheck(StringRef Name, ClangTidyContext *Context);
void storeOptions(ClangTidyOptions::OptionMap &Opts) override; void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
Show All 17 Lines

clang-tools-extra/clang-tidy/bugprone/SignalHandlerCheck.h

Show All 15 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace bugprone { namespace bugprone {
/// Checker for signal handler functions. /// Checker for signal handler functions.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-signal-handler-check.html /// https://clang.llvm.org/extra/clang-tidy/checks/bugprone-signal-handler-check.html
class SignalHandlerCheck : public ClangTidyCheck { class SignalHandlerCheck : public ClangTidyCheck {
public: public:
enum class AsyncSafeFunctionSetKind { Minimal, POSIX }; enum class AsyncSafeFunctionSetKind { Minimal, POSIX };
SignalHandlerCheck(StringRef Name, ClangTidyContext *Context); SignalHandlerCheck(StringRef Name, ClangTidyContext *Context);
void storeOptions(ClangTidyOptions::OptionMap &Opts) override; void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override; bool isLanguageVersionSupported(const LangOptions &LangOpts) const override;
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
Show All 38 Lines

clang-tools-extra/clang-tidy/bugprone/SignedCharMisuseCheck.h

Show All 16 Lines
/// Finds those ``signed char`` -> integer conversions which might indicate a /// Finds those ``signed char`` -> integer conversions which might indicate a
/// programming error. The basic problem with the ``signed char``, that it might /// programming error. The basic problem with the ``signed char``, that it might
/// store the non-ASCII characters as negative values. This behavior can cause a /// store the non-ASCII characters as negative values. This behavior can cause a
/// misunderstanding of the written code both when an explicit and when an /// misunderstanding of the written code both when an explicit and when an
/// implicit conversion happens. /// implicit conversion happens.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-signed-char-misuse.html /// https://clang.llvm.org/extra/clang-tidy/checks/bugprone-signed-char-misuse.html
class SignedCharMisuseCheck : public ClangTidyCheck { class SignedCharMisuseCheck : public ClangTidyCheck {
public: public:
SignedCharMisuseCheck(StringRef Name, ClangTidyContext *Context); SignedCharMisuseCheck(StringRef Name, ClangTidyContext *Context);
void storeOptions(ClangTidyOptions::OptionMap &Opts) override; void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
Show All 15 Lines

clang-tools-extra/clang-tidy/bugprone/SizeofContainerCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace bugprone { namespace bugprone {
/// Find usages of sizeof on expressions of STL container types. Most likely the /// Find usages of sizeof on expressions of STL container types. Most likely the
/// user wanted to use `.size()` instead. /// user wanted to use `.size()` instead.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-sizeof-container.html /// https://clang.llvm.org/extra/clang-tidy/checks/bugprone-sizeof-container.html
class SizeofContainerCheck : public ClangTidyCheck { class SizeofContainerCheck : public ClangTidyCheck {
public: public:
SizeofContainerCheck(StringRef Name, ClangTidyContext *Context) SizeofContainerCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SIZEOFCONTAINERCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SIZEOFCONTAINERCHECK_H

clang-tools-extra/clang-tidy/bugprone/SizeofExpressionCheck.h

Show All 12 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace bugprone { namespace bugprone {
/// Find suspicious usages of sizeof expression. /// Find suspicious usages of sizeof expression.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-sizeof-expression.html /// https://clang.llvm.org/extra/clang-tidy/checks/bugprone-sizeof-expression.html
class SizeofExpressionCheck : public ClangTidyCheck { class SizeofExpressionCheck : public ClangTidyCheck {
public: public:
SizeofExpressionCheck(StringRef Name, ClangTidyContext *Context); SizeofExpressionCheck(StringRef Name, ClangTidyContext *Context);
void storeOptions(ClangTidyOptions::OptionMap &Opts) override; void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
private: private:
Show All 11 Lines

clang-tools-extra/clang-tidy/bugprone/SpuriouslyWakeUpFunctionsCheck.h

//===--- SpuriouslyWakeUpFunctionsCheck.h - clang-tidy ----------*- C++ -*-===// //===--- SpuriouslyWakeUpFunctionsCheck.h - clang-tidy ----------*- C++ -*-===//
Lint: Lint
Inline Actions

clang-format suggested style edits found:

Lint: Lint: clang-format suggested style edits found:
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SPURIOUSLYWAKEUPFUNCTIONSCHECK_H #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SPURIOUSLYWAKEUPFUNCTIONSCHECK_H
#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SPURIOUSLYWAKEUPFUNCTIONSCHECK_H #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SPURIOUSLYWAKEUPFUNCTIONSCHECK_H
#include "../ClangTidyCheck.h" #include "../ClangTidyCheck.h"
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace bugprone { namespace bugprone {
/// Finds ``cnd_wait``, ``cnd_timedwait``, ``wait``, ``wait_for``, or /// Finds ``cnd_wait``, ``cnd_timedwait``, ``wait``, ``wait_for``, or
/// ``wait_until`` function calls when the function is not invoked from a loop /// ``wait_until`` function calls when the function is not invoked from a loop
/// that checks whether a condition predicate holds or the function has a /// that checks whether a condition predicate holds or the function has a
/// condition parameter. /// condition parameter.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-spuriously-wake-up-functions.html /// https://clang.llvm.org/extra/clang-tidy/checks/bugprone-spuriously-wake-up-functions.html
class SpuriouslyWakeUpFunctionsCheck : public ClangTidyCheck { class SpuriouslyWakeUpFunctionsCheck : public ClangTidyCheck {
public: public:
SpuriouslyWakeUpFunctionsCheck(StringRef Name, ClangTidyContext *Context) SpuriouslyWakeUpFunctionsCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SPURIOUSLYWAKEUPFUNCTIONSCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SPURIOUSLYWAKEUPFUNCTIONSCHECK_H

clang-tools-extra/clang-tidy/bugprone/StringConstructorCheck.h

Show All 12 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace bugprone { namespace bugprone {
/// Finds suspicious string constructor and check their parameters. /// Finds suspicious string constructor and check their parameters.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-string-constructor.html /// https://clang.llvm.org/extra/clang-tidy/checks/bugprone-string-constructor.html
class StringConstructorCheck : public ClangTidyCheck { class StringConstructorCheck : public ClangTidyCheck {
public: public:
StringConstructorCheck(StringRef Name, ClangTidyContext *Context); StringConstructorCheck(StringRef Name, ClangTidyContext *Context);
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
void storeOptions(ClangTidyOptions::OptionMap &Opts) override; void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
Show All 14 Lines

clang-tools-extra/clang-tidy/bugprone/StringIntegerAssignmentCheck.h

Show All 12 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace bugprone { namespace bugprone {
/// Finds instances where an integer is assigned to a string. /// Finds instances where an integer is assigned to a string.
/// ///
/// For more details see: /// For more details see:
/// http://clang.llvm.org/extra/clang-tidy/checks/misc-string-assignment.html /// https://clang.llvm.org/extra/clang-tidy/checks/misc-string-assignment.html
class StringIntegerAssignmentCheck : public ClangTidyCheck { class StringIntegerAssignmentCheck : public ClangTidyCheck {
public: public:
StringIntegerAssignmentCheck(StringRef Name, ClangTidyContext *Context) StringIntegerAssignmentCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_STRINGINTEGERASSIGNMENTCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_STRINGINTEGERASSIGNMENTCHECK_H

clang-tools-extra/clang-tidy/bugprone/StringLiteralWithEmbeddedNulCheck.h

Show All 12 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace bugprone { namespace bugprone {
/// Find suspicious string literals with embedded NUL characters. /// Find suspicious string literals with embedded NUL characters.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-string-literal-with-embedded-nul.html /// https://clang.llvm.org/extra/clang-tidy/checks/bugprone-string-literal-with-embedded-nul.html
class StringLiteralWithEmbeddedNulCheck : public ClangTidyCheck { class StringLiteralWithEmbeddedNulCheck : public ClangTidyCheck {
public: public:
StringLiteralWithEmbeddedNulCheck(StringRef Name, ClangTidyContext *Context) StringLiteralWithEmbeddedNulCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_STRINGLITERALWITHEMBEDDEDNULCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_STRINGLITERALWITHEMBEDDEDNULCHECK_H

clang-tools-extra/clang-tidy/bugprone/StringviewNullptrCheck.h

Show All 26 Lines
/// add an explicitly-deleted overload to catch some of these cases: /// add an explicitly-deleted overload to catch some of these cases:
/// wg21.link/p2166 /// wg21.link/p2166
/// ///
/// To catch the additional cases of `NULL` (which expands to `__null`) and /// To catch the additional cases of `NULL` (which expands to `__null`) and
/// `0`, first run the ``modernize-use-nullptr`` check to convert the callers /// `0`, first run the ``modernize-use-nullptr`` check to convert the callers
/// to `nullptr`. /// to `nullptr`.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-stringview-nullptr.html /// https://clang.llvm.org/extra/clang-tidy/checks/bugprone-stringview-nullptr.html
class StringviewNullptrCheck : public utils::TransformerClangTidyCheck { class StringviewNullptrCheck : public utils::TransformerClangTidyCheck {
public: public:
StringviewNullptrCheck(StringRef Name, ClangTidyContext *Context); StringviewNullptrCheck(StringRef Name, ClangTidyContext *Context);
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus17; return LangOpts.CPlusPlus17;
} }
}; };
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_STRINGVIEWNULLPTRCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_STRINGVIEWNULLPTRCHECK_H

clang-tools-extra/clang-tidy/bugprone/SuspiciousEnumUsageCheck.h

Show All 12 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace bugprone { namespace bugprone {
/// The checker detects various cases when an enum is probably misused (as a /// The checker detects various cases when an enum is probably misused (as a
/// bitmask). /// bitmask).
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-suspicious-enum-usage.html /// https://clang.llvm.org/extra/clang-tidy/checks/bugprone-suspicious-enum-usage.html
class SuspiciousEnumUsageCheck : public ClangTidyCheck { class SuspiciousEnumUsageCheck : public ClangTidyCheck {
public: public:
SuspiciousEnumUsageCheck(StringRef Name, ClangTidyContext *Context); SuspiciousEnumUsageCheck(StringRef Name, ClangTidyContext *Context);
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
void storeOptions(ClangTidyOptions::OptionMap &Opts) override; void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
llvm::Optional<TraversalKind> getCheckTraversalKind() const override { llvm::Optional<TraversalKind> getCheckTraversalKind() const override {
return TK_IgnoreUnlessSpelledInSource; return TK_IgnoreUnlessSpelledInSource;
Show All 12 Lines

clang-tools-extra/clang-tidy/bugprone/SuspiciousIncludeCheck.h

Show All 28 Lines
/// "." prefix) ";h;hh;hpp;hxx" by default. For extension-less header /// "." prefix) ";h;hh;hpp;hxx" by default. For extension-less header
/// files, using an empty string or leaving an empty string between ";" if /// files, using an empty string or leaving an empty string between ";" if
/// there are other filename extensions. /// there are other filename extensions.
/// ///
/// - `ImplementationFileExtensions`: likewise, a semicolon-separated list of /// - `ImplementationFileExtensions`: likewise, a semicolon-separated list of
/// filename extensions of implementation files. "c;cc;cpp;cxx" by default. /// filename extensions of implementation files. "c;cc;cpp;cxx" by default.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-suspicious-include.html /// https://clang.llvm.org/extra/clang-tidy/checks/bugprone-suspicious-include.html
class SuspiciousIncludeCheck : public ClangTidyCheck { class SuspiciousIncludeCheck : public ClangTidyCheck {
public: public:
SuspiciousIncludeCheck(StringRef Name, ClangTidyContext *Context); SuspiciousIncludeCheck(StringRef Name, ClangTidyContext *Context);
void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP, void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
Preprocessor *ModuleExpanderPP) override; Preprocessor *ModuleExpanderPP) override;
void storeOptions(ClangTidyOptions::OptionMap &Opts) override; void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
utils::FileExtensionsSet HeaderFileExtensions; utils::FileExtensionsSet HeaderFileExtensions;
Show All 12 Lines

clang-tools-extra/clang-tidy/bugprone/SuspiciousMemoryComparisonCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace bugprone { namespace bugprone {
/// Finds potentially incorrect calls to ``memcmp()`` based on properties of the /// Finds potentially incorrect calls to ``memcmp()`` based on properties of the
/// arguments. /// arguments.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-suspicious-memory-comparison.html /// https://clang.llvm.org/extra/clang-tidy/checks/bugprone-suspicious-memory-comparison.html
class SuspiciousMemoryComparisonCheck : public ClangTidyCheck { class SuspiciousMemoryComparisonCheck : public ClangTidyCheck {
public: public:
SuspiciousMemoryComparisonCheck(StringRef Name, ClangTidyContext *Context) SuspiciousMemoryComparisonCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SUSPICIOUSMEMORYCOMPARISONCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SUSPICIOUSMEMORYCOMPARISONCHECK_H

clang-tools-extra/clang-tidy/bugprone/SuspiciousMemsetUsageCheck.h

Show All 12 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace bugprone { namespace bugprone {
/// Finds memset calls with potential mistakes in their arguments. /// Finds memset calls with potential mistakes in their arguments.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-suspicious-memset-usage.html /// https://clang.llvm.org/extra/clang-tidy/checks/bugprone-suspicious-memset-usage.html
class SuspiciousMemsetUsageCheck : public ClangTidyCheck { class SuspiciousMemsetUsageCheck : public ClangTidyCheck {
public: public:
SuspiciousMemsetUsageCheck(StringRef Name, ClangTidyContext *Context) SuspiciousMemsetUsageCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
llvm::Optional<TraversalKind> getCheckTraversalKind() const override { llvm::Optional<TraversalKind> getCheckTraversalKind() const override {
return TK_IgnoreUnlessSpelledInSource; return TK_IgnoreUnlessSpelledInSource;
} }
}; };
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SUSPICIOUS_MEMSET_USAGE_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SUSPICIOUS_MEMSET_USAGE_H

clang-tools-extra/clang-tidy/bugprone/SuspiciousMissingCommaCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace bugprone { namespace bugprone {
/// This check finds string literals which are probably concatenated /// This check finds string literals which are probably concatenated
/// accidentally. /// accidentally.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-suspicious-missing-comma.html /// https://clang.llvm.org/extra/clang-tidy/checks/bugprone-suspicious-missing-comma.html
class SuspiciousMissingCommaCheck : public ClangTidyCheck { class SuspiciousMissingCommaCheck : public ClangTidyCheck {
public: public:
SuspiciousMissingCommaCheck(StringRef Name, ClangTidyContext *Context); SuspiciousMissingCommaCheck(StringRef Name, ClangTidyContext *Context);
void storeOptions(ClangTidyOptions::OptionMap &Opts) override; void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
private: private:
Show All 13 Lines

clang-tools-extra/clang-tidy/bugprone/SuspiciousSemicolonCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace bugprone { namespace bugprone {
/// This check finds semicolon that modifies the meaning of the program /// This check finds semicolon that modifies the meaning of the program
/// unintendedly. /// unintendedly.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-suspicious-semicolon.html /// https://clang.llvm.org/extra/clang-tidy/checks/bugprone-suspicious-semicolon.html
class SuspiciousSemicolonCheck : public ClangTidyCheck { class SuspiciousSemicolonCheck : public ClangTidyCheck {
public: public:
SuspiciousSemicolonCheck(StringRef Name, ClangTidyContext *Context) SuspiciousSemicolonCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SUSPICIOUSSEMICOLONCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SUSPICIOUSSEMICOLONCHECK_H

clang-tools-extra/clang-tidy/bugprone/SuspiciousStringCompareCheck.h

Show All 12 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace bugprone { namespace bugprone {
/// Find suspicious calls to string compare functions. /// Find suspicious calls to string compare functions.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-suspicious-string-compare.html /// https://clang.llvm.org/extra/clang-tidy/checks/bugprone-suspicious-string-compare.html
class SuspiciousStringCompareCheck : public ClangTidyCheck { class SuspiciousStringCompareCheck : public ClangTidyCheck {
public: public:
SuspiciousStringCompareCheck(StringRef Name, ClangTidyContext *Context); SuspiciousStringCompareCheck(StringRef Name, ClangTidyContext *Context);
void storeOptions(ClangTidyOptions::OptionMap &Opts) override; void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
private: private:
Show All 10 Lines

clang-tools-extra/clang-tidy/bugprone/TerminatingContinueCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace bugprone { namespace bugprone {
/// Checks if a 'continue' statement terminates the loop (i.e. the loop has /// Checks if a 'continue' statement terminates the loop (i.e. the loop has
/// a condition which always evaluates to false). /// a condition which always evaluates to false).
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-terminating-continue.html /// https://clang.llvm.org/extra/clang-tidy/checks/bugprone-terminating-continue.html
class TerminatingContinueCheck : public ClangTidyCheck { class TerminatingContinueCheck : public ClangTidyCheck {
public: public:
TerminatingContinueCheck(StringRef Name, ClangTidyContext *Context) TerminatingContinueCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_TERMINATINGCONTINUECHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_TERMINATINGCONTINUECHECK_H

clang-tools-extra/clang-tidy/bugprone/ThrowKeywordMissingCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace bugprone { namespace bugprone {
/// Emits a warning about temporary objects whose type is (or is derived from) a /// Emits a warning about temporary objects whose type is (or is derived from) a
/// class that has 'EXCEPTION', 'Exception' or 'exception' in its name. /// class that has 'EXCEPTION', 'Exception' or 'exception' in its name.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-throw-keyword-missing.html /// https://clang.llvm.org/extra/clang-tidy/checks/bugprone-throw-keyword-missing.html
class ThrowKeywordMissingCheck : public ClangTidyCheck { class ThrowKeywordMissingCheck : public ClangTidyCheck {
public: public:
ThrowKeywordMissingCheck(StringRef Name, ClangTidyContext *Context) ThrowKeywordMissingCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
Show All 11 Lines

clang-tools-extra/clang-tidy/bugprone/TooSmallLoopVariableCheck.h

Show All 20 Lines
/// If the loop variable's type is too small we might end up in an infinite /// If the loop variable's type is too small we might end up in an infinite
/// loop. Example: /// loop. Example:
/// \code /// \code
/// long size = 294967296l; /// long size = 294967296l;
/// for (short i = 0; i < size; ++i) {} { ... } /// for (short i = 0; i < size; ++i) {} { ... }
/// \endcode /// \endcode
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-too-small-loop-variable.html /// https://clang.llvm.org/extra/clang-tidy/checks/bugprone-too-small-loop-variable.html
class TooSmallLoopVariableCheck : public ClangTidyCheck { class TooSmallLoopVariableCheck : public ClangTidyCheck {
public: public:
TooSmallLoopVariableCheck(StringRef Name, ClangTidyContext *Context); TooSmallLoopVariableCheck(StringRef Name, ClangTidyContext *Context);
void storeOptions(ClangTidyOptions::OptionMap &Opts) override; void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
Show All 9 Lines

clang-tools-extra/clang-tidy/bugprone/UncheckedOptionalAccessCheck.h

Show All 14 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace bugprone { namespace bugprone {
/// Warns when the code is unwrapping a `std::optional<T>`, `absl::optional<T>`, /// Warns when the code is unwrapping a `std::optional<T>`, `absl::optional<T>`,
/// or `base::Optional<T>` object without assuring that it contains a value. /// or `base::Optional<T>` object without assuring that it contains a value.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-unchecked-optional-access.html /// https://clang.llvm.org/extra/clang-tidy/checks/bugprone-unchecked-optional-access.html
class UncheckedOptionalAccessCheck : public ClangTidyCheck { class UncheckedOptionalAccessCheck : public ClangTidyCheck {
public: public:
UncheckedOptionalAccessCheck(StringRef Name, ClangTidyContext *Context) UncheckedOptionalAccessCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
}; };
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_UNCHECKEDOPTIONALACCESSCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_UNCHECKEDOPTIONALACCESSCHECK_H

clang-tools-extra/clang-tidy/bugprone/UndefinedMemoryManipulationCheck.h

Show All 14 Lines
namespace tidy { namespace tidy {
namespace bugprone { namespace bugprone {
/// Finds calls of memory manipulation functions ``memset()``, ``memcpy()`` and /// Finds calls of memory manipulation functions ``memset()``, ``memcpy()`` and
/// ``memmove()`` on not TriviallyCopyable objects resulting in undefined /// ``memmove()`` on not TriviallyCopyable objects resulting in undefined
/// behavior. /// behavior.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-undefined-memory-manipulation.html /// https://clang.llvm.org/extra/clang-tidy/checks/bugprone-undefined-memory-manipulation.html
class UndefinedMemoryManipulationCheck : public ClangTidyCheck { class UndefinedMemoryManipulationCheck : public ClangTidyCheck {
public: public:
UndefinedMemoryManipulationCheck(StringRef Name, ClangTidyContext *Context) UndefinedMemoryManipulationCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_UNDEFINED_MEMORY_MANIPULATION_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_UNDEFINED_MEMORY_MANIPULATION_H

clang-tools-extra/clang-tidy/bugprone/UnhandledExceptionAtNewCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace bugprone { namespace bugprone {
/// Finds calls to 'new' that may throw unhandled exception at allocation /// Finds calls to 'new' that may throw unhandled exception at allocation
/// failure. /// failure.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-unhandled-exception-at-new.html /// https://clang.llvm.org/extra/clang-tidy/checks/bugprone-unhandled-exception-at-new.html
class UnhandledExceptionAtNewCheck : public ClangTidyCheck { class UnhandledExceptionAtNewCheck : public ClangTidyCheck {
public: public:
UnhandledExceptionAtNewCheck(StringRef Name, ClangTidyContext *Context); UnhandledExceptionAtNewCheck(StringRef Name, ClangTidyContext *Context);
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus && LangOpts.CXXExceptions; return LangOpts.CPlusPlus && LangOpts.CXXExceptions;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_UNHANDLEDEXCEPTIONATNEWCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_UNHANDLEDEXCEPTIONATNEWCHECK_H

clang-tools-extra/clang-tidy/bugprone/UnhandledSelfAssignmentCheck.h

Show All 14 Lines
namespace tidy { namespace tidy {
namespace bugprone { namespace bugprone {
/// Finds user-defined copy assignment operators which do not protect the code /// Finds user-defined copy assignment operators which do not protect the code
/// against self-assignment either by checking self-assignment explicitly or /// against self-assignment either by checking self-assignment explicitly or
/// using the copy-and-swap or the copy-and-move method. /// using the copy-and-swap or the copy-and-move method.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-unhandled-self-assignment.html /// https://clang.llvm.org/extra/clang-tidy/checks/bugprone-unhandled-self-assignment.html
class UnhandledSelfAssignmentCheck : public ClangTidyCheck { class UnhandledSelfAssignmentCheck : public ClangTidyCheck {
public: public:
UnhandledSelfAssignmentCheck(StringRef Name, ClangTidyContext *Context); UnhandledSelfAssignmentCheck(StringRef Name, ClangTidyContext *Context);
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
void storeOptions(ClangTidyOptions::OptionMap &Opts) override; void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
Show All 12 Lines

clang-tools-extra/clang-tidy/bugprone/UnusedRaiiCheck.h

Show All 12 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace bugprone { namespace bugprone {
/// Finds temporaries that look like RAII objects. /// Finds temporaries that look like RAII objects.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-unused-raii.html /// https://clang.llvm.org/extra/clang-tidy/checks/bugprone-unused-raii.html
class UnusedRaiiCheck : public ClangTidyCheck { class UnusedRaiiCheck : public ClangTidyCheck {
public: public:
UnusedRaiiCheck(StringRef Name, ClangTidyContext *Context) UnusedRaiiCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
Show All 11 Lines

clang-tools-extra/clang-tidy/bugprone/UnusedReturnValueCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace bugprone { namespace bugprone {
/// Detects function calls where the return value is unused. /// Detects function calls where the return value is unused.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-unused-return-value.html /// https://clang.llvm.org/extra/clang-tidy/checks/bugprone-unused-return-value.html
class UnusedReturnValueCheck : public ClangTidyCheck { class UnusedReturnValueCheck : public ClangTidyCheck {
public: public:
UnusedReturnValueCheck(StringRef Name, ClangTidyContext *Context); UnusedReturnValueCheck(StringRef Name, ClangTidyContext *Context);
void storeOptions(ClangTidyOptions::OptionMap &Opts) override; void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
private: private:
std::string CheckedFunctions; std::string CheckedFunctions;
}; };
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_UNUSEDRETURNVALUECHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_UNUSEDRETURNVALUECHECK_H

clang-tools-extra/clang-tidy/bugprone/UseAfterMoveCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace bugprone { namespace bugprone {
/// The check warns if an object is used after it has been moved, without an /// The check warns if an object is used after it has been moved, without an
/// intervening reinitialization. /// intervening reinitialization.
/// ///
/// For details, see the user-facing documentation: /// For details, see the user-facing documentation:
/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-use-after-move.html /// https://clang.llvm.org/extra/clang-tidy/checks/bugprone-use-after-move.html
class UseAfterMoveCheck : public ClangTidyCheck { class UseAfterMoveCheck : public ClangTidyCheck {
public: public:
UseAfterMoveCheck(StringRef Name, ClangTidyContext *Context) UseAfterMoveCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus11; return LangOpts.CPlusPlus11;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_USEAFTERMOVECHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_USEAFTERMOVECHECK_H

clang-tools-extra/clang-tidy/bugprone/VirtualNearMissCheck.h

Show All 16 Lines
namespace bugprone { namespace bugprone {
/// Checks for near miss of virtual methods. /// Checks for near miss of virtual methods.
/// ///
/// For a method in a derived class, this check looks for virtual method with a /// For a method in a derived class, this check looks for virtual method with a
/// very similar name and an identical signature defined in a base class. /// very similar name and an identical signature defined in a base class.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-virtual-near-miss.html /// https://clang.llvm.org/extra/clang-tidy/checks/bugprone-virtual-near-miss.html
class VirtualNearMissCheck : public ClangTidyCheck { class VirtualNearMissCheck : public ClangTidyCheck {
public: public:
VirtualNearMissCheck(StringRef Name, ClangTidyContext *Context) VirtualNearMissCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
Show All 34 Lines

clang-tools-extra/clang-tidy/cert/CommandProcessorCheck.h

Show All 15 Lines
namespace cert { namespace cert {
/// Execution of a command processor can lead to security vulnerabilities, /// Execution of a command processor can lead to security vulnerabilities,
/// and is generally not required. Instead, prefer to launch executables /// and is generally not required. Instead, prefer to launch executables
/// directly via mechanisms that give you more control over what executable is /// directly via mechanisms that give you more control over what executable is
/// actually launched. /// actually launched.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/cert-env33-c.html /// https://clang.llvm.org/extra/clang-tidy/checks/cert-env33-c.html
class CommandProcessorCheck : public ClangTidyCheck { class CommandProcessorCheck : public ClangTidyCheck {
public: public:
CommandProcessorCheck(StringRef Name, ClangTidyContext *Context) CommandProcessorCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace cert } // namespace cert
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_COMMAND_PROCESSOR_CHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_COMMAND_PROCESSOR_CHECK_H

clang-tools-extra/clang-tidy/cert/DefaultOperatorNewAlignmentCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace cert { namespace cert {
/// Checks if an object of type with extended alignment is allocated by using /// Checks if an object of type with extended alignment is allocated by using
/// the default operator new. /// the default operator new.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/cert-mem57-cpp.html /// https://clang.llvm.org/extra/clang-tidy/checks/cert-mem57-cpp.html
class DefaultOperatorNewAlignmentCheck : public ClangTidyCheck { class DefaultOperatorNewAlignmentCheck : public ClangTidyCheck {
public: public:
DefaultOperatorNewAlignmentCheck(StringRef Name, ClangTidyContext *Context) DefaultOperatorNewAlignmentCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return !LangOpts.CPlusPlus17; return !LangOpts.CPlusPlus17;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace cert } // namespace cert
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_DEFAULTOPERATORNEWALIGNMENTCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_DEFAULTOPERATORNEWALIGNMENTCHECK_H

clang-tools-extra/clang-tidy/cert/FloatLoopCounter.h

Show All 14 Lines
namespace tidy { namespace tidy {
namespace cert { namespace cert {
/// This check diagnoses when the loop induction expression of a for loop has /// This check diagnoses when the loop induction expression of a for loop has
/// floating-point type. The check corresponds to: /// floating-point type. The check corresponds to:
/// https://www.securecoding.cert.org/confluence/display/c/FLP30-C.+Do+not+use+floating-point+variables+as+loop+counters /// https://www.securecoding.cert.org/confluence/display/c/FLP30-C.+Do+not+use+floating-point+variables+as+loop+counters
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/cert-flp30-c.html /// https://clang.llvm.org/extra/clang-tidy/checks/cert-flp30-c.html
class FloatLoopCounter : public ClangTidyCheck { class FloatLoopCounter : public ClangTidyCheck {
public: public:
FloatLoopCounter(StringRef Name, ClangTidyContext *Context) FloatLoopCounter(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace cert } // namespace cert
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_FLOAT_LOOP_COUNTER_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_FLOAT_LOOP_COUNTER_H

clang-tools-extra/clang-tidy/cert/LimitedRandomnessCheck.h

Show All 15 Lines
namespace cert { namespace cert {
/// Pseudorandom number generators are not genuinely random. The result of the /// Pseudorandom number generators are not genuinely random. The result of the
/// std::rand() function makes no guarantees as to the quality of the random /// std::rand() function makes no guarantees as to the quality of the random
/// sequence produced. /// sequence produced.
/// This check warns for the usage of std::rand() function. /// This check warns for the usage of std::rand() function.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/cert-msc50-cpp.html /// https://clang.llvm.org/extra/clang-tidy/checks/cert-msc50-cpp.html
class LimitedRandomnessCheck : public ClangTidyCheck { class LimitedRandomnessCheck : public ClangTidyCheck {
public: public:
LimitedRandomnessCheck(StringRef Name, ClangTidyContext *Context) LimitedRandomnessCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace cert } // namespace cert
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_LIMITED_RANDOMNESS_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_LIMITED_RANDOMNESS_H

clang-tools-extra/clang-tidy/cert/MutatingCopyCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace cert { namespace cert {
/// Finds assignments to the copied object and its direct or indirect members /// Finds assignments to the copied object and its direct or indirect members
/// in copy constructors and copy assignment operators. /// in copy constructors and copy assignment operators.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/cert-oop58-cpp.html /// https://clang.llvm.org/extra/clang-tidy/checks/cert-oop58-cpp.html
class MutatingCopyCheck : public ClangTidyCheck { class MutatingCopyCheck : public ClangTidyCheck {
public: public:
MutatingCopyCheck(StringRef Name, ClangTidyContext *Context) MutatingCopyCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace cert } // namespace cert
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_MUTATINGCOPYCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_MUTATINGCOPYCHECK_H

clang-tools-extra/clang-tidy/cert/NonTrivialTypesLibcMemoryCallsCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace cert { namespace cert {
/// Flags use of the `C` standard library functions 'memset', 'memcpy' and /// Flags use of the `C` standard library functions 'memset', 'memcpy' and
/// 'memcmp' and similar derivatives on non-trivial types. /// 'memcmp' and similar derivatives on non-trivial types.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/cert-oop57-cpp.html /// https://clang.llvm.org/extra/clang-tidy/checks/cert-oop57-cpp.html
class NonTrivialTypesLibcMemoryCallsCheck : public ClangTidyCheck { class NonTrivialTypesLibcMemoryCallsCheck : public ClangTidyCheck {
public: public:
NonTrivialTypesLibcMemoryCallsCheck(StringRef Name, NonTrivialTypesLibcMemoryCallsCheck(StringRef Name,
ClangTidyContext *Context); ClangTidyContext *Context);
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus && !LangOpts.ObjC; return LangOpts.CPlusPlus && !LangOpts.ObjC;
} }
void storeOptions(ClangTidyOptions::OptionMap &Opts) override; void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
Show All 14 Lines

clang-tools-extra/clang-tidy/cert/ProperlySeededRandomGeneratorCheck.h

Show All 16 Lines
namespace cert { namespace cert {
/// Random number generator must be seeded properly. /// Random number generator must be seeded properly.
/// ///
/// A random number generator initialized with default value or a /// A random number generator initialized with default value or a
/// constant expression is a security vulnerability. /// constant expression is a security vulnerability.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/cert-properly-seeded-random-generator.html /// https://clang.llvm.org/extra/clang-tidy/checks/cert-properly-seeded-random-generator.html
class ProperlySeededRandomGeneratorCheck : public ClangTidyCheck { class ProperlySeededRandomGeneratorCheck : public ClangTidyCheck {
public: public:
ProperlySeededRandomGeneratorCheck(StringRef Name, ClangTidyContext *Context); ProperlySeededRandomGeneratorCheck(StringRef Name, ClangTidyContext *Context);
void storeOptions(ClangTidyOptions::OptionMap &Opts) override; void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
private: private:
Show All 13 Lines

clang-tools-extra/clang-tidy/cert/SetLongJmpCheck.h

Show All 12 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace cert { namespace cert {
/// Guards against use of setjmp/longjmp in C++ code /// Guards against use of setjmp/longjmp in C++ code
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/cert-err52-cpp.html /// https://clang.llvm.org/extra/clang-tidy/checks/cert-err52-cpp.html
class SetLongJmpCheck : public ClangTidyCheck { class SetLongJmpCheck : public ClangTidyCheck {
public: public:
SetLongJmpCheck(StringRef Name, ClangTidyContext *Context) SetLongJmpCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
Show All 10 Lines

clang-tools-extra/clang-tidy/cert/StrToNumCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace cert { namespace cert {
/// Guards against use of string conversion functions that do not have /// Guards against use of string conversion functions that do not have
/// reasonable error handling for conversion errors. /// reasonable error handling for conversion errors.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/cert-err34-c.html /// https://clang.llvm.org/extra/clang-tidy/checks/cert-err34-c.html
class StrToNumCheck : public ClangTidyCheck { class StrToNumCheck : public ClangTidyCheck {
public: public:
StrToNumCheck(StringRef Name, ClangTidyContext *Context) StrToNumCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace cert } // namespace cert
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_STRTONUMCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_STRTONUMCHECK_H

clang-tools-extra/clang-tidy/cert/ThrownExceptionTypeCheck.h

Show All 12 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace cert { namespace cert {
/// Checks whether a thrown object is nothrow copy constructible. /// Checks whether a thrown object is nothrow copy constructible.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/cert-err60-cpp.html /// https://clang.llvm.org/extra/clang-tidy/checks/cert-err60-cpp.html
class ThrownExceptionTypeCheck : public ClangTidyCheck { class ThrownExceptionTypeCheck : public ClangTidyCheck {
public: public:
ThrownExceptionTypeCheck(StringRef Name, ClangTidyContext *Context) ThrownExceptionTypeCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace cert } // namespace cert
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_THROWNEXCEPTIONTYPECHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_THROWNEXCEPTIONTYPECHECK_H

clang-tools-extra/clang-tidy/cert/VariadicFunctionDefCheck.h

Show All 12 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace cert { namespace cert {
/// Guards against any C-style variadic function definitions (not declarations). /// Guards against any C-style variadic function definitions (not declarations).
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/cert-dcl50-cpp.html /// https://clang.llvm.org/extra/clang-tidy/checks/cert-dcl50-cpp.html
class VariadicFunctionDefCheck : public ClangTidyCheck { class VariadicFunctionDefCheck : public ClangTidyCheck {
public: public:
VariadicFunctionDefCheck(StringRef Name, ClangTidyContext *Context) VariadicFunctionDefCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace cert } // namespace cert
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_VARIADICFUNCTIONDEF_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_VARIADICFUNCTIONDEF_H

clang-tools-extra/clang-tidy/concurrency/MtUnsafeCheck.h

Show All 12 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace concurrency { namespace concurrency {
/// Checks that non-thread-safe functions are not used. /// Checks that non-thread-safe functions are not used.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/threads-mt-unsafe.html /// https://clang.llvm.org/extra/clang-tidy/checks/threads-mt-unsafe.html
class MtUnsafeCheck : public ClangTidyCheck { class MtUnsafeCheck : public ClangTidyCheck {
public: public:
MtUnsafeCheck(StringRef Name, ClangTidyContext *Context); MtUnsafeCheck(StringRef Name, ClangTidyContext *Context);
void storeOptions(ClangTidyOptions::OptionMap &Opts) override; void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
enum class FunctionSet { enum class FunctionSet {
Show All 14 Lines

clang-tools-extra/clang-tidy/concurrency/ThreadCanceltypeAsynchronousCheck.h

Show All 12 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace concurrency { namespace concurrency {
/// Finds ``pthread_setcanceltype`` function calls where a thread's /// Finds ``pthread_setcanceltype`` function calls where a thread's
/// cancellation type is set to asynchronous. /// cancellation type is set to asynchronous.
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/concurrency-thread-canceltype-asynchronous.html /// https://clang.llvm.org/extra/clang-tidy/checks/concurrency-thread-canceltype-asynchronous.html
class ThreadCanceltypeAsynchronousCheck : public ClangTidyCheck { class ThreadCanceltypeAsynchronousCheck : public ClangTidyCheck {
public: public:
ThreadCanceltypeAsynchronousCheck(StringRef Name, ClangTidyContext *Context) ThreadCanceltypeAsynchronousCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace concurrency } // namespace concurrency
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CONCURRENCY_THREADCANCELTYPEASYNCHRONOUSCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CONCURRENCY_THREADCANCELTYPEASYNCHRONOUSCHECK_H

clang-tools-extra/clang-tidy/cppcoreguidelines/AvoidGotoCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace cppcoreguidelines { namespace cppcoreguidelines {
/// The usage of ``goto`` for control flow is error prone and should be replaced /// The usage of ``goto`` for control flow is error prone and should be replaced
/// with looping constructs. Only forward jumps in nested loops are accepted. /// with looping constructs. Only forward jumps in nested loops are accepted.
// //
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-avoid-goto.html /// https://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-avoid-goto.html
class AvoidGotoCheck : public ClangTidyCheck { class AvoidGotoCheck : public ClangTidyCheck {
public: public:
AvoidGotoCheck(StringRef Name, ClangTidyContext *Context) AvoidGotoCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace cppcoreguidelines } // namespace cppcoreguidelines
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_AVOIDGOTOCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_AVOIDGOTOCHECK_H

clang-tools-extra/clang-tidy/cppcoreguidelines/AvoidNonConstGlobalVariablesCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace cppcoreguidelines { namespace cppcoreguidelines {
/// Non-const global variables hide dependencies and make the dependencies /// Non-const global variables hide dependencies and make the dependencies
/// subject to unpredictable changes. /// subject to unpredictable changes.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-avoid-non-const-global-variables.html /// https://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-avoid-non-const-global-variables.html
class AvoidNonConstGlobalVariablesCheck : public ClangTidyCheck { class AvoidNonConstGlobalVariablesCheck : public ClangTidyCheck {
public: public:
AvoidNonConstGlobalVariablesCheck(StringRef Name, ClangTidyContext *Context) AvoidNonConstGlobalVariablesCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace cppcoreguidelines } // namespace cppcoreguidelines
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_AVOIDNONCONSTGLOBALVARIABLESCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_AVOIDNONCONSTGLOBALVARIABLESCHECK_H

clang-tools-extra/clang-tidy/cppcoreguidelines/InitVariablesCheck.h

Show All 14 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace cppcoreguidelines { namespace cppcoreguidelines {
/// Find uninitialized local variables. /// Find uninitialized local variables.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-init-variables.html /// https://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-init-variables.html
class InitVariablesCheck : public ClangTidyCheck { class InitVariablesCheck : public ClangTidyCheck {
public: public:
InitVariablesCheck(StringRef Name, ClangTidyContext *Context); InitVariablesCheck(StringRef Name, ClangTidyContext *Context);
void storeOptions(ClangTidyOptions::OptionMap &Opts) override; void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP, void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
Preprocessor *ModuleExpanderPP) override; Preprocessor *ModuleExpanderPP) override;
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
Show All 11 Lines

clang-tools-extra/clang-tidy/cppcoreguidelines/InterfacesGlobalInitCheck.h

Show All 12 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace cppcoreguidelines { namespace cppcoreguidelines {
/// Flags possible initialization order issues of static variables. /// Flags possible initialization order issues of static variables.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-interfaces-global-init.html /// https://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-interfaces-global-init.html
class InterfacesGlobalInitCheck : public ClangTidyCheck { class InterfacesGlobalInitCheck : public ClangTidyCheck {
public: public:
InterfacesGlobalInitCheck(StringRef Name, ClangTidyContext *Context) InterfacesGlobalInitCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace cppcoreguidelines } // namespace cppcoreguidelines
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_INTERFACES_GLOBAL_INIT_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_INTERFACES_GLOBAL_INIT_H

clang-tools-extra/clang-tidy/cppcoreguidelines/MacroUsageCheck.h

Show All 16 Lines
class MacroDirective; class MacroDirective;
namespace tidy { namespace tidy {
namespace cppcoreguidelines { namespace cppcoreguidelines {
/// Find macro usage that is considered problematic because better language /// Find macro usage that is considered problematic because better language
/// constructs exist for the task. /// constructs exist for the task.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-macro-usage.html /// https://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-macro-usage.html
class MacroUsageCheck : public ClangTidyCheck { class MacroUsageCheck : public ClangTidyCheck {
public: public:
MacroUsageCheck(StringRef Name, ClangTidyContext *Context) MacroUsageCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context), : ClangTidyCheck(Name, Context),
AllowedRegexp(Options.get("AllowedRegexp", "^DEBUG_*")), AllowedRegexp(Options.get("AllowedRegexp", "^DEBUG_*")),
CheckCapsOnly(Options.get("CheckCapsOnly", false)), CheckCapsOnly(Options.get("CheckCapsOnly", false)),
IgnoreCommandLineMacros(Options.get("IgnoreCommandLineMacros", true)) {} IgnoreCommandLineMacros(Options.get("IgnoreCommandLineMacros", true)) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
Show All 22 Lines

clang-tools-extra/clang-tidy/cppcoreguidelines/NarrowingConversionsCheck.h

Show All 14 Lines
namespace tidy { namespace tidy {
namespace cppcoreguidelines { namespace cppcoreguidelines {
/// Checks for narrowing conversions, e.g: /// Checks for narrowing conversions, e.g:
/// int i = 0; /// int i = 0;
/// i += 0.1; /// i += 0.1;
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-narrowing-conversions.html /// https://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-narrowing-conversions.html
class NarrowingConversionsCheck : public ClangTidyCheck { class NarrowingConversionsCheck : public ClangTidyCheck {
public: public:
NarrowingConversionsCheck(StringRef Name, ClangTidyContext *Context); NarrowingConversionsCheck(StringRef Name, ClangTidyContext *Context);
void storeOptions(ClangTidyOptions::OptionMap &Opts) override; void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/cppcoreguidelines/NoMallocCheck.h

Show All 15 Lines
namespace cppcoreguidelines { namespace cppcoreguidelines {
/// This checker is concerned with C-style memory management and suggest modern /// This checker is concerned with C-style memory management and suggest modern
/// alternatives to it. /// alternatives to it.
/// The check is only enabled in C++. For analyzing malloc calls see Clang /// The check is only enabled in C++. For analyzing malloc calls see Clang
/// Static Analyzer - unix.Malloc. /// Static Analyzer - unix.Malloc.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-no-malloc.html /// https://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-no-malloc.html
class NoMallocCheck : public ClangTidyCheck { class NoMallocCheck : public ClangTidyCheck {
public: public:
/// Construct Checker and read in configuration for function names. /// Construct Checker and read in configuration for function names.
NoMallocCheck(StringRef Name, ClangTidyContext *Context) NoMallocCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context), : ClangTidyCheck(Name, Context),
AllocList(Options.get("Allocations", "::malloc;::calloc")), AllocList(Options.get("Allocations", "::malloc;::calloc")),
ReallocList(Options.get("Reallocations", "::realloc")), ReallocList(Options.get("Reallocations", "::realloc")),
DeallocList(Options.get("Deallocations", "::free")) {} DeallocList(Options.get("Deallocations", "::free")) {}
Show All 31 Lines

clang-tools-extra/clang-tidy/cppcoreguidelines/OwningMemoryCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace cppcoreguidelines { namespace cppcoreguidelines {
/// Checks for common use cases for gsl::owner and enforces the unique owner /// Checks for common use cases for gsl::owner and enforces the unique owner
/// nature of it whenever possible. /// nature of it whenever possible.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-owning-memory.html /// https://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-owning-memory.html
class OwningMemoryCheck : public ClangTidyCheck { class OwningMemoryCheck : public ClangTidyCheck {
public: public:
OwningMemoryCheck(StringRef Name, ClangTidyContext *Context) OwningMemoryCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context), : ClangTidyCheck(Name, Context),
LegacyResourceProducers(Options.get( LegacyResourceProducers(Options.get(
"LegacyResourceProducers", "::malloc;::aligned_alloc;::realloc;" "LegacyResourceProducers", "::malloc;::aligned_alloc;::realloc;"
"::calloc;::fopen;::freopen;::tmpfile")), "::calloc;::fopen;::freopen;::tmpfile")),
LegacyResourceConsumers(Options.get( LegacyResourceConsumers(Options.get(
Show All 35 Lines

clang-tools-extra/clang-tidy/cppcoreguidelines/PreferMemberInitializerCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace cppcoreguidelines { namespace cppcoreguidelines {
/// Finds member initializations in the constructor body which can be placed /// Finds member initializations in the constructor body which can be placed
/// into the initialization list instead. /// into the initialization list instead.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-prefer-member-initializer.html /// https://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-prefer-member-initializer.html
class PreferMemberInitializerCheck : public ClangTidyCheck { class PreferMemberInitializerCheck : public ClangTidyCheck {
public: public:
PreferMemberInitializerCheck(StringRef Name, ClangTidyContext *Context); PreferMemberInitializerCheck(StringRef Name, ClangTidyContext *Context);
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
void storeOptions(ClangTidyOptions::OptionMap &Opts) override; void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
Show All 11 Lines

clang-tools-extra/clang-tidy/cppcoreguidelines/ProBoundsArrayToPointerDecayCheck.h

Show All 12 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace cppcoreguidelines { namespace cppcoreguidelines {
/// This check flags all array to pointer decays /// This check flags all array to pointer decays
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-pro-bounds-array-to-pointer-decay.html /// https://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-pro-bounds-array-to-pointer-decay.html
class ProBoundsArrayToPointerDecayCheck : public ClangTidyCheck { class ProBoundsArrayToPointerDecayCheck : public ClangTidyCheck {
public: public:
ProBoundsArrayToPointerDecayCheck(StringRef Name, ClangTidyContext *Context) ProBoundsArrayToPointerDecayCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace cppcoreguidelines } // namespace cppcoreguidelines
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_BOUNDS_ARRAY_TO_POINTER_DECAY_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_BOUNDS_ARRAY_TO_POINTER_DECAY_H

clang-tools-extra/clang-tidy/cppcoreguidelines/ProBoundsConstantArrayIndexCheck.h

Show All 14 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace cppcoreguidelines { namespace cppcoreguidelines {
/// This checks that all array subscriptions on static arrays and std::arrays /// This checks that all array subscriptions on static arrays and std::arrays
/// have a constant index and are within bounds /// have a constant index and are within bounds
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-pro-bounds-constant-array-index.html /// https://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-pro-bounds-constant-array-index.html
class ProBoundsConstantArrayIndexCheck : public ClangTidyCheck { class ProBoundsConstantArrayIndexCheck : public ClangTidyCheck {
const StringRef GslHeader; const StringRef GslHeader;
utils::IncludeInserter Inserter; utils::IncludeInserter Inserter;
public: public:
ProBoundsConstantArrayIndexCheck(StringRef Name, ClangTidyContext *Context); ProBoundsConstantArrayIndexCheck(StringRef Name, ClangTidyContext *Context);
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
Show All 13 Lines

clang-tools-extra/clang-tidy/cppcoreguidelines/ProBoundsPointerArithmeticCheck.h

Show All 14 Lines
namespace tidy { namespace tidy {
namespace cppcoreguidelines { namespace cppcoreguidelines {
/// Flags all kinds of pointer arithmetic that have result of pointer type, i.e. /// Flags all kinds of pointer arithmetic that have result of pointer type, i.e.
/// +, -, +=, -=, ++, --. In addition, the [] operator on pointers (not on /// +, -, +=, -=, ++, --. In addition, the [] operator on pointers (not on
/// arrays) is flagged. /// arrays) is flagged.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-pro-bounds-pointer-arithmetic.html /// https://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-pro-bounds-pointer-arithmetic.html
class ProBoundsPointerArithmeticCheck : public ClangTidyCheck { class ProBoundsPointerArithmeticCheck : public ClangTidyCheck {
public: public:
ProBoundsPointerArithmeticCheck(StringRef Name, ClangTidyContext *Context) ProBoundsPointerArithmeticCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace cppcoreguidelines } // namespace cppcoreguidelines
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_BOUNDS_POINTER_ARITHMETIC_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_BOUNDS_POINTER_ARITHMETIC_H

clang-tools-extra/clang-tidy/cppcoreguidelines/ProTypeConstCastCheck.h

Show All 12 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace cppcoreguidelines { namespace cppcoreguidelines {
/// This check flags all instances of const_cast /// This check flags all instances of const_cast
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-pro-type-const-cast.html /// https://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-pro-type-const-cast.html
class ProTypeConstCastCheck : public ClangTidyCheck { class ProTypeConstCastCheck : public ClangTidyCheck {
public: public:
ProTypeConstCastCheck(StringRef Name, ClangTidyContext *Context) ProTypeConstCastCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace cppcoreguidelines } // namespace cppcoreguidelines
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_TYPE_CONST_CAST_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_TYPE_CONST_CAST_H

clang-tools-extra/clang-tidy/cppcoreguidelines/ProTypeCstyleCastCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace cppcoreguidelines { namespace cppcoreguidelines {
/// This check flags all use of C-style casts that perform a static_cast /// This check flags all use of C-style casts that perform a static_cast
/// downcast, const_cast, or reinterpret_cast. /// downcast, const_cast, or reinterpret_cast.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-pro-type-cstyle-cast.html /// https://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-pro-type-cstyle-cast.html
class ProTypeCstyleCastCheck : public ClangTidyCheck { class ProTypeCstyleCastCheck : public ClangTidyCheck {
public: public:
ProTypeCstyleCastCheck(StringRef Name, ClangTidyContext *Context) ProTypeCstyleCastCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace cppcoreguidelines } // namespace cppcoreguidelines
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_TYPE_CSTYLE_CAST_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_TYPE_CSTYLE_CAST_H

clang-tools-extra/clang-tidy/cppcoreguidelines/ProTypeMemberInitCheck.h

Show All 21 Lines
/// members and base classes that would have undefined behavior otherwise. Also /// members and base classes that would have undefined behavior otherwise. Also
/// check that any record types without user-provided default constructors are /// check that any record types without user-provided default constructors are
/// value-initialized where used. /// value-initialized where used.
/// ///
/// Members initialized through function calls in the body of the constructor /// Members initialized through function calls in the body of the constructor
/// will result in false positives. /// will result in false positives.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-pro-type-member-init.html /// https://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-pro-type-member-init.html
/// TODO: See if 'fixes' for false positives are optimized away by the compiler. /// TODO: See if 'fixes' for false positives are optimized away by the compiler.
/// TODO: For classes with multiple constructors, make sure that we don't offer /// TODO: For classes with multiple constructors, make sure that we don't offer
/// multiple in-class initializer fixits for the same member. /// multiple in-class initializer fixits for the same member.
class ProTypeMemberInitCheck : public ClangTidyCheck { class ProTypeMemberInitCheck : public ClangTidyCheck {
public: public:
ProTypeMemberInitCheck(StringRef Name, ClangTidyContext *Context); ProTypeMemberInitCheck(StringRef Name, ClangTidyContext *Context);
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/cppcoreguidelines/ProTypeReinterpretCastCheck.h

Show All 12 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace cppcoreguidelines { namespace cppcoreguidelines {
/// Flags all occurrences of reinterpret_cast /// Flags all occurrences of reinterpret_cast
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-pro-type-reinterpret-cast.html /// https://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-pro-type-reinterpret-cast.html
class ProTypeReinterpretCastCheck : public ClangTidyCheck { class ProTypeReinterpretCastCheck : public ClangTidyCheck {
public: public:
ProTypeReinterpretCastCheck(StringRef Name, ClangTidyContext *Context) ProTypeReinterpretCastCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace cppcoreguidelines } // namespace cppcoreguidelines
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_TYPE_REINTERPRETCAST_CHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_TYPE_REINTERPRETCAST_CHECK_H

clang-tools-extra/clang-tidy/cppcoreguidelines/ProTypeStaticCastDowncastCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace cppcoreguidelines { namespace cppcoreguidelines {
/// Checks for usages of static_cast, where a base class is downcasted to a /// Checks for usages of static_cast, where a base class is downcasted to a
/// derived class. /// derived class.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-pro-type-static-cast-downcast.html /// https://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-pro-type-static-cast-downcast.html
class ProTypeStaticCastDowncastCheck : public ClangTidyCheck { class ProTypeStaticCastDowncastCheck : public ClangTidyCheck {
public: public:
ProTypeStaticCastDowncastCheck(StringRef Name, ClangTidyContext *Context) ProTypeStaticCastDowncastCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace cppcoreguidelines } // namespace cppcoreguidelines
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_TYPE_STATIC_CAST_DOWNCAST_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_TYPE_STATIC_CAST_DOWNCAST_H

clang-tools-extra/clang-tidy/cppcoreguidelines/ProTypeUnionAccessCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace cppcoreguidelines { namespace cppcoreguidelines {
/// This check flags all access to members of unions. /// This check flags all access to members of unions.
/// Access to a union as a whole (e.g. passing to a function) is not flagged. /// Access to a union as a whole (e.g. passing to a function) is not flagged.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-pro-type-union-access.html /// https://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-pro-type-union-access.html
class ProTypeUnionAccessCheck : public ClangTidyCheck { class ProTypeUnionAccessCheck : public ClangTidyCheck {
public: public:
ProTypeUnionAccessCheck(StringRef Name, ClangTidyContext *Context) ProTypeUnionAccessCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace cppcoreguidelines } // namespace cppcoreguidelines
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_TYPE_UNION_ACCESS_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_TYPE_UNION_ACCESS_H

clang-tools-extra/clang-tidy/cppcoreguidelines/ProTypeVarargCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace cppcoreguidelines { namespace cppcoreguidelines {
/// This check flags all calls to c-style variadic functions and all use /// This check flags all calls to c-style variadic functions and all use
/// of va_arg. /// of va_arg.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-pro-type-vararg.html /// https://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-pro-type-vararg.html
class ProTypeVarargCheck : public ClangTidyCheck { class ProTypeVarargCheck : public ClangTidyCheck {
public: public:
ProTypeVarargCheck(StringRef Name, ClangTidyContext *Context) ProTypeVarargCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
Show All 10 Lines

clang-tools-extra/clang-tidy/cppcoreguidelines/SlicingCheck.h

//===--- SlicingCheck.h - clang-tidy-----------------------------*- C++ -*-===// //===--- SlicingCheck.h - clang-tidy-----------------------------*- C++ -*-===//
Lint: Lint
Inline Actions

clang-format suggested style edits found:

Lint: Lint: clang-format suggested style edits found:
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_SLICING_H #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_SLICING_H
#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_SLICING_H #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_SLICING_H
#include "../ClangTidyCheck.h" #include "../ClangTidyCheck.h"
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace cppcoreguidelines { namespace cppcoreguidelines {
/// Flags slicing (incomplete copying of an object's state) of member variables /// Flags slicing (incomplete copying of an object's state) of member variables
/// or vtable. See: /// or vtable. See:
/// - https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#es63-dont-slice /// - https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#es63-dont-slice
/// for the former, and /// for the former, and
/// - https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#c145-access-polymorphic-objects-through-pointers-and-references /// - https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#c145-access-polymorphic-objects-through-pointers-and-references
/// for the latter /// for the latter
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-slicing.html /// https://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-slicing.html
class SlicingCheck : public ClangTidyCheck { class SlicingCheck : public ClangTidyCheck {
public: public:
SlicingCheck(StringRef Name, ClangTidyContext *Context) SlicingCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
private: private:
Show All 10 Lines

clang-tools-extra/clang-tidy/cppcoreguidelines/SpecialMemberFunctionsCheck.h

Show All 15 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace cppcoreguidelines { namespace cppcoreguidelines {
/// Checks for classes where some, but not all, of the special member functions /// Checks for classes where some, but not all, of the special member functions
/// are defined. /// are defined.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-special-member-functions.html /// https://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-special-member-functions.html
class SpecialMemberFunctionsCheck : public ClangTidyCheck { class SpecialMemberFunctionsCheck : public ClangTidyCheck {
public: public:
SpecialMemberFunctionsCheck(StringRef Name, ClangTidyContext *Context); SpecialMemberFunctionsCheck(StringRef Name, ClangTidyContext *Context);
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
void storeOptions(ClangTidyOptions::OptionMap &Opts) override; void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/cppcoreguidelines/VirtualClassDestructorCheck.h

Show All 14 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace cppcoreguidelines { namespace cppcoreguidelines {
/// Finds base classes whose destructor is neither public and virtual /// Finds base classes whose destructor is neither public and virtual
/// nor protected and non-virtual. /// nor protected and non-virtual.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-virtual-class-destructor.html /// https://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-virtual-class-destructor.html
class VirtualClassDestructorCheck : public ClangTidyCheck { class VirtualClassDestructorCheck : public ClangTidyCheck {
public: public:
VirtualClassDestructorCheck(StringRef Name, ClangTidyContext *Context) VirtualClassDestructorCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
Show All 10 Lines

clang-tools-extra/clang-tidy/darwin/AvoidSpinlockCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace darwin { namespace darwin {
/// Finds usages of OSSpinlock, which is deprecated due to potential livelock /// Finds usages of OSSpinlock, which is deprecated due to potential livelock
/// problems. /// problems.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/darwin-avoid-spinlock.html /// https://clang.llvm.org/extra/clang-tidy/checks/darwin-avoid-spinlock.html
class AvoidSpinlockCheck : public ClangTidyCheck { class AvoidSpinlockCheck : public ClangTidyCheck {
public: public:
AvoidSpinlockCheck(StringRef Name, ClangTidyContext *Context) AvoidSpinlockCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace darwin } // namespace darwin
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_DARWIN_AVOIDSPINLOCKCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_DARWIN_AVOIDSPINLOCKCHECK_H

clang-tools-extra/clang-tidy/darwin/DispatchOnceNonstaticCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace darwin { namespace darwin {
/// Finds variables of type dispatch_once_t that do not have static or global /// Finds variables of type dispatch_once_t that do not have static or global
/// storage duration, as required by the libdispatch documentation. /// storage duration, as required by the libdispatch documentation.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/darwin-dispatch-once-nonstatic.html /// https://clang.llvm.org/extra/clang-tidy/checks/darwin-dispatch-once-nonstatic.html
class DispatchOnceNonstaticCheck : public ClangTidyCheck { class DispatchOnceNonstaticCheck : public ClangTidyCheck {
public: public:
DispatchOnceNonstaticCheck(StringRef Name, ClangTidyContext *Context) DispatchOnceNonstaticCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace darwin } // namespace darwin
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_DARWIN_DISPATCHONCENONSTATICCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_DARWIN_DISPATCHONCENONSTATICCHECK_H

clang-tools-extra/clang-tidy/fuchsia/DefaultArgumentsCallsCheck.h

Show All 12 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace fuchsia { namespace fuchsia {
/// Default arguments are not allowed in called functions. /// Default arguments are not allowed in called functions.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/fuchsia-default-arguments-calls.html /// https://clang.llvm.org/extra/clang-tidy/checks/fuchsia-default-arguments-calls.html
class DefaultArgumentsCallsCheck : public ClangTidyCheck { class DefaultArgumentsCallsCheck : public ClangTidyCheck {
public: public:
DefaultArgumentsCallsCheck(StringRef Name, ClangTidyContext *Context) DefaultArgumentsCallsCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace fuchsia } // namespace fuchsia
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_DEFAULT_ARGUMENTS_CALLS_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_DEFAULT_ARGUMENTS_CALLS_H

clang-tools-extra/clang-tidy/fuchsia/DefaultArgumentsDeclarationsCheck.h

Show All 12 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace fuchsia { namespace fuchsia {
/// Default parameters are not allowed in declared functions. /// Default parameters are not allowed in declared functions.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/fuchsia-default-parameters.html /// https://clang.llvm.org/extra/clang-tidy/checks/fuchsia-default-parameters.html
class DefaultArgumentsDeclarationsCheck : public ClangTidyCheck { class DefaultArgumentsDeclarationsCheck : public ClangTidyCheck {
public: public:
DefaultArgumentsDeclarationsCheck(StringRef Name, ClangTidyContext *Context) DefaultArgumentsDeclarationsCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace fuchsia } // namespace fuchsia
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_DEFAULT_ARGUMENTS_DECLARATIONS_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_DEFAULT_ARGUMENTS_DECLARATIONS_H

clang-tools-extra/clang-tidy/fuchsia/MultipleInheritanceCheck.h

Show All 12 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace fuchsia { namespace fuchsia {
/// Multiple implementation inheritance is discouraged. /// Multiple implementation inheritance is discouraged.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/fuchsia-multiple-inheritance.html /// https://clang.llvm.org/extra/clang-tidy/checks/fuchsia-multiple-inheritance.html
class MultipleInheritanceCheck : public ClangTidyCheck { class MultipleInheritanceCheck : public ClangTidyCheck {
public: public:
MultipleInheritanceCheck(StringRef Name, ClangTidyContext *Context) MultipleInheritanceCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
Show All 21 Lines

clang-tools-extra/clang-tidy/fuchsia/OverloadedOperatorCheck.h

Show All 12 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace fuchsia { namespace fuchsia {
/// Overloading operators is disallowed by the Fuchsia coding standard. /// Overloading operators is disallowed by the Fuchsia coding standard.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/fuchsia-overloaded-operator.html /// https://clang.llvm.org/extra/clang-tidy/checks/fuchsia-overloaded-operator.html
class OverloadedOperatorCheck : public ClangTidyCheck { class OverloadedOperatorCheck : public ClangTidyCheck {
public: public:
OverloadedOperatorCheck(StringRef Name, ClangTidyContext *Context) OverloadedOperatorCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace fuchsia } // namespace fuchsia
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_OVERLOADED_OPERATOR_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_OVERLOADED_OPERATOR_H

clang-tools-extra/clang-tidy/fuchsia/StaticallyConstructedObjectsCheck.h

//===--- StaticallyConstructedObjectsCheck.h - clang-tidy--------*- C++ -*-===// //===--- StaticallyConstructedObjectsCheck.h - clang-tidy--------*- C++ -*-===//
Lint: Lint
Inline Actions

clang-format suggested style edits found:

Lint: Lint: clang-format suggested style edits found:
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_STATICALLY_CONSTRUCTED_OBJECTS_H #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_STATICALLY_CONSTRUCTED_OBJECTS_H
#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_STATICALLY_CONSTRUCTED_OBJECTS_H #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_STATICALLY_CONSTRUCTED_OBJECTS_H
#include "../ClangTidyCheck.h" #include "../ClangTidyCheck.h"
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace fuchsia { namespace fuchsia {
/// Constructing global, non-trivial objects with static storage is /// Constructing global, non-trivial objects with static storage is
/// disallowed, unless the object is statically initialized with a constexpr /// disallowed, unless the object is statically initialized with a constexpr
/// constructor or has no explicit constructor. /// constructor or has no explicit constructor.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/fuchsia-statically-constructed-objects.html /// https://clang.llvm.org/extra/clang-tidy/checks/fuchsia-statically-constructed-objects.html
class StaticallyConstructedObjectsCheck : public ClangTidyCheck { class StaticallyConstructedObjectsCheck : public ClangTidyCheck {
public: public:
StaticallyConstructedObjectsCheck(StringRef Name, ClangTidyContext *Context) StaticallyConstructedObjectsCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus11; return LangOpts.CPlusPlus11;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace fuchsia } // namespace fuchsia
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_STATICALLY_CONSTRUCTED_OBJECTS_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_STATICALLY_CONSTRUCTED_OBJECTS_H

clang-tools-extra/clang-tidy/fuchsia/TrailingReturnCheck.h

//===--- TrailingReturnCheck.h - clang-tidy----------------------*- C++ -*-===// //===--- TrailingReturnCheck.h - clang-tidy----------------------*- C++ -*-===//
Lint: Lint
Inline Actions

clang-format suggested style edits found:

Lint: Lint: clang-format suggested style edits found:
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_TRAILING_RETURN_H #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_TRAILING_RETURN_H
#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_TRAILING_RETURN_H #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_TRAILING_RETURN_H
#include "../ClangTidyCheck.h" #include "../ClangTidyCheck.h"
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace fuchsia { namespace fuchsia {
/// Functions that have trailing returns are disallowed, except for those /// Functions that have trailing returns are disallowed, except for those
/// using decltype specifiers and lambda with otherwise unutterable /// using decltype specifiers and lambda with otherwise unutterable
/// return types. /// return types.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/fuchsia-trailing-return.html /// https://clang.llvm.org/extra/clang-tidy/checks/fuchsia-trailing-return.html
class TrailingReturnCheck : public ClangTidyCheck { class TrailingReturnCheck : public ClangTidyCheck {
public: public:
TrailingReturnCheck(StringRef Name, ClangTidyContext *Context) TrailingReturnCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus11; return LangOpts.CPlusPlus11;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace fuchsia } // namespace fuchsia
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_TRAILING_RETURN_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_TRAILING_RETURN_H

clang-tools-extra/clang-tidy/fuchsia/VirtualInheritanceCheck.h

Show All 12 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace fuchsia { namespace fuchsia {
/// Defining classes with virtual inheritance is disallowed. /// Defining classes with virtual inheritance is disallowed.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/fuchsia-virtual-inheritance.html /// https://clang.llvm.org/extra/clang-tidy/checks/fuchsia-virtual-inheritance.html
class VirtualInheritanceCheck : public ClangTidyCheck { class VirtualInheritanceCheck : public ClangTidyCheck {
public: public:
VirtualInheritanceCheck(StringRef Name, ClangTidyContext *Context) VirtualInheritanceCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace fuchsia } // namespace fuchsia
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_VIRTUAL_INHERITANCE_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_VIRTUAL_INHERITANCE_H

clang-tools-extra/clang-tidy/google/AvoidCStyleCastsCheck.h

Show All 21 Lines
/// ///
/// Corresponding cpplint.py check name: 'readability/casting'. /// Corresponding cpplint.py check name: 'readability/casting'.
/// ///
/// This check is similar to `-Wold-style-cast`, but it suggests automated fixes /// This check is similar to `-Wold-style-cast`, but it suggests automated fixes
/// in some cases. The reported locations should not be different from the /// in some cases. The reported locations should not be different from the
/// ones generated by `-Wold-style-cast`. /// ones generated by `-Wold-style-cast`.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/google-readability-casting.html /// https://clang.llvm.org/extra/clang-tidy/checks/google-readability-casting.html
class AvoidCStyleCastsCheck : public ClangTidyCheck { class AvoidCStyleCastsCheck : public ClangTidyCheck {
public: public:
AvoidCStyleCastsCheck(StringRef Name, ClangTidyContext *Context) AvoidCStyleCastsCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace readability } // namespace readability
} // namespace google } // namespace google
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_AVOIDCSTYLECASTSCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_AVOIDCSTYLECASTSCHECK_H

clang-tools-extra/clang-tidy/google/AvoidNSObjectNewCheck.h

Show All 15 Lines
namespace google { namespace google {
namespace objc { namespace objc {
/// This check finds Objective-C code that uses +new to create object instances, /// This check finds Objective-C code that uses +new to create object instances,
/// or overrides +new in classes. Both are forbidden by Google's Objective-C /// or overrides +new in classes. Both are forbidden by Google's Objective-C
/// style guide. /// style guide.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/google-avoid-nsobject-new.html /// https://clang.llvm.org/extra/clang-tidy/checks/google-avoid-nsobject-new.html
class AvoidNSObjectNewCheck : public ClangTidyCheck { class AvoidNSObjectNewCheck : public ClangTidyCheck {
public: public:
AvoidNSObjectNewCheck(StringRef Name, ClangTidyContext *Context) AvoidNSObjectNewCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.ObjC; return LangOpts.ObjC;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
Show All 9 Lines

clang-tools-extra/clang-tidy/google/AvoidThrowingObjCExceptionCheck.h

Show All 15 Lines
namespace google { namespace google {
namespace objc { namespace objc {
/// The check is to find usage of @throw invocation in Objective-C code. /// The check is to find usage of @throw invocation in Objective-C code.
/// We should avoid using @throw for Objective-C exceptions according to /// We should avoid using @throw for Objective-C exceptions according to
/// the Google Objective-C Style Guide. /// the Google Objective-C Style Guide.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/google-objc-avoid-throwing-exception.html /// https://clang.llvm.org/extra/clang-tidy/checks/google-objc-avoid-throwing-exception.html
class AvoidThrowingObjCExceptionCheck : public ClangTidyCheck { class AvoidThrowingObjCExceptionCheck : public ClangTidyCheck {
public: public:
AvoidThrowingObjCExceptionCheck(StringRef Name, ClangTidyContext *Context) AvoidThrowingObjCExceptionCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.ObjC; return LangOpts.ObjC;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
Show All 9 Lines

clang-tools-extra/clang-tidy/google/AvoidUnderscoreInGoogletestNameCheck.h

Show All 14 Lines
namespace tidy { namespace tidy {
namespace google { namespace google {
namespace readability { namespace readability {
// Check for underscores in the names of googletest tests, per // Check for underscores in the names of googletest tests, per
// https://github.com/google/googletest/blob/master/docs/faq.md#why-should-test-suite-names-and-test-names-not-contain-underscore // https://github.com/google/googletest/blob/master/docs/faq.md#why-should-test-suite-names-and-test-names-not-contain-underscore
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/google-readability-avoid-underscore-in-googletest-name.html /// https://clang.llvm.org/extra/clang-tidy/checks/google-readability-avoid-underscore-in-googletest-name.html
class AvoidUnderscoreInGoogletestNameCheck : public ClangTidyCheck { class AvoidUnderscoreInGoogletestNameCheck : public ClangTidyCheck {
public: public:
using ClangTidyCheck::ClangTidyCheck; using ClangTidyCheck::ClangTidyCheck;
void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP, void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
Preprocessor *ModuleExpanderPP) override; Preprocessor *ModuleExpanderPP) override;
}; };
} // namespace readability } // namespace readability
} // namespace google } // namespace google
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_AVOIDUNDERSCOREINGOOGLETESTNAMECHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_AVOIDUNDERSCOREINGOOGLETESTNAMECHECK_H

clang-tools-extra/clang-tidy/google/DefaultArgumentsCheck.h

Show All 14 Lines
namespace tidy { namespace tidy {
namespace google { namespace google {
/// Checks that default parameters are not given for virtual methods. /// Checks that default parameters are not given for virtual methods.
/// ///
/// See https://google.github.io/styleguide/cppguide.html#Default_Arguments /// See https://google.github.io/styleguide/cppguide.html#Default_Arguments
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/google-default-arguments.html /// https://clang.llvm.org/extra/clang-tidy/checks/google-default-arguments.html
class DefaultArgumentsCheck : public ClangTidyCheck { class DefaultArgumentsCheck : public ClangTidyCheck {
public: public:
DefaultArgumentsCheck(StringRef Name, ClangTidyContext *Context) DefaultArgumentsCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace google } // namespace google
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_DEFAULT_ARGUMENTS_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_DEFAULT_ARGUMENTS_H

clang-tools-extra/clang-tidy/google/ExplicitConstructorCheck.h

Show All 14 Lines
namespace tidy { namespace tidy {
namespace google { namespace google {
/// Checks that all single-argument constructors are explicit. /// Checks that all single-argument constructors are explicit.
/// ///
/// See https://google.github.io/styleguide/cppguide.html#Explicit_Constructors /// See https://google.github.io/styleguide/cppguide.html#Explicit_Constructors
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/google-explicit-constructor.html /// https://clang.llvm.org/extra/clang-tidy/checks/google-explicit-constructor.html
class ExplicitConstructorCheck : public ClangTidyCheck { class ExplicitConstructorCheck : public ClangTidyCheck {
public: public:
ExplicitConstructorCheck(StringRef Name, ClangTidyContext *Context) ExplicitConstructorCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace google } // namespace google
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_EXPLICITCONSTRUCTORCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_EXPLICITCONSTRUCTORCHECK_H

clang-tools-extra/clang-tidy/google/ExplicitMakePairCheck.h

Show All 18 Lines
/// Check that `make_pair`'s template arguments are deduced. /// Check that `make_pair`'s template arguments are deduced.
/// ///
/// G++ 4.6 in C++11 mode fails badly if `make_pair`'s template arguments are /// G++ 4.6 in C++11 mode fails badly if `make_pair`'s template arguments are
/// specified explicitly, and such use isn't intended in any case. /// specified explicitly, and such use isn't intended in any case.
/// ///
/// Corresponding cpplint.py check name: 'build/explicit_make_pair'. /// Corresponding cpplint.py check name: 'build/explicit_make_pair'.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/google-build-explicit-make-pair.html /// https://clang.llvm.org/extra/clang-tidy/checks/google-build-explicit-make-pair.html
class ExplicitMakePairCheck : public ClangTidyCheck { class ExplicitMakePairCheck : public ClangTidyCheck {
public: public:
ExplicitMakePairCheck(StringRef Name, ClangTidyContext *Context) ExplicitMakePairCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
Show All 9 Lines

clang-tools-extra/clang-tidy/google/FunctionNamingCheck.h

Show All 19 Lines
/// Finds function names that do not conform to the recommendations of the /// Finds function names that do not conform to the recommendations of the
/// Google Objective-C Style Guide. Function names should be in upper camel case /// Google Objective-C Style Guide. Function names should be in upper camel case
/// including capitalized acronyms and initialisms. Functions that are not of /// including capitalized acronyms and initialisms. Functions that are not of
/// static storage class must also have an appropriate prefix. The function /// static storage class must also have an appropriate prefix. The function
/// `main` is an exception. Note that this check does not apply to Objective-C /// `main` is an exception. Note that this check does not apply to Objective-C
/// method or property declarations. /// method or property declarations.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/google-objc-function-naming.html /// https://clang.llvm.org/extra/clang-tidy/checks/google-objc-function-naming.html
class FunctionNamingCheck : public ClangTidyCheck { class FunctionNamingCheck : public ClangTidyCheck {
public: public:
FunctionNamingCheck(StringRef Name, ClangTidyContext *Context) FunctionNamingCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.ObjC; return LangOpts.ObjC;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
Show All 9 Lines

clang-tools-extra/clang-tidy/google/GlobalNamesInHeadersCheck.h

Show All 23 Lines
/// - `HeaderFileExtensions`: a semicolon-separated list of filename /// - `HeaderFileExtensions`: a semicolon-separated list of filename
/// extensions of header files (the filename extensions should not contain /// extensions of header files (the filename extensions should not contain
/// "." prefix). ";h;hh;hpp;hxx" by default. /// "." prefix). ";h;hh;hpp;hxx" by default.
/// ///
/// For extension-less header files, using an empty string or leaving an /// For extension-less header files, using an empty string or leaving an
/// empty string between ";" if there are other filename extensions. /// empty string between ";" if there are other filename extensions.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/google-global-names-in-headers.html /// https://clang.llvm.org/extra/clang-tidy/checks/google-global-names-in-headers.html
class GlobalNamesInHeadersCheck : public ClangTidyCheck { class GlobalNamesInHeadersCheck : public ClangTidyCheck {
public: public:
GlobalNamesInHeadersCheck(StringRef Name, ClangTidyContext *Context); GlobalNamesInHeadersCheck(StringRef Name, ClangTidyContext *Context);
void storeOptions(ClangTidyOptions::OptionMap &Opts) override; void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
private: private:
Show All 10 Lines

clang-tools-extra/clang-tidy/google/GlobalVariableDeclarationCheck.h

Show All 15 Lines
namespace google { namespace google {
namespace objc { namespace objc {
/// The check for Objective-C global variables and constants naming convention. /// The check for Objective-C global variables and constants naming convention.
/// The declaration should follow the patterns of 'k[A-Z].*' (constants) or /// The declaration should follow the patterns of 'k[A-Z].*' (constants) or
/// 'g[A-Z].*' (variables). /// 'g[A-Z].*' (variables).
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/google-objc-global-variable-declaration.html /// https://clang.llvm.org/extra/clang-tidy/checks/google-objc-global-variable-declaration.html
class GlobalVariableDeclarationCheck : public ClangTidyCheck { class GlobalVariableDeclarationCheck : public ClangTidyCheck {
public: public:
GlobalVariableDeclarationCheck(StringRef Name, ClangTidyContext *Context) GlobalVariableDeclarationCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.ObjC; return LangOpts.ObjC;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
Show All 9 Lines

clang-tools-extra/clang-tidy/google/IntegerTypesCheck.h

Show All 21 Lines
namespace runtime { namespace runtime {
/// Finds uses of `short`, `long` and `long long` and suggest replacing them /// Finds uses of `short`, `long` and `long long` and suggest replacing them
/// with `u?intXX(_t)?`. /// with `u?intXX(_t)?`.
/// ///
/// Corresponding cpplint.py check: 'runtime/int'. /// Corresponding cpplint.py check: 'runtime/int'.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/google-runtime-int.html /// https://clang.llvm.org/extra/clang-tidy/checks/google-runtime-int.html
class IntegerTypesCheck : public ClangTidyCheck { class IntegerTypesCheck : public ClangTidyCheck {
public: public:
IntegerTypesCheck(StringRef Name, ClangTidyContext *Context); IntegerTypesCheck(StringRef Name, ClangTidyContext *Context);
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus && !LangOpts.ObjC; return LangOpts.CPlusPlus && !LangOpts.ObjC;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
Show All 16 Lines

clang-tools-extra/clang-tidy/google/OverloadedUnaryAndCheck.h

Show All 17 Lines
/// Finds overloads of unary `operator &`. /// Finds overloads of unary `operator &`.
/// ///
/// https://google.github.io/styleguide/cppguide.html#Operator_Overloading /// https://google.github.io/styleguide/cppguide.html#Operator_Overloading
/// ///
/// Corresponding cpplint.py check name: 'runtime/operator'. /// Corresponding cpplint.py check name: 'runtime/operator'.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/google-runtime-operator.html /// https://clang.llvm.org/extra/clang-tidy/checks/google-runtime-operator.html
class OverloadedUnaryAndCheck : public ClangTidyCheck { class OverloadedUnaryAndCheck : public ClangTidyCheck {
public: public:
OverloadedUnaryAndCheck(StringRef Name, ClangTidyContext *Context) OverloadedUnaryAndCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
Show All 9 Lines

clang-tools-extra/clang-tidy/google/TodoCommentCheck.h

Show All 15 Lines
namespace google { namespace google {
namespace readability { namespace readability {
/// Finds TODO comments without a username or bug number. /// Finds TODO comments without a username or bug number.
/// ///
/// Corresponding cpplint.py check: 'readability/todo' /// Corresponding cpplint.py check: 'readability/todo'
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/google-readability-todo.html /// https://clang.llvm.org/extra/clang-tidy/checks/google-readability-todo.html
class TodoCommentCheck : public ClangTidyCheck { class TodoCommentCheck : public ClangTidyCheck {
public: public:
TodoCommentCheck(StringRef Name, ClangTidyContext *Context); TodoCommentCheck(StringRef Name, ClangTidyContext *Context);
~TodoCommentCheck(); ~TodoCommentCheck();
void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP, void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
Preprocessor *ModuleExpanderPP) override; Preprocessor *ModuleExpanderPP) override;
Show All 11 Lines

clang-tools-extra/clang-tidy/google/UnnamedNamespaceInHeaderCheck.h

Show All 26 Lines
/// For extension-less header files, using an empty string or leaving an /// For extension-less header files, using an empty string or leaving an
/// empty string between ";" if there are other filename extensions. /// empty string between ";" if there are other filename extensions.
/// ///
/// https://google.github.io/styleguide/cppguide.html#Namespaces /// https://google.github.io/styleguide/cppguide.html#Namespaces
/// ///
/// Corresponding cpplint.py check name: 'build/namespaces'. /// Corresponding cpplint.py check name: 'build/namespaces'.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/google-build-namespaces.html /// https://clang.llvm.org/extra/clang-tidy/checks/google-build-namespaces.html
class UnnamedNamespaceInHeaderCheck : public ClangTidyCheck { class UnnamedNamespaceInHeaderCheck : public ClangTidyCheck {
public: public:
UnnamedNamespaceInHeaderCheck(StringRef Name, ClangTidyContext *Context); UnnamedNamespaceInHeaderCheck(StringRef Name, ClangTidyContext *Context);
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
void storeOptions(ClangTidyOptions::OptionMap &Opts) override; void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
Show All 13 Lines

clang-tools-extra/clang-tidy/hicpp/ExceptionBaseclassCheck.h

//===--- ExceptionBaseclassCheck.h - clang-tidy------------------*- C++ -*-===// //===--- ExceptionBaseclassCheck.h - clang-tidy------------------*- C++ -*-===//
Lint: Lint
Inline Actions

clang-format suggested style edits found:

Lint: Lint: clang-format suggested style edits found:
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_HICPP_EXCEPTION_BASECLASS_H #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_HICPP_EXCEPTION_BASECLASS_H
#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_HICPP_EXCEPTION_BASECLASS_H #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_HICPP_EXCEPTION_BASECLASS_H
#include "../ClangTidyCheck.h" #include "../ClangTidyCheck.h"
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace hicpp { namespace hicpp {
/// Check for thrown exceptions and enforce they are all derived from std::exception. /// Check for thrown exceptions and enforce they are all derived from std::exception.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/hicpp-exception-baseclass.html /// https://clang.llvm.org/extra/clang-tidy/checks/hicpp-exception-baseclass.html
class ExceptionBaseclassCheck : public ClangTidyCheck { class ExceptionBaseclassCheck : public ClangTidyCheck {
public: public:
ExceptionBaseclassCheck(StringRef Name, ClangTidyContext *Context) ExceptionBaseclassCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace hicpp } // namespace hicpp
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_HICPP_EXCEPTION_BASECLASS_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_HICPP_EXCEPTION_BASECLASS_H

clang-tools-extra/clang-tidy/hicpp/MultiwayPathsCoveredCheck.h

Show All 14 Lines
namespace tidy { namespace tidy {
namespace hicpp { namespace hicpp {
/// Find occasions where not all codepaths are explicitly covered in code. /// Find occasions where not all codepaths are explicitly covered in code.
/// This includes 'switch' without a 'default'-branch and 'if'-'else if'-chains /// This includes 'switch' without a 'default'-branch and 'if'-'else if'-chains
/// without a final 'else'-branch. /// without a final 'else'-branch.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/hicpp-multiway-paths-covered.html /// https://clang.llvm.org/extra/clang-tidy/checks/hicpp-multiway-paths-covered.html
class MultiwayPathsCoveredCheck : public ClangTidyCheck { class MultiwayPathsCoveredCheck : public ClangTidyCheck {
public: public:
MultiwayPathsCoveredCheck(StringRef Name, ClangTidyContext *Context) MultiwayPathsCoveredCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context), : ClangTidyCheck(Name, Context),
WarnOnMissingElse(Options.get("WarnOnMissingElse", false)) {} WarnOnMissingElse(Options.get("WarnOnMissingElse", false)) {}
void storeOptions(ClangTidyOptions::OptionMap &Opts) override; void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
Show All 17 Lines

clang-tools-extra/clang-tidy/hicpp/NoAssemblerCheck.h

Show All 12 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace hicpp { namespace hicpp {
/// Find assembler statements. No fix is offered. /// Find assembler statements. No fix is offered.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/hicpp-no-assembler.html /// https://clang.llvm.org/extra/clang-tidy/checks/hicpp-no-assembler.html
class NoAssemblerCheck : public ClangTidyCheck { class NoAssemblerCheck : public ClangTidyCheck {
public: public:
NoAssemblerCheck(StringRef Name, ClangTidyContext *Context) NoAssemblerCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace hicpp } // namespace hicpp
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_HICPP_NO_ASSEMBLER_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_HICPP_NO_ASSEMBLER_H

clang-tools-extra/clang-tidy/hicpp/SignedBitwiseCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace hicpp { namespace hicpp {
/// This check implements the rule 5.6.1 of the HICPP Standard, which disallows /// This check implements the rule 5.6.1 of the HICPP Standard, which disallows
/// bitwise operations on signed integer types. /// bitwise operations on signed integer types.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/hicpp-signed-bitwise.html /// https://clang.llvm.org/extra/clang-tidy/checks/hicpp-signed-bitwise.html
class SignedBitwiseCheck : public ClangTidyCheck { class SignedBitwiseCheck : public ClangTidyCheck {
public: public:
SignedBitwiseCheck(StringRef Name, ClangTidyContext *Context); SignedBitwiseCheck(StringRef Name, ClangTidyContext *Context);
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
void storeOptions(ClangTidyOptions::OptionMap &Options) override; void storeOptions(ClangTidyOptions::OptionMap &Options) override;
private: private:
bool IgnorePositiveIntegerLiterals; bool IgnorePositiveIntegerLiterals;
}; };
} // namespace hicpp } // namespace hicpp
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_HICPP_SIGNED_BITWISE_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_HICPP_SIGNED_BITWISE_H

clang-tools-extra/clang-tidy/linuxkernel/MustCheckErrsCheck.h

Show All 21 Lines
/// This is important in the Linux kernel because ERR_PTR, PTR_ERR, IS_ERR, /// This is important in the Linux kernel because ERR_PTR, PTR_ERR, IS_ERR,
/// IS_ERR_OR_NULL, ERR_CAST, and PTR_ERR_OR_ZERO return values must be checked, /// IS_ERR_OR_NULL, ERR_CAST, and PTR_ERR_OR_ZERO return values must be checked,
/// since positive pointers and negative error codes are being used in the same /// since positive pointers and negative error codes are being used in the same
/// context. These functions are marked with /// context. These functions are marked with
/// __attribute__((warn_unused_result)), but some kernel versions do not have /// __attribute__((warn_unused_result)), but some kernel versions do not have
/// this warning enabled for clang. /// this warning enabled for clang.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/linuxkernel-must-use-errs.html /// https://clang.llvm.org/extra/clang-tidy/checks/linuxkernel-must-use-errs.html
class MustCheckErrsCheck : public ClangTidyCheck { class MustCheckErrsCheck : public ClangTidyCheck {
public: public:
MustCheckErrsCheck(StringRef Name, ClangTidyContext *Context) MustCheckErrsCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace linuxkernel } // namespace linuxkernel
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LINUXKERNEL_MUSTCHECKERRSCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LINUXKERNEL_MUSTCHECKERRSCHECK_H

clang-tools-extra/clang-tidy/llvm/HeaderGuardCheck.h

Show All 11 Lines
#include "../utils/HeaderGuard.h" #include "../utils/HeaderGuard.h"
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace llvm_check { namespace llvm_check {
/// Finds and fixes header guards that do not adhere to LLVM style. /// Finds and fixes header guards that do not adhere to LLVM style.
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/llvm-header-guard.html /// https://clang.llvm.org/extra/clang-tidy/checks/llvm-header-guard.html
/// The check supports these options: /// The check supports these options:
/// - `HeaderFileExtensions`: a semicolon-separated list of filename /// - `HeaderFileExtensions`: a semicolon-separated list of filename
/// extensions of header files (The filename extension should not contain /// extensions of header files (The filename extension should not contain
/// "." prefix). ";h;hh;hpp;hxx" by default. /// "." prefix). ";h;hh;hpp;hxx" by default.
/// ///
/// For extension-less header files, using an empty string or leaving an /// For extension-less header files, using an empty string or leaving an
/// empty string between ";" if there are other filename extensions. /// empty string between ";" if there are other filename extensions.
class LLVMHeaderGuardCheck : public utils::HeaderGuardCheck { class LLVMHeaderGuardCheck : public utils::HeaderGuardCheck {
Show All 12 Lines

clang-tools-extra/clang-tidy/llvm/IncludeOrderCheck.h

Show All 11 Lines
#include "../ClangTidyCheck.h" #include "../ClangTidyCheck.h"
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace llvm_check { namespace llvm_check {
/// Checks the correct order of `#includes`. /// Checks the correct order of `#includes`.
/// ///
/// See http://llvm.org/docs/CodingStandards.html#include-style /// See https://llvm.org/docs/CodingStandards.html#include-style
class IncludeOrderCheck : public ClangTidyCheck { class IncludeOrderCheck : public ClangTidyCheck {
public: public:
IncludeOrderCheck(StringRef Name, ClangTidyContext *Context) IncludeOrderCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP, void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
Preprocessor *ModuleExpanderPP) override; Preprocessor *ModuleExpanderPP) override;
}; };
} // namespace llvm_check } // namespace llvm_check
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_INCLUDEORDERCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_INCLUDEORDERCHECK_H

clang-tools-extra/clang-tidy/llvm/PreferIsaOrDynCastInConditionalsCheck.h

//===--- PreferIsaOrDynCastInConditionalsCheck.h - clang-tidy ---*- C++ -*-===// //===--- PreferIsaOrDynCastInConditionalsCheck.h - clang-tidy ---*- C++ -*-===//
Lint: Lint
Inline Actions

clang-format suggested style edits found:

Lint: Lint: clang-format suggested style edits found:
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_PREFERISAORDYNCASTINCONDITIONALSCHECK_H #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_PREFERISAORDYNCASTINCONDITIONALSCHECK_H
Show All 32 Lines
/// // Other cases are ignored, e.g.: /// // Other cases are ignored, e.g.:
/// \code /// \code
/// if (auto f = cast<Z>(y)->foo()) {} /// if (auto f = cast<Z>(y)->foo()) {}
/// if (cast<Z>(y)->foo()) {} /// if (cast<Z>(y)->foo()) {}
/// if (X.cast(y)) {} /// if (X.cast(y)) {}
/// \endcode /// \endcode
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/llvm-prefer-isa-or-dyn-cast-in-conditionals.html /// https://clang.llvm.org/extra/clang-tidy/checks/llvm-prefer-isa-or-dyn-cast-in-conditionals.html
class PreferIsaOrDynCastInConditionalsCheck : public ClangTidyCheck { class PreferIsaOrDynCastInConditionalsCheck : public ClangTidyCheck {
public: public:
PreferIsaOrDynCastInConditionalsCheck(StringRef Name, PreferIsaOrDynCastInConditionalsCheck(StringRef Name,
ClangTidyContext *Context) ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
Show All 9 Lines

clang-tools-extra/clang-tidy/llvm/PreferRegisterOverUnsignedCheck.h

Show All 14 Lines
namespace tidy { namespace tidy {
namespace llvm_check { namespace llvm_check {
/// Historically, LLVM has used `unsigned` to represent registers. Since then /// Historically, LLVM has used `unsigned` to represent registers. Since then
/// a `Register` object has been introduced for improved type-safety and make /// a `Register` object has been introduced for improved type-safety and make
/// the code more explicit. /// the code more explicit.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/llvm-prefer-register-over-unsigned.html /// https://clang.llvm.org/extra/clang-tidy/checks/llvm-prefer-register-over-unsigned.html
class PreferRegisterOverUnsignedCheck : public ClangTidyCheck { class PreferRegisterOverUnsignedCheck : public ClangTidyCheck {
public: public:
PreferRegisterOverUnsignedCheck(StringRef Name, ClangTidyContext *Context) PreferRegisterOverUnsignedCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace llvm_check } // namespace llvm_check
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_PREFERREGISTEROVERUNSIGNEDCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_PREFERREGISTEROVERUNSIGNEDCHECK_H

clang-tools-extra/clang-tidy/llvmlibc/CalleeNamespaceCheck.h

Show All 12 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace llvm_libc { namespace llvm_libc {
/// Checks all calls resolve to functions within __llvm_libc namespace. /// Checks all calls resolve to functions within __llvm_libc namespace.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/llvmlibc-callee-namespace.html /// https://clang.llvm.org/extra/clang-tidy/checks/llvmlibc-callee-namespace.html
class CalleeNamespaceCheck : public ClangTidyCheck { class CalleeNamespaceCheck : public ClangTidyCheck {
public: public:
CalleeNamespaceCheck(StringRef Name, ClangTidyContext *Context) CalleeNamespaceCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
Show All 9 Lines

clang-tools-extra/clang-tidy/llvmlibc/ImplementationInNamespaceCheck.h

Show All 12 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace llvm_libc { namespace llvm_libc {
/// Checks all llvm-libc implementation is within the correct namespace. /// Checks all llvm-libc implementation is within the correct namespace.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/llvmlibc-implementation-in-namespace.html /// https://clang.llvm.org/extra/clang-tidy/checks/llvmlibc-implementation-in-namespace.html
class ImplementationInNamespaceCheck : public ClangTidyCheck { class ImplementationInNamespaceCheck : public ClangTidyCheck {
public: public:
ImplementationInNamespaceCheck(StringRef Name, ClangTidyContext *Context) ImplementationInNamespaceCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
Show All 9 Lines

clang-tools-extra/clang-tidy/llvmlibc/RestrictSystemLibcHeadersCheck.h

Show All 14 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace llvm_libc { namespace llvm_libc {
/// Warns of accidental inclusions of system libc headers that aren't /// Warns of accidental inclusions of system libc headers that aren't
/// compiler provided. /// compiler provided.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/llvmlibc-restrict-system-libc-headers.html /// https://clang.llvm.org/extra/clang-tidy/checks/llvmlibc-restrict-system-libc-headers.html
class RestrictSystemLibcHeadersCheck class RestrictSystemLibcHeadersCheck
: public portability::RestrictSystemIncludesCheck { : public portability::RestrictSystemIncludesCheck {
public: public:
RestrictSystemLibcHeadersCheck(StringRef Name, ClangTidyContext *Context) RestrictSystemLibcHeadersCheck(StringRef Name, ClangTidyContext *Context)
: portability::RestrictSystemIncludesCheck(Name, Context, "-*") {} : portability::RestrictSystemIncludesCheck(Name, Context, "-*") {}
void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP, void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
Preprocessor *ModuleExpanderPP) override; Preprocessor *ModuleExpanderPP) override;
}; };
} // namespace llvm_libc } // namespace llvm_libc
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVMLIBC_RESTRICTSYSTEMLIBCHEADERSCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVMLIBC_RESTRICTSYSTEMLIBCHEADERSCHECK_H

clang-tools-extra/clang-tidy/misc/DefinitionsInHeadersCheck.h

Show All 24 Lines
/// - `HeaderFileExtensions`: a semicolon-separated list of filename /// - `HeaderFileExtensions`: a semicolon-separated list of filename
/// extensions of header files (The filename extension should not contain /// extensions of header files (The filename extension should not contain
/// "." prefix). ";h;hh;hpp;hxx" by default. /// "." prefix). ";h;hh;hpp;hxx" by default.
/// ///
/// For extension-less header files, using an empty string or leaving an /// For extension-less header files, using an empty string or leaving an
/// empty string between ";" if there are other filename extensions. /// empty string between ";" if there are other filename extensions.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/misc-definitions-in-headers.html /// https://clang.llvm.org/extra/clang-tidy/checks/misc-definitions-in-headers.html
class DefinitionsInHeadersCheck : public ClangTidyCheck { class DefinitionsInHeadersCheck : public ClangTidyCheck {
public: public:
DefinitionsInHeadersCheck(StringRef Name, ClangTidyContext *Context); DefinitionsInHeadersCheck(StringRef Name, ClangTidyContext *Context);
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus11; return LangOpts.CPlusPlus11;
} }
void storeOptions(ClangTidyOptions::OptionMap &Opts) override; void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
Show All 13 Lines

clang-tools-extra/clang-tidy/misc/MisplacedConstCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace misc { namespace misc {
/// This check diagnoses when a const qualifier is applied to a typedef to a /// This check diagnoses when a const qualifier is applied to a typedef to a
/// pointer type rather than to the pointee. /// pointer type rather than to the pointee.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/misc-misplaced-const.html /// https://clang.llvm.org/extra/clang-tidy/checks/misc-misplaced-const.html
class MisplacedConstCheck : public ClangTidyCheck { class MisplacedConstCheck : public ClangTidyCheck {
public: public:
MisplacedConstCheck(StringRef Name, ClangTidyContext *Context) MisplacedConstCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace misc } // namespace misc
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_MISPLACED_CONST_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_MISPLACED_CONST_H

clang-tools-extra/clang-tidy/misc/NoRecursionCheck.h

Show All 17 Lines
namespace tidy { namespace tidy {
namespace misc { namespace misc {
/// Finds strongly connected functions (by analyzing call graph for SCC's /// Finds strongly connected functions (by analyzing call graph for SCC's
/// that are loops), diagnoses each function in the cycle, /// that are loops), diagnoses each function in the cycle,
/// and displays one example of possible call graph loop (recursion). /// and displays one example of possible call graph loop (recursion).
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/misc-no-recursion.html /// https://clang.llvm.org/extra/clang-tidy/checks/misc-no-recursion.html
class NoRecursionCheck : public ClangTidyCheck { class NoRecursionCheck : public ClangTidyCheck {
public: public:
NoRecursionCheck(StringRef Name, ClangTidyContext *Context) NoRecursionCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
private: private:
void handleSCC(ArrayRef<CallGraphNode *> SCC); void handleSCC(ArrayRef<CallGraphNode *> SCC);
}; };
} // namespace misc } // namespace misc
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_NORECURSIONCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_NORECURSIONCHECK_H

clang-tools-extra/clang-tidy/misc/NonPrivateMemberVariablesInClassesCheck.h

Show All 19 Lines
/// functions), and diagnoses all member variables that have any other scope /// functions), and diagnoses all member variables that have any other scope
/// other than `private`. They should be made `private`, and manipulated /// other than `private`. They should be made `private`, and manipulated
/// exclusively via the member functions. /// exclusively via the member functions.
/// ///
/// Optionally, classes with all member variables being `public` could be /// Optionally, classes with all member variables being `public` could be
/// ignored and optionally all `public` member variables could be ignored. /// ignored and optionally all `public` member variables could be ignored.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/misc-non-private-member-variables-in-classes.html /// https://clang.llvm.org/extra/clang-tidy/checks/misc-non-private-member-variables-in-classes.html
class NonPrivateMemberVariablesInClassesCheck : public ClangTidyCheck { class NonPrivateMemberVariablesInClassesCheck : public ClangTidyCheck {
public: public:
NonPrivateMemberVariablesInClassesCheck(StringRef Name, NonPrivateMemberVariablesInClassesCheck(StringRef Name,
ClangTidyContext *Context); ClangTidyContext *Context);
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
void storeOptions(ClangTidyOptions::OptionMap &Opts) override; void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
Show All 13 Lines

clang-tools-extra/clang-tidy/misc/RedundantExpressionCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace misc { namespace misc {
/// The checker detects expressions that are redundant, because they contain /// The checker detects expressions that are redundant, because they contain
/// ineffective, useless parts. /// ineffective, useless parts.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/misc-redundant-expression.html /// https://clang.llvm.org/extra/clang-tidy/checks/misc-redundant-expression.html
class RedundantExpressionCheck : public ClangTidyCheck { class RedundantExpressionCheck : public ClangTidyCheck {
public: public:
RedundantExpressionCheck(StringRef Name, ClangTidyContext *Context) RedundantExpressionCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
private: private:
Show All 10 Lines

clang-tools-extra/clang-tidy/misc/UnconventionalAssignOperatorCheck.h

Show All 19 Lines
/// statements. /// statements.
/// ///
/// * The return type must be `Class&`. /// * The return type must be `Class&`.
/// * Works with move-assign and assign by value. /// * Works with move-assign and assign by value.
/// * Private and deleted operators are ignored. /// * Private and deleted operators are ignored.
/// * The operator must always return ``*this``. /// * The operator must always return ``*this``.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/misc-unconventional-assign-operator.html /// https://clang.llvm.org/extra/clang-tidy/checks/misc-unconventional-assign-operator.html
class UnconventionalAssignOperatorCheck : public ClangTidyCheck { class UnconventionalAssignOperatorCheck : public ClangTidyCheck {
public: public:
UnconventionalAssignOperatorCheck(StringRef Name, ClangTidyContext *Context) UnconventionalAssignOperatorCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace misc } // namespace misc
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_ASSIGNOPERATORSIGNATURECHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_ASSIGNOPERATORSIGNATURECHECK_H

clang-tools-extra/clang-tidy/misc/UnusedUsingDeclsCheck.h

Show All 14 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace misc { namespace misc {
/// Finds unused using declarations. /// Finds unused using declarations.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/misc-unused-using-decls.html /// https://clang.llvm.org/extra/clang-tidy/checks/misc-unused-using-decls.html
class UnusedUsingDeclsCheck : public ClangTidyCheck { class UnusedUsingDeclsCheck : public ClangTidyCheck {
public: public:
UnusedUsingDeclsCheck(StringRef Name, ClangTidyContext *Context) UnusedUsingDeclsCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
void onEndOfTranslationUnit() override; void onEndOfTranslationUnit() override;
Show All 26 Lines

clang-tools-extra/clang-tidy/modernize/AvoidBindCheck.h

Show All 14 Lines
namespace tidy { namespace tidy {
namespace modernize { namespace modernize {
/// Replace simple uses of std::bind with a lambda. /// Replace simple uses of std::bind with a lambda.
/// ///
/// FIXME: Add support for function references and member function references. /// FIXME: Add support for function references and member function references.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/modernize-avoid-std-bind.html /// https://clang.llvm.org/extra/clang-tidy/checks/modernize-avoid-std-bind.html
class AvoidBindCheck : public ClangTidyCheck { class AvoidBindCheck : public ClangTidyCheck {
public: public:
AvoidBindCheck(StringRef Name, ClangTidyContext *Context); AvoidBindCheck(StringRef Name, ClangTidyContext *Context);
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus14; return LangOpts.CPlusPlus14;
} }
void storeOptions(ClangTidyOptions::OptionMap &Opts) override; void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
Show All 10 Lines

clang-tools-extra/clang-tidy/modernize/AvoidCArraysCheck.h

Show All 12 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace modernize { namespace modernize {
/// Find C-style array types and recommend to use std::array<> / std::vector<>. /// Find C-style array types and recommend to use std::array<> / std::vector<>.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/modernize-avoid-c-arrays.html /// https://clang.llvm.org/extra/clang-tidy/checks/modernize-avoid-c-arrays.html
class AvoidCArraysCheck : public ClangTidyCheck { class AvoidCArraysCheck : public ClangTidyCheck {
public: public:
AvoidCArraysCheck(StringRef Name, ClangTidyContext *Context) AvoidCArraysCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus11; return LangOpts.CPlusPlus11;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace modernize } // namespace modernize
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_AVOIDCARRAYSCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_AVOIDCARRAYSCHECK_H

clang-tools-extra/clang-tidy/modernize/DeprecatedHeadersCheck.h

Show All 25 Lines
/// After: /// After:
/// ~~~{.cpp} /// ~~~{.cpp}
/// #include <cheader> /// #include <cheader>
/// ~~~ /// ~~~
/// ///
/// Example: ``<stdio.h> => <cstdio>`` /// Example: ``<stdio.h> => <cstdio>``
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/modernize-deprecated-headers.html /// https://clang.llvm.org/extra/clang-tidy/checks/modernize-deprecated-headers.html
class DeprecatedHeadersCheck : public ClangTidyCheck { class DeprecatedHeadersCheck : public ClangTidyCheck {
public: public:
DeprecatedHeadersCheck(StringRef Name, ClangTidyContext *Context); DeprecatedHeadersCheck(StringRef Name, ClangTidyContext *Context);
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
void storeOptions(ClangTidyOptions::OptionMap &Opts) override; void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP, void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
Show All 22 Lines

clang-tools-extra/clang-tidy/modernize/DeprecatedIosBaseAliasesCheck.h

//===--- DeprecatedIosBaseAliasesCheck.h - clang-tidy------------*- C++ -*-===// //===--- DeprecatedIosBaseAliasesCheck.h - clang-tidy------------*- C++ -*-===//
Lint: Lint
Inline Actions

clang-format suggested style edits found:

Lint: Lint: clang-format suggested style edits found:
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_DEPRECATEDIOSBASEALIASESCHECK_H #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_DEPRECATEDIOSBASEALIASESCHECK_H
#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_DEPRECATEDIOSBASEALIASESCHECK_H #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_DEPRECATEDIOSBASEALIASESCHECK_H
#include "../ClangTidyCheck.h" #include "../ClangTidyCheck.h"
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace modernize { namespace modernize {
/// This check warns the uses of the deprecated member types of ``std::ios_base`` /// This check warns the uses of the deprecated member types of ``std::ios_base``
/// and replaces those that have a non-deprecated equivalent. /// and replaces those that have a non-deprecated equivalent.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/modernize-deprecated-ios-base-aliases.html /// https://clang.llvm.org/extra/clang-tidy/checks/modernize-deprecated-ios-base-aliases.html
class DeprecatedIosBaseAliasesCheck : public ClangTidyCheck { class DeprecatedIosBaseAliasesCheck : public ClangTidyCheck {
public: public:
DeprecatedIosBaseAliasesCheck(StringRef Name, ClangTidyContext *Context) DeprecatedIosBaseAliasesCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace modernize } // namespace modernize
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_DEPRECATEDIOSBASEALIASESCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_DEPRECATEDIOSBASEALIASESCHECK_H

clang-tools-extra/clang-tidy/modernize/MacroToEnumCheck.h

Show All 14 Lines
namespace tidy { namespace tidy {
namespace modernize { namespace modernize {
class MacroToEnumCallbacks; class MacroToEnumCallbacks;
/// Replaces groups of related macros with an unscoped anonymous enum. /// Replaces groups of related macros with an unscoped anonymous enum.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/modernize-macro-to-enum.html /// https://clang.llvm.org/extra/clang-tidy/checks/modernize-macro-to-enum.html
class MacroToEnumCheck : public ClangTidyCheck { class MacroToEnumCheck : public ClangTidyCheck {
public: public:
MacroToEnumCheck(StringRef Name, ClangTidyContext *Context) MacroToEnumCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP, void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
Preprocessor *ModuleExpanderPP) override; Preprocessor *ModuleExpanderPP) override;
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
Show All 10 Lines

clang-tools-extra/clang-tidy/modernize/MakeSharedCheck.h

Show All 20 Lines
/// \endcode /// \endcode
/// ///
/// With the safer version: /// With the safer version:
/// \code /// \code
/// std::make_shared<type>(args...) /// std::make_shared<type>(args...)
/// \endcode /// \endcode
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/modernize-make-shared.html /// https://clang.llvm.org/extra/clang-tidy/checks/modernize-make-shared.html
class MakeSharedCheck : public MakeSmartPtrCheck { class MakeSharedCheck : public MakeSmartPtrCheck {
public: public:
MakeSharedCheck(StringRef Name, ClangTidyContext *Context); MakeSharedCheck(StringRef Name, ClangTidyContext *Context);
protected: protected:
SmartPtrTypeMatcher getSmartPointerTypeMatcher() const override; SmartPtrTypeMatcher getSmartPointerTypeMatcher() const override;
}; };
} // namespace modernize } // namespace modernize
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_MAKE_SHARED_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_MAKE_SHARED_H

clang-tools-extra/clang-tidy/modernize/RawStringLiteralCheck.h

Show All 16 Lines
namespace modernize { namespace modernize {
using CharsBitSet = std::bitset<1 << CHAR_BIT>; using CharsBitSet = std::bitset<1 << CHAR_BIT>;
/// This check replaces string literals with escaped characters to /// This check replaces string literals with escaped characters to
/// raw string literals. /// raw string literals.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/modernize-raw-string-literal.html /// https://clang.llvm.org/extra/clang-tidy/checks/modernize-raw-string-literal.html
class RawStringLiteralCheck : public ClangTidyCheck { class RawStringLiteralCheck : public ClangTidyCheck {
public: public:
RawStringLiteralCheck(StringRef Name, ClangTidyContext *Context); RawStringLiteralCheck(StringRef Name, ClangTidyContext *Context);
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus11; return LangOpts.CPlusPlus11;
} }
void storeOptions(ClangTidyOptions::OptionMap &Options) override; void storeOptions(ClangTidyOptions::OptionMap &Options) override;
Show All 18 Lines

clang-tools-extra/clang-tidy/modernize/ReplaceDisallowCopyAndAssignMacroCheck.h

Show All 31 Lines
/// class Foo { /// class Foo {
/// private: /// private:
/// Foo(const Foo &) = delete; /// Foo(const Foo &) = delete;
/// const Foo &operator=(const Foo &) = delete; /// const Foo &operator=(const Foo &) = delete;
/// }; /// };
/// ~~~ /// ~~~
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/modernize-replace-disallow-copy-and-assign-macro.html /// https://clang.llvm.org/extra/clang-tidy/checks/modernize-replace-disallow-copy-and-assign-macro.html
class ReplaceDisallowCopyAndAssignMacroCheck : public ClangTidyCheck { class ReplaceDisallowCopyAndAssignMacroCheck : public ClangTidyCheck {
public: public:
ReplaceDisallowCopyAndAssignMacroCheck(StringRef Name, ReplaceDisallowCopyAndAssignMacroCheck(StringRef Name,
ClangTidyContext *Context); ClangTidyContext *Context);
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus11; return LangOpts.CPlusPlus11;
} }
void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP, void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
Show All 14 Lines

clang-tools-extra/clang-tidy/modernize/ReplaceRandomShuffleCheck.h

Show All 14 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace modernize { namespace modernize {
/// std::random_shuffle will be removed as of C++17. This check will find and /// std::random_shuffle will be removed as of C++17. This check will find and
/// replace all occurrences of std::random_shuffle with std::shuffle. /// replace all occurrences of std::random_shuffle with std::shuffle.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/modernize-replace-random-shuffle.html /// https://clang.llvm.org/extra/clang-tidy/checks/modernize-replace-random-shuffle.html
class ReplaceRandomShuffleCheck : public ClangTidyCheck { class ReplaceRandomShuffleCheck : public ClangTidyCheck {
public: public:
ReplaceRandomShuffleCheck(StringRef Name, ClangTidyContext *Context); ReplaceRandomShuffleCheck(StringRef Name, ClangTidyContext *Context);
void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP, void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
Preprocessor *ModuleExpanderPP) override; Preprocessor *ModuleExpanderPP) override;
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus11; return LangOpts.CPlusPlus11;
} }
Show All 13 Lines

clang-tools-extra/clang-tidy/modernize/ReturnBracedInitListCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace modernize { namespace modernize {
/// Use a braced init list for return statements rather than unnecessary /// Use a braced init list for return statements rather than unnecessary
/// repeating the return type name. /// repeating the return type name.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/modernize-return-braced-init-list.html /// https://clang.llvm.org/extra/clang-tidy/checks/modernize-return-braced-init-list.html
class ReturnBracedInitListCheck : public ClangTidyCheck { class ReturnBracedInitListCheck : public ClangTidyCheck {
public: public:
ReturnBracedInitListCheck(StringRef Name, ClangTidyContext *Context) ReturnBracedInitListCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus11; return LangOpts.CPlusPlus11;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
Show All 11 Lines

clang-tools-extra/clang-tidy/modernize/UnaryStaticAssertCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace modernize { namespace modernize {
/// Replaces a static_assert declaration with an empty message /// Replaces a static_assert declaration with an empty message
/// with the unary version. /// with the unary version.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/modernize-unary-static-assert.html /// https://clang.llvm.org/extra/clang-tidy/checks/modernize-unary-static-assert.html
class UnaryStaticAssertCheck : public ClangTidyCheck { class UnaryStaticAssertCheck : public ClangTidyCheck {
public: public:
UnaryStaticAssertCheck(StringRef Name, ClangTidyContext *Context) UnaryStaticAssertCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus17; return LangOpts.CPlusPlus17;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace modernize } // namespace modernize
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_UNARY_STATIC_ASSERT_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_UNARY_STATIC_ASSERT_H

clang-tools-extra/clang-tidy/modernize/UseBoolLiteralsCheck.h

Show All 12 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace modernize { namespace modernize {
/// Finds integer literals which are cast to bool. /// Finds integer literals which are cast to bool.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/modernize-use-bool-literals.html /// https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-bool-literals.html
class UseBoolLiteralsCheck : public ClangTidyCheck { class UseBoolLiteralsCheck : public ClangTidyCheck {
public: public:
UseBoolLiteralsCheck(StringRef Name, ClangTidyContext *Context); UseBoolLiteralsCheck(StringRef Name, ClangTidyContext *Context);
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
void storeOptions(ClangTidyOptions::OptionMap &Opts) override; void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
Show All 11 Lines

clang-tools-extra/clang-tidy/modernize/UseDefaultMemberInitCheck.h

Show All 14 Lines
namespace tidy { namespace tidy {
namespace modernize { namespace modernize {
/// Convert a default constructor's member initializers into default member /// Convert a default constructor's member initializers into default member
/// initializers. Remove member initializers that are the same as a default /// initializers. Remove member initializers that are the same as a default
/// member initializer. /// member initializer.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/modernize-use-default-member-init.html /// https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-default-member-init.html
class UseDefaultMemberInitCheck : public ClangTidyCheck { class UseDefaultMemberInitCheck : public ClangTidyCheck {
public: public:
UseDefaultMemberInitCheck(StringRef Name, ClangTidyContext *Context); UseDefaultMemberInitCheck(StringRef Name, ClangTidyContext *Context);
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus11; return LangOpts.CPlusPlus11;
} }
void storeOptions(ClangTidyOptions::OptionMap &Opts) override; void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
Show All 20 Lines

clang-tools-extra/clang-tidy/modernize/UseEqualsDefaultCheck.h

Show All 27 Lines
/// struct A { /// struct A {
/// A() = default; /// A() = default;
/// ~A(); /// ~A();
/// }; /// };
/// A::~A() = default; /// A::~A() = default;
/// \endcode /// \endcode
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/modernize-use-equals-default.html /// https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-equals-default.html
class UseEqualsDefaultCheck : public ClangTidyCheck { class UseEqualsDefaultCheck : public ClangTidyCheck {
public: public:
UseEqualsDefaultCheck(StringRef Name, ClangTidyContext *Context); UseEqualsDefaultCheck(StringRef Name, ClangTidyContext *Context);
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
void storeOptions(ClangTidyOptions::OptionMap &Opts) override; void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
Show All 11 Lines

clang-tools-extra/clang-tidy/modernize/UseEqualsDeleteCheck.h

Show All 27 Lines
/// struct A { /// struct A {
/// private: /// private:
/// A(const A&) = delete; /// A(const A&) = delete;
/// A& operator=(const A&) = delete; /// A& operator=(const A&) = delete;
/// }; /// };
/// \endcode /// \endcode
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/modernize-use-equals-delete.html /// https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-equals-delete.html
class UseEqualsDeleteCheck : public ClangTidyCheck { class UseEqualsDeleteCheck : public ClangTidyCheck {
public: public:
UseEqualsDeleteCheck(StringRef Name, ClangTidyContext *Context) UseEqualsDeleteCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context), : ClangTidyCheck(Name, Context),
IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", true)) {} IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", true)) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
Show All 13 Lines

clang-tools-extra/clang-tidy/modernize/UseNodiscardCheck.h

Show All 24 Lines
/// Is converted to: /// Is converted to:
/// \code /// \code
/// [[nodiscard]] bool empty() const; /// [[nodiscard]] bool empty() const;
/// [[nodiscard]] bool empty(const Bar &) const; /// [[nodiscard]] bool empty(const Bar &) const;
/// [[nodiscard]] bool empty(int bar) const; /// [[nodiscard]] bool empty(int bar) const;
/// \endcode /// \endcode
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nodiscard.html /// https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nodiscard.html
class UseNodiscardCheck : public ClangTidyCheck { class UseNodiscardCheck : public ClangTidyCheck {
public: public:
UseNodiscardCheck(StringRef Name, ClangTidyContext *Context); UseNodiscardCheck(StringRef Name, ClangTidyContext *Context);
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override; bool isLanguageVersionSupported(const LangOptions &LangOpts) const override;
void storeOptions(ClangTidyOptions::OptionMap &Opts) override; void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
Show All 9 Lines

clang-tools-extra/clang-tidy/modernize/UseNoexceptCheck.h

Show All 22 Lines
/// \endcode /// \endcode
/// Is converted to: /// Is converted to:
/// \code /// \code
/// void foo() ; /// void foo() ;
/// void bar() noexcept(false); /// void bar() noexcept(false);
/// \endcode /// \endcode
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/modernize-use-noexcept.html /// https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-noexcept.html
class UseNoexceptCheck : public ClangTidyCheck { class UseNoexceptCheck : public ClangTidyCheck {
public: public:
UseNoexceptCheck(StringRef Name, ClangTidyContext *Context); UseNoexceptCheck(StringRef Name, ClangTidyContext *Context);
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus11; return LangOpts.CPlusPlus11;
} }
void storeOptions(ClangTidyOptions::OptionMap &Opts) override; void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
Show All 12 Lines

clang-tools-extra/clang-tidy/modernize/UseTrailingReturnTypeCheck.h

Show All 19 Linesstruct ClassifiedToken {
Token T; Token T;
bool IsQualifier; bool IsQualifier;
bool IsSpecifier; bool IsSpecifier;
}; };
/// Rewrites function signatures to use a trailing return type. /// Rewrites function signatures to use a trailing return type.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/modernize-use-trailing-type-return.html /// https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-trailing-type-return.html
class UseTrailingReturnTypeCheck : public ClangTidyCheck { class UseTrailingReturnTypeCheck : public ClangTidyCheck {
public: public:
UseTrailingReturnTypeCheck(StringRef Name, ClangTidyContext *Context) UseTrailingReturnTypeCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus11; return LangOpts.CPlusPlus11;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
Show All 30 Lines

clang-tools-extra/clang-tidy/modernize/UseTransparentFunctorsCheck.h

Show All 12 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace modernize { namespace modernize {
/// Prefer using transparent functors to non-transparent ones. /// Prefer using transparent functors to non-transparent ones.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/modernize-use-transparent-functors.html /// https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-transparent-functors.html
class UseTransparentFunctorsCheck : public ClangTidyCheck { class UseTransparentFunctorsCheck : public ClangTidyCheck {
public: public:
UseTransparentFunctorsCheck(StringRef Name, ClangTidyContext *Context); UseTransparentFunctorsCheck(StringRef Name, ClangTidyContext *Context);
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus14; return LangOpts.CPlusPlus14;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
Show All 10 Lines

clang-tools-extra/clang-tidy/modernize/UseUncaughtExceptionsCheck.h

//===--- UseUncaughtExceptionsCheck.h - clang-tidy------------*- C++ -*-===// //===--- UseUncaughtExceptionsCheck.h - clang-tidy------------*- C++ -*-===//
Lint: Lint
Inline Actions

clang-format suggested style edits found:

Lint: Lint: clang-format suggested style edits found:
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_UNCAUGHT_EXCEPTIONS_H #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_UNCAUGHT_EXCEPTIONS_H
#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_UNCAUGHT_EXCEPTIONS_H #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_UNCAUGHT_EXCEPTIONS_H
#include "../ClangTidyCheck.h" #include "../ClangTidyCheck.h"
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace modernize { namespace modernize {
/// This check will warn on calls to std::uncaught_exception and replace them with calls to /// This check will warn on calls to std::uncaught_exception and replace them with calls to
/// std::uncaught_exceptions, since std::uncaught_exception was deprecated in C++17. In case of /// std::uncaught_exceptions, since std::uncaught_exception was deprecated in C++17. In case of
/// macro ID there will be only a warning without fixits. /// macro ID there will be only a warning without fixits.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/modernize-use-uncaught-exceptions.html /// https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-uncaught-exceptions.html
class UseUncaughtExceptionsCheck : public ClangTidyCheck { class UseUncaughtExceptionsCheck : public ClangTidyCheck {
public: public:
UseUncaughtExceptionsCheck(StringRef Name, ClangTidyContext *Context) UseUncaughtExceptionsCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus17; return LangOpts.CPlusPlus17;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace modernize } // namespace modernize
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_UNCAUGHT_EXCEPTIONS_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_UNCAUGHT_EXCEPTIONS_H

clang-tools-extra/clang-tidy/modernize/UseUsingCheck.h

Show All 12 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace modernize { namespace modernize {
/// Check finds typedefs and replaces it with usings. /// Check finds typedefs and replaces it with usings.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/modernize-use-using.html /// https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-using.html
class UseUsingCheck : public ClangTidyCheck { class UseUsingCheck : public ClangTidyCheck {
const bool IgnoreMacros; const bool IgnoreMacros;
SourceLocation LastReplacementEnd; SourceLocation LastReplacementEnd;
llvm::DenseMap<const Decl *, SourceRange> LastTagDeclRanges; llvm::DenseMap<const Decl *, SourceRange> LastTagDeclRanges;
std::string FirstTypedefType; std::string FirstTypedefType;
std::string FirstTypedefName; std::string FirstTypedefName;
Show All 16 Lines

clang-tools-extra/clang-tidy/mpi/BufferDerefCheck.h

Show All 18 Lines
/// This check verifies if a buffer passed to an MPI (Message Passing Interface) /// This check verifies if a buffer passed to an MPI (Message Passing Interface)
/// function is sufficiently dereferenced. Buffers should be passed as a single /// function is sufficiently dereferenced. Buffers should be passed as a single
/// pointer or array. As MPI function signatures specify void * for their buffer /// pointer or array. As MPI function signatures specify void * for their buffer
/// types, insufficiently dereferenced buffers can be passed, like for example /// types, insufficiently dereferenced buffers can be passed, like for example
/// as double pointers or multidimensional arrays, without a compiler warning /// as double pointers or multidimensional arrays, without a compiler warning
/// emitted. /// emitted.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/mpi-buffer-deref.html /// https://clang.llvm.org/extra/clang-tidy/checks/mpi-buffer-deref.html
class BufferDerefCheck : public ClangTidyCheck { class BufferDerefCheck : public ClangTidyCheck {
public: public:
BufferDerefCheck(StringRef Name, ClangTidyContext *Context) BufferDerefCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
void onEndOfTranslationUnit() override; void onEndOfTranslationUnit() override;
Show All 19 Lines

clang-tools-extra/clang-tidy/mpi/TypeMismatchCheck.h

Show All 17 Lines
namespace mpi { namespace mpi {
/// This check verifies if buffer type and MPI (Message Passing Interface) /// This check verifies if buffer type and MPI (Message Passing Interface)
/// datatype pairs match. All MPI datatypes defined by the MPI standard (3.1) /// datatype pairs match. All MPI datatypes defined by the MPI standard (3.1)
/// are verified by this check. User defined typedefs, custom MPI datatypes and /// are verified by this check. User defined typedefs, custom MPI datatypes and
/// null pointer constants are skipped, in the course of verification. /// null pointer constants are skipped, in the course of verification.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/mpi-type-mismatch.html /// https://clang.llvm.org/extra/clang-tidy/checks/mpi-type-mismatch.html
class TypeMismatchCheck : public ClangTidyCheck { class TypeMismatchCheck : public ClangTidyCheck {
public: public:
TypeMismatchCheck(StringRef Name, ClangTidyContext *Context) TypeMismatchCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
Show All 21 Lines

clang-tools-extra/clang-tidy/objc/AssertEquals.h

Show All 14 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace objc { namespace objc {
/// Warn if XCTAssertEqual() or XCTAssertNotEqual() is used with at least one /// Warn if XCTAssertEqual() or XCTAssertNotEqual() is used with at least one
/// operands of type NSString*. /// operands of type NSString*.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/objc-assert-equals.html /// https://clang.llvm.org/extra/clang-tidy/checks/objc-assert-equals.html
class AssertEquals final : public ClangTidyCheck { class AssertEquals final : public ClangTidyCheck {
public: public:
AssertEquals(StringRef Name, ClangTidyContext *Context) AssertEquals(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.ObjC; return LangOpts.ObjC;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace objc } // namespace objc
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // THIRD_PARTY_LLVM_LLVM_PROJECT_CLANG_TOOLS_EXTRA_CLANG_TIDY_OBJC_OBJCASSERTEQUALS_H_ #endif // THIRD_PARTY_LLVM_LLVM_PROJECT_CLANG_TOOLS_EXTRA_CLANG_TIDY_OBJC_OBJCASSERTEQUALS_H_

clang-tools-extra/clang-tidy/objc/AvoidNSErrorInitCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace objc { namespace objc {
/// Finds usages of -[NSError init]. It is not the proper way of creating /// Finds usages of -[NSError init]. It is not the proper way of creating
/// NSError. errorWithDomain:code:userInfo: should be used instead. /// NSError. errorWithDomain:code:userInfo: should be used instead.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/objc-avoid-nserror-init.html /// https://clang.llvm.org/extra/clang-tidy/checks/objc-avoid-nserror-init.html
class AvoidNSErrorInitCheck : public ClangTidyCheck { class AvoidNSErrorInitCheck : public ClangTidyCheck {
public: public:
AvoidNSErrorInitCheck(StringRef Name, ClangTidyContext *Context) AvoidNSErrorInitCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.ObjC; return LangOpts.ObjC;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace objc } // namespace objc
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_OBJC_AVOIDNSERRORINITCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_OBJC_AVOIDNSERRORINITCHECK_H

clang-tools-extra/clang-tidy/objc/DeallocInCategoryCheck.h

Show All 14 Lines
namespace tidy { namespace tidy {
namespace objc { namespace objc {
/// Finds implementations of -dealloc in Objective-C categories. The category /// Finds implementations of -dealloc in Objective-C categories. The category
/// implementation will override any dealloc in the class implementation, /// implementation will override any dealloc in the class implementation,
/// potentially causing issues. /// potentially causing issues.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/objc-dealloc-in-category.html /// https://clang.llvm.org/extra/clang-tidy/checks/objc-dealloc-in-category.html
class DeallocInCategoryCheck final : public ClangTidyCheck { class DeallocInCategoryCheck final : public ClangTidyCheck {
public: public:
DeallocInCategoryCheck(StringRef Name, ClangTidyContext *Context) DeallocInCategoryCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.ObjC; return LangOpts.ObjC;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace objc } // namespace objc
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_OBJC_DEALLOCINCATEGORYCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_OBJC_DEALLOCINCATEGORYCHECK_H

clang-tools-extra/clang-tidy/objc/ForbiddenSubclassingCheck.h

Show All 15 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace objc { namespace objc {
/// Finds Objective-C classes which have a superclass which is /// Finds Objective-C classes which have a superclass which is
/// documented to not support subclassing. /// documented to not support subclassing.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/objc-forbidden-subclassing.html /// https://clang.llvm.org/extra/clang-tidy/checks/objc-forbidden-subclassing.html
class ForbiddenSubclassingCheck : public ClangTidyCheck { class ForbiddenSubclassingCheck : public ClangTidyCheck {
public: public:
ForbiddenSubclassingCheck(StringRef Name, ClangTidyContext *Context); ForbiddenSubclassingCheck(StringRef Name, ClangTidyContext *Context);
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.ObjC; return LangOpts.ObjC;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
Show All 11 Lines

clang-tools-extra/clang-tidy/objc/MissingHashCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace objc { namespace objc {
/// Finds Objective-C implementations that implement -isEqual: without also /// Finds Objective-C implementations that implement -isEqual: without also
/// appropriately implementing -hash. /// appropriately implementing -hash.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/objc-missing-hash.html /// https://clang.llvm.org/extra/clang-tidy/checks/objc-missing-hash.html
class MissingHashCheck : public ClangTidyCheck { class MissingHashCheck : public ClangTidyCheck {
public: public:
MissingHashCheck(StringRef Name, ClangTidyContext *Context) MissingHashCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.ObjC; return LangOpts.ObjC;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace objc } // namespace objc
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_OBJC_MISSINGHASHCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_OBJC_MISSINGHASHCHECK_H

clang-tools-extra/clang-tidy/objc/NSInvocationArgumentLifetimeCheck.h

Show All 14 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace objc { namespace objc {
/// Finds calls to NSInvocation methods under ARC that don't have proper /// Finds calls to NSInvocation methods under ARC that don't have proper
/// argument object lifetimes. /// argument object lifetimes.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/objc-nsinvocation-argument-lifetime.html /// https://clang.llvm.org/extra/clang-tidy/checks/objc-nsinvocation-argument-lifetime.html
class NSInvocationArgumentLifetimeCheck : public ClangTidyCheck { class NSInvocationArgumentLifetimeCheck : public ClangTidyCheck {
public: public:
NSInvocationArgumentLifetimeCheck(StringRef Name, ClangTidyContext *Context) NSInvocationArgumentLifetimeCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.ObjC && LangOpts.ObjCAutoRefCount; return LangOpts.ObjC && LangOpts.ObjCAutoRefCount;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace objc } // namespace objc
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_OBJC_NSINVOCATIONARGUMENTLIFETIMECHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_OBJC_NSINVOCATIONARGUMENTLIFETIMECHECK_H

clang-tools-extra/clang-tidy/objc/PropertyDeclarationCheck.h

Show All 16 Lines
/// Finds Objective-C property declarations which /// Finds Objective-C property declarations which
/// are not in Lower Camel Case. /// are not in Lower Camel Case.
/// ///
/// The format of property should look like: /// The format of property should look like:
/// @property(nonatomic) NSString *lowerCamelCase; /// @property(nonatomic) NSString *lowerCamelCase;
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/objc-property-declaration.html /// https://clang.llvm.org/extra/clang-tidy/checks/objc-property-declaration.html
class PropertyDeclarationCheck : public ClangTidyCheck { class PropertyDeclarationCheck : public ClangTidyCheck {
public: public:
PropertyDeclarationCheck(StringRef Name, ClangTidyContext *Context) PropertyDeclarationCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.ObjC; return LangOpts.ObjC;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace objc } // namespace objc
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_OBJC_PROPERTY_DECLARATION_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_OBJC_PROPERTY_DECLARATION_H

clang-tools-extra/clang-tidy/objc/SuperSelfCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace objc { namespace objc {
/// Finds invocations of -self on super instances in initializers of subclasses /// Finds invocations of -self on super instances in initializers of subclasses
/// of NSObject and recommends calling a superclass initializer instead. /// of NSObject and recommends calling a superclass initializer instead.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/objc-super-self.html /// https://clang.llvm.org/extra/clang-tidy/checks/objc-super-self.html
class SuperSelfCheck : public ClangTidyCheck { class SuperSelfCheck : public ClangTidyCheck {
public: public:
SuperSelfCheck(StringRef Name, ClangTidyContext *Context) SuperSelfCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.ObjC; return LangOpts.ObjC;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace objc } // namespace objc
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_OBJC_SUPERSELFCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_OBJC_SUPERSELFCHECK_H

clang-tools-extra/clang-tidy/openmp/ExceptionEscapeCheck.h

Show All 14 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace openmp { namespace openmp {
/// Analyzes OpenMP Structured Blocks and checks that no exception escapes /// Analyzes OpenMP Structured Blocks and checks that no exception escapes
/// out of the Structured Block it was thrown in. /// out of the Structured Block it was thrown in.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/openmp-exception-escape.html /// https://clang.llvm.org/extra/clang-tidy/checks/openmp-exception-escape.html
class ExceptionEscapeCheck : public ClangTidyCheck { class ExceptionEscapeCheck : public ClangTidyCheck {
public: public:
ExceptionEscapeCheck(StringRef Name, ClangTidyContext *Context); ExceptionEscapeCheck(StringRef Name, ClangTidyContext *Context);
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.OpenMP && LangOpts.CPlusPlus && LangOpts.CXXExceptions; return LangOpts.OpenMP && LangOpts.CPlusPlus && LangOpts.CXXExceptions;
} }
void storeOptions(ClangTidyOptions::OptionMap &Opts) override; void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
Show All 13 Lines

clang-tools-extra/clang-tidy/openmp/UseDefaultNoneCheck.h

Show All 14 Lines
namespace tidy { namespace tidy {
namespace openmp { namespace openmp {
/// Finds OpenMP directives that are allowed to contain a ``default`` clause, /// Finds OpenMP directives that are allowed to contain a ``default`` clause,
/// but either don't specify it or the clause is specified but with the kind /// but either don't specify it or the clause is specified but with the kind
/// other than ``none``, and suggests to use the ``default(none)`` clause. /// other than ``none``, and suggests to use the ``default(none)`` clause.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/openmp-use-default-none.html /// https://clang.llvm.org/extra/clang-tidy/checks/openmp-use-default-none.html
class UseDefaultNoneCheck : public ClangTidyCheck { class UseDefaultNoneCheck : public ClangTidyCheck {
public: public:
UseDefaultNoneCheck(StringRef Name, ClangTidyContext *Context) UseDefaultNoneCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.OpenMP; return LangOpts.OpenMP;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace openmp } // namespace openmp
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_OPENMP_USEDEFAULTNONECHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_OPENMP_USEDEFAULTNONECHECK_H

clang-tools-extra/clang-tidy/performance/FasterStringFindCheck.h

Show All 17 Lines
namespace tidy { namespace tidy {
namespace performance { namespace performance {
/// Optimize calls to std::string::find() and friends when the needle passed is /// Optimize calls to std::string::find() and friends when the needle passed is
/// a single character string literal. /// a single character string literal.
/// The character literal overload is more efficient. /// The character literal overload is more efficient.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/performance-faster-string-find.html /// https://clang.llvm.org/extra/clang-tidy/checks/performance-faster-string-find.html
class FasterStringFindCheck : public ClangTidyCheck { class FasterStringFindCheck : public ClangTidyCheck {
public: public:
FasterStringFindCheck(StringRef Name, ClangTidyContext *Context); FasterStringFindCheck(StringRef Name, ClangTidyContext *Context);
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override{ bool isLanguageVersionSupported(const LangOptions &LangOpts) const override{
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
Show All 11 Lines

clang-tools-extra/clang-tidy/performance/ForRangeCopyCheck.h

Show All 12 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace performance { namespace performance {
/// A check that detects copied loop variables and suggests using const /// A check that detects copied loop variables and suggests using const
/// references. /// references.
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/performance-for-range-copy.html /// https://clang.llvm.org/extra/clang-tidy/checks/performance-for-range-copy.html
class ForRangeCopyCheck : public ClangTidyCheck { class ForRangeCopyCheck : public ClangTidyCheck {
public: public:
ForRangeCopyCheck(StringRef Name, ClangTidyContext *Context); ForRangeCopyCheck(StringRef Name, ClangTidyContext *Context);
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override{ bool isLanguageVersionSupported(const LangOptions &LangOpts) const override{
return LangOpts.CPlusPlus11; return LangOpts.CPlusPlus11;
} }
void storeOptions(ClangTidyOptions::OptionMap &Opts) override; void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
Show All 23 Lines

clang-tools-extra/clang-tidy/performance/InefficientStringConcatenationCheck.h

Show All 14 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace performance { namespace performance {
/// This check is to warn about the performance overhead arising from /// This check is to warn about the performance overhead arising from
/// concatenating strings, using the operator+, instead of operator+=. /// concatenating strings, using the operator+, instead of operator+=.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/performance-inefficient-string-concatenation.html /// https://clang.llvm.org/extra/clang-tidy/checks/performance-inefficient-string-concatenation.html
class InefficientStringConcatenationCheck : public ClangTidyCheck { class InefficientStringConcatenationCheck : public ClangTidyCheck {
public: public:
InefficientStringConcatenationCheck(StringRef Name, InefficientStringConcatenationCheck(StringRef Name,
ClangTidyContext *Context); ClangTidyContext *Context);
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
Show All 12 Lines

clang-tools-extra/clang-tidy/performance/InefficientVectorOperationCheck.h

Show All 16 Lines
/// Finds possible inefficient `std::vector` operations (e.g. `push_back`) in /// Finds possible inefficient `std::vector` operations (e.g. `push_back`) in
/// for loops that may cause unnecessary memory reallocations. /// for loops that may cause unnecessary memory reallocations.
/// ///
/// When EnableProto, also finds calls that add element to protobuf repeated /// When EnableProto, also finds calls that add element to protobuf repeated
/// field without calling Reserve() first. /// field without calling Reserve() first.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/performance-inefficient-vector-operation.html /// https://clang.llvm.org/extra/clang-tidy/checks/performance-inefficient-vector-operation.html
class InefficientVectorOperationCheck : public ClangTidyCheck { class InefficientVectorOperationCheck : public ClangTidyCheck {
public: public:
InefficientVectorOperationCheck(StringRef Name, ClangTidyContext *Context); InefficientVectorOperationCheck(StringRef Name, ClangTidyContext *Context);
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override{ bool isLanguageVersionSupported(const LangOptions &LangOpts) const override{
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
Show All 18 Lines

clang-tools-extra/clang-tidy/performance/MoveConstructorInitCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace performance { namespace performance {
/// The check flags user-defined move constructors that have a ctor-initializer /// The check flags user-defined move constructors that have a ctor-initializer
/// initializing a member or base class through a copy constructor instead of a /// initializing a member or base class through a copy constructor instead of a
/// move constructor. /// move constructor.
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/performance-move-constructor-init.html /// https://clang.llvm.org/extra/clang-tidy/checks/performance-move-constructor-init.html
class MoveConstructorInitCheck : public ClangTidyCheck { class MoveConstructorInitCheck : public ClangTidyCheck {
public: public:
MoveConstructorInitCheck(StringRef Name, ClangTidyContext *Context); MoveConstructorInitCheck(StringRef Name, ClangTidyContext *Context);
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus11; return LangOpts.CPlusPlus11;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace performance } // namespace performance
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_MOVECONSTRUCTORINITCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_MOVECONSTRUCTORINITCHECK_H

clang-tools-extra/clang-tidy/performance/NoAutomaticMoveCheck.h

Show All 11 Lines
#include "../ClangTidyCheck.h" #include "../ClangTidyCheck.h"
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace performance { namespace performance {
/// Finds local variables that cannot be automatically moved due to constness. /// Finds local variables that cannot be automatically moved due to constness.
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/performance-no-automatic-move.html /// https://clang.llvm.org/extra/clang-tidy/checks/performance-no-automatic-move.html
class NoAutomaticMoveCheck : public ClangTidyCheck { class NoAutomaticMoveCheck : public ClangTidyCheck {
public: public:
NoAutomaticMoveCheck(StringRef Name, ClangTidyContext *Context); NoAutomaticMoveCheck(StringRef Name, ClangTidyContext *Context);
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus11; return LangOpts.CPlusPlus11;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
Show All 11 Lines

clang-tools-extra/clang-tidy/performance/NoIntToPtrCheck.h

Show All 12 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace performance { namespace performance {
/// Diagnoses every integer to pointer cast. /// Diagnoses every integer to pointer cast.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/performance-no-int-to-ptr.html /// https://clang.llvm.org/extra/clang-tidy/checks/performance-no-int-to-ptr.html
class NoIntToPtrCheck : public ClangTidyCheck { class NoIntToPtrCheck : public ClangTidyCheck {
public: public:
NoIntToPtrCheck(StringRef Name, ClangTidyContext *Context) NoIntToPtrCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace performance } // namespace performance
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_NOINTTOPTRCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_NOINTTOPTRCHECK_H

clang-tools-extra/clang-tidy/performance/TriviallyDestructibleCheck.h

Show All 18 Lines
/// destructors declared out-of-line: /// destructors declared out-of-line:
/// struct A: TrivialClass { /// struct A: TrivialClass {
/// ~A(); /// ~A();
/// TrivialClass trivial_fields; /// TrivialClass trivial_fields;
/// }; /// };
/// A::~A() = default; /// A::~A() = default;
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/performance-trivially-destructible.html /// https://clang.llvm.org/extra/clang-tidy/checks/performance-trivially-destructible.html
class TriviallyDestructibleCheck : public ClangTidyCheck { class TriviallyDestructibleCheck : public ClangTidyCheck {
public: public:
TriviallyDestructibleCheck(StringRef Name, ClangTidyContext *Context) TriviallyDestructibleCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus11; return LangOpts.CPlusPlus11;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace performance } // namespace performance
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_TRIVIALLYDESTRUCTIBLECHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_TRIVIALLYDESTRUCTIBLECHECK_H

clang-tools-extra/clang-tidy/performance/TypePromotionInMathFnCheck.h

Show All 18 Lines
/// Finds calls to C math library functions with implicit float to double /// Finds calls to C math library functions with implicit float to double
/// promotions. /// promotions.
/// ///
/// For example, warns on ::sin(0.f), because this funciton's parameter is a /// For example, warns on ::sin(0.f), because this funciton's parameter is a
/// double. You probably meant to call std::sin(0.f) (in C++), or sinf(0.f) (in /// double. You probably meant to call std::sin(0.f) (in C++), or sinf(0.f) (in
/// C). /// C).
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/performance-type-promotion-in-math-fn.html /// https://clang.llvm.org/extra/clang-tidy/checks/performance-type-promotion-in-math-fn.html
class TypePromotionInMathFnCheck : public ClangTidyCheck { class TypePromotionInMathFnCheck : public ClangTidyCheck {
public: public:
TypePromotionInMathFnCheck(StringRef Name, ClangTidyContext *Context); TypePromotionInMathFnCheck(StringRef Name, ClangTidyContext *Context);
void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP, void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
Preprocessor *ModuleExpanderPP) override; Preprocessor *ModuleExpanderPP) override;
void storeOptions(ClangTidyOptions::OptionMap &Opts) override; void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
Show All 11 Lines

clang-tools-extra/clang-tidy/performance/UnnecessaryValueParamCheck.h

Show All 15 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace performance { namespace performance {
/// A check that flags value parameters of expensive to copy types that /// A check that flags value parameters of expensive to copy types that
/// can safely be converted to const references. /// can safely be converted to const references.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/performance-unnecessary-value-param.html /// https://clang.llvm.org/extra/clang-tidy/checks/performance-unnecessary-value-param.html
class UnnecessaryValueParamCheck : public ClangTidyCheck { class UnnecessaryValueParamCheck : public ClangTidyCheck {
public: public:
UnnecessaryValueParamCheck(StringRef Name, ClangTidyContext *Context); UnnecessaryValueParamCheck(StringRef Name, ClangTidyContext *Context);
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
Show All 20 Lines

clang-tools-extra/clang-tidy/portability/RestrictSystemIncludesCheck.h

Show All 15 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace portability { namespace portability {
/// Checks for allowed includes and suggests removal of any others. If no /// Checks for allowed includes and suggests removal of any others. If no
/// includes are specified, the check will exit without issuing any warnings. /// includes are specified, the check will exit without issuing any warnings.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/portability-restrict-system-includes.html /// https://clang.llvm.org/extra/clang-tidy/checks/portability-restrict-system-includes.html
class RestrictSystemIncludesCheck : public ClangTidyCheck { class RestrictSystemIncludesCheck : public ClangTidyCheck {
public: public:
RestrictSystemIncludesCheck(StringRef Name, ClangTidyContext *Context, RestrictSystemIncludesCheck(StringRef Name, ClangTidyContext *Context,
std::string DefaultAllowedIncludes = "*") std::string DefaultAllowedIncludes = "*")
: ClangTidyCheck(Name, Context), : ClangTidyCheck(Name, Context),
AllowedIncludes(Options.get("Includes", DefaultAllowedIncludes)), AllowedIncludes(Options.get("Includes", DefaultAllowedIncludes)),
AllowedIncludesGlobList(AllowedIncludes) {} AllowedIncludesGlobList(AllowedIncludes) {}
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/portability/SIMDIntrinsicsCheck.h

Show All 14 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace portability { namespace portability {
/// Find SIMD intrinsics calls and suggest std::experimental::simd alternatives. /// Find SIMD intrinsics calls and suggest std::experimental::simd alternatives.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/portability-simd-intrinsics.html /// https://clang.llvm.org/extra/clang-tidy/checks/portability-simd-intrinsics.html
class SIMDIntrinsicsCheck : public ClangTidyCheck { class SIMDIntrinsicsCheck : public ClangTidyCheck {
public: public:
SIMDIntrinsicsCheck(StringRef Name, ClangTidyContext *Context); SIMDIntrinsicsCheck(StringRef Name, ClangTidyContext *Context);
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus11; return LangOpts.CPlusPlus11;
} }
void storeOptions(ClangTidyOptions::OptionMap &Opts) override; void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
Show All 13 Lines

clang-tools-extra/clang-tidy/portability/StdAllocatorConstCheck.h

Show All 14 Lines
namespace tidy { namespace tidy {
namespace portability { namespace portability {
/// Report use of ``std::vector<const T>`` (and similar containers of const /// Report use of ``std::vector<const T>`` (and similar containers of const
/// elements). These are not allowed in standard C++ due to undefined /// elements). These are not allowed in standard C++ due to undefined
/// ``std::allocator<const T>``. They do not compile with libstdc++ or MSVC. /// ``std::allocator<const T>``. They do not compile with libstdc++ or MSVC.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/portability-std-allocator-const.html /// https://clang.llvm.org/extra/clang-tidy/checks/portability-std-allocator-const.html
class StdAllocatorConstCheck : public ClangTidyCheck { class StdAllocatorConstCheck : public ClangTidyCheck {
public: public:
StdAllocatorConstCheck(StringRef Name, ClangTidyContext *Context) StdAllocatorConstCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace portability } // namespace portability
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PORTABILITY_STDALLOCATORCONSTCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PORTABILITY_STDALLOCATORCONSTCHECK_H

clang-tools-extra/clang-tidy/readability/ConstReturnTypeCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace readability { namespace readability {
/// For any function whose return type is const-qualified, suggests removal of /// For any function whose return type is const-qualified, suggests removal of
/// the `const` qualifier from that return type. /// the `const` qualifier from that return type.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/readability-const-return-type.html /// https://clang.llvm.org/extra/clang-tidy/checks/readability-const-return-type.html
class ConstReturnTypeCheck : public ClangTidyCheck { class ConstReturnTypeCheck : public ClangTidyCheck {
public: public:
using ClangTidyCheck::ClangTidyCheck; using ClangTidyCheck::ClangTidyCheck;
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace readability } // namespace readability
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_CONSTRETURNTYPECHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_CONSTRETURNTYPECHECK_H

clang-tools-extra/clang-tidy/readability/ContainerContainsCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace readability { namespace readability {
/// Finds usages of `container.count()` and `find() == end()` which should be /// Finds usages of `container.count()` and `find() == end()` which should be
/// replaced by a call to the `container.contains()` method introduced in C++20. /// replaced by a call to the `container.contains()` method introduced in C++20.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/readability-container-contains.html /// https://clang.llvm.org/extra/clang-tidy/checks/readability-container-contains.html
class ContainerContainsCheck : public ClangTidyCheck { class ContainerContainsCheck : public ClangTidyCheck {
public: public:
ContainerContainsCheck(StringRef Name, ClangTidyContext *Context) ContainerContainsCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) final; void registerMatchers(ast_matchers::MatchFinder *Finder) final;
void check(const ast_matchers::MatchFinder::MatchResult &Result) final; void check(const ast_matchers::MatchFinder::MatchResult &Result) final;
protected: protected:
Show All 10 Lines

clang-tools-extra/clang-tidy/readability/ConvertMemberFunctionsToStatic.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace readability { namespace readability {
/// This check finds C++ class methods than can be made static /// This check finds C++ class methods than can be made static
/// because they don't use the 'this' pointer. /// because they don't use the 'this' pointer.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/ /// https://clang.llvm.org/extra/clang-tidy/checks/
/// readability-convert-member-functions-to-static.html /// readability-convert-member-functions-to-static.html
class ConvertMemberFunctionsToStatic : public ClangTidyCheck { class ConvertMemberFunctionsToStatic : public ClangTidyCheck {
public: public:
ConvertMemberFunctionsToStatic(StringRef Name, ClangTidyContext *Context) ConvertMemberFunctionsToStatic(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace readability } // namespace readability
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_CONVERTMEMFUNCTOSTATIC_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_CONVERTMEMFUNCTOSTATIC_H

clang-tools-extra/clang-tidy/readability/DeleteNullPointerCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace readability { namespace readability {
/// Check whether the 'if' statement is unnecessary before calling 'delete' on a /// Check whether the 'if' statement is unnecessary before calling 'delete' on a
/// pointer. /// pointer.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/readability-delete-null-pointer.html /// https://clang.llvm.org/extra/clang-tidy/checks/readability-delete-null-pointer.html
class DeleteNullPointerCheck : public ClangTidyCheck { class DeleteNullPointerCheck : public ClangTidyCheck {
public: public:
DeleteNullPointerCheck(StringRef Name, ClangTidyContext *Context) DeleteNullPointerCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
llvm::Optional<TraversalKind> getCheckTraversalKind() const override { llvm::Optional<TraversalKind> getCheckTraversalKind() const override {
return TK_IgnoreUnlessSpelledInSource; return TK_IgnoreUnlessSpelledInSource;
} }
}; };
} // namespace readability } // namespace readability
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_DELETE_NULL_POINTER_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_DELETE_NULL_POINTER_H

clang-tools-extra/clang-tidy/readability/ElseAfterReturnCheck.h

Show All 12 Lines
#include "llvm/ADT/DenseMap.h" #include "llvm/ADT/DenseMap.h"
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace readability { namespace readability {
/// Flags the usages of `else` after `return`. /// Flags the usages of `else` after `return`.
/// ///
/// http://llvm.org/docs/CodingStandards.html#don-t-use-else-after-a-return /// https://llvm.org/docs/CodingStandards.html#don-t-use-else-after-a-return
class ElseAfterReturnCheck : public ClangTidyCheck { class ElseAfterReturnCheck : public ClangTidyCheck {
public: public:
ElseAfterReturnCheck(StringRef Name, ClangTidyContext *Context); ElseAfterReturnCheck(StringRef Name, ClangTidyContext *Context);
void storeOptions(ClangTidyOptions::OptionMap &Opts) override; void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP, void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
Preprocessor *ModuleExpanderPP) override; Preprocessor *ModuleExpanderPP) override;
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
Show All 19 Lines

clang-tools-extra/clang-tidy/readability/FunctionCognitiveComplexityCheck.h

Show All 24 Lines
/// exceeding the complexity threshold the check will issue additional /// exceeding the complexity threshold the check will issue additional
/// diagnostics on every piece of code (loop, `if` statement, etc.) which /// diagnostics on every piece of code (loop, `if` statement, etc.) which
/// contributes to that complexity. /// contributes to that complexity.
// Default is `true` // Default is `true`
/// * `IgnoreMacros` - if set to `true`, the check will ignore code inside /// * `IgnoreMacros` - if set to `true`, the check will ignore code inside
/// macros. Default is `false`. /// macros. Default is `false`.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/readability-function-cognitive-complexity.html /// https://clang.llvm.org/extra/clang-tidy/checks/readability-function-cognitive-complexity.html
class FunctionCognitiveComplexityCheck : public ClangTidyCheck { class FunctionCognitiveComplexityCheck : public ClangTidyCheck {
public: public:
FunctionCognitiveComplexityCheck(StringRef Name, ClangTidyContext *Context); FunctionCognitiveComplexityCheck(StringRef Name, ClangTidyContext *Context);
void storeOptions(ClangTidyOptions::OptionMap &Opts) override; void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
llvm::Optional<TraversalKind> getCheckTraversalKind() const override { llvm::Optional<TraversalKind> getCheckTraversalKind() const override {
Show All 14 Lines

clang-tools-extra/clang-tidy/readability/FunctionCognitiveComplexityCheck.cpp

Show All 37 Lines
namespace readability { namespace readability {
namespace { namespace {
struct CognitiveComplexity final { struct CognitiveComplexity final {
// Any increment is based on some combination of reasons. // Any increment is based on some combination of reasons.
// For details you can look at the Specification at // For details you can look at the Specification at
// https://www.sonarsource.com/docs/CognitiveComplexity.pdf // https://www.sonarsource.com/docs/CognitiveComplexity.pdf
// or user-facing docs at // or user-facing docs at
// http://clang.llvm.org/extra/clang-tidy/checks/readability-function-cognitive-complexity.html // https://clang.llvm.org/extra/clang-tidy/checks/readability-function-cognitive-complexity.html
// Here are all the possible reasons: // Here are all the possible reasons:
enum Criteria : uint8_t { enum Criteria : uint8_t {
None = 0U, None = 0U,
// B1, increases cognitive complexity (by 1) // B1, increases cognitive complexity (by 1)
// What causes it: // What causes it:
// * if, else if, else, ConditionalOperator (not BinaryConditionalOperator) // * if, else if, else, ConditionalOperator (not BinaryConditionalOperator)
// * SwitchStmt // * SwitchStmt
▲ Show 20 Lines • Show All 516 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/readability/IdentifierLengthCheck.h

Show All 14 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace readability { namespace readability {
/// Warns about identifiers names whose length is too short. /// Warns about identifiers names whose length is too short.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/readability-identifier-length.html /// https://clang.llvm.org/extra/clang-tidy/checks/readability-identifier-length.html
class IdentifierLengthCheck : public ClangTidyCheck { class IdentifierLengthCheck : public ClangTidyCheck {
public: public:
IdentifierLengthCheck(StringRef Name, ClangTidyContext *Context); IdentifierLengthCheck(StringRef Name, ClangTidyContext *Context);
void storeOptions(ClangTidyOptions::OptionMap &Opts) override; void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
private: private:
Show All 23 Lines

clang-tools-extra/clang-tidy/readability/ImplicitBoolConversionCheck.h

Show All 12 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace readability { namespace readability {
/// Checks for use of implicit bool conversions in expressions. /// Checks for use of implicit bool conversions in expressions.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/readability-implicit-bool-conversion.html /// https://clang.llvm.org/extra/clang-tidy/checks/readability-implicit-bool-conversion.html
class ImplicitBoolConversionCheck : public ClangTidyCheck { class ImplicitBoolConversionCheck : public ClangTidyCheck {
public: public:
ImplicitBoolConversionCheck(StringRef Name, ClangTidyContext *Context); ImplicitBoolConversionCheck(StringRef Name, ClangTidyContext *Context);
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.Bool; return LangOpts.Bool;
} }
void storeOptions(ClangTidyOptions::OptionMap &Opts) override; void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
Show All 18 Lines

clang-tools-extra/clang-tidy/readability/InconsistentDeclarationParameterNameCheck.h

Show All 14 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace readability { namespace readability {
/// Checks for declarations of functions which differ in parameter names. /// Checks for declarations of functions which differ in parameter names.
/// ///
/// For detailed documentation see: /// For detailed documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/readability-inconsistent-declaration-parameter-name.html /// https://clang.llvm.org/extra/clang-tidy/checks/readability-inconsistent-declaration-parameter-name.html
/// ///
class InconsistentDeclarationParameterNameCheck : public ClangTidyCheck { class InconsistentDeclarationParameterNameCheck : public ClangTidyCheck {
public: public:
InconsistentDeclarationParameterNameCheck(StringRef Name, InconsistentDeclarationParameterNameCheck(StringRef Name,
ClangTidyContext *Context) ClangTidyContext *Context)
: ClangTidyCheck(Name, Context), : ClangTidyCheck(Name, Context),
IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", true)), IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", true)),
Strict(Options.getLocalOrGlobal("Strict", false)) {} Strict(Options.getLocalOrGlobal("Strict", false)) {}
Show All 21 Lines

clang-tools-extra/clang-tidy/readability/IsolateDeclarationCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace readability { namespace readability {
/// This check diagnoses all DeclStmt's declaring more than one variable and /// This check diagnoses all DeclStmt's declaring more than one variable and
/// tries to refactor the code to one statement per declaration. /// tries to refactor the code to one statement per declaration.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/readability-isolate-declaration.html /// https://clang.llvm.org/extra/clang-tidy/checks/readability-isolate-declaration.html
class IsolateDeclarationCheck : public ClangTidyCheck { class IsolateDeclarationCheck : public ClangTidyCheck {
public: public:
IsolateDeclarationCheck(StringRef Name, ClangTidyContext *Context) IsolateDeclarationCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace readability } // namespace readability
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_ISOLATEDECLCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_ISOLATEDECLCHECK_H

clang-tools-extra/clang-tidy/readability/MagicNumbersCheck.h

Show All 15 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace readability { namespace readability {
/// Detects magic numbers, integer and floating point literals embedded in code. /// Detects magic numbers, integer and floating point literals embedded in code.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/readability-magic-numbers.html /// https://clang.llvm.org/extra/clang-tidy/checks/readability-magic-numbers.html
class MagicNumbersCheck : public ClangTidyCheck { class MagicNumbersCheck : public ClangTidyCheck {
public: public:
MagicNumbersCheck(StringRef Name, ClangTidyContext *Context); MagicNumbersCheck(StringRef Name, ClangTidyContext *Context);
void storeOptions(ClangTidyOptions::OptionMap &Opts) override; void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
private: private:
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/readability/MakeMemberFunctionConstCheck.h

Show All 12 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace readability { namespace readability {
/// Finds non-static member functions that can be made 'const'. /// Finds non-static member functions that can be made 'const'.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/readability-make-member-function-const.html /// https://clang.llvm.org/extra/clang-tidy/checks/readability-make-member-function-const.html
class MakeMemberFunctionConstCheck : public ClangTidyCheck { class MakeMemberFunctionConstCheck : public ClangTidyCheck {
public: public:
MakeMemberFunctionConstCheck(StringRef Name, ClangTidyContext *Context) MakeMemberFunctionConstCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace readability } // namespace readability
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_MAKEMEMBERFUNCTIONCONSTCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_MAKEMEMBERFUNCTIONCONSTCHECK_H

clang-tools-extra/clang-tidy/readability/MisleadingIndentationCheck.h

Show All 14 Lines
namespace tidy { namespace tidy {
namespace readability { namespace readability {
/// Checks the code for dangling else, and possible misleading indentations due /// Checks the code for dangling else, and possible misleading indentations due
/// to missing braces. Note that this check only works as expected when the tabs /// to missing braces. Note that this check only works as expected when the tabs
/// or spaces are used consistently and not mixed. /// or spaces are used consistently and not mixed.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/readability-misleading-indentation.html /// https://clang.llvm.org/extra/clang-tidy/checks/readability-misleading-indentation.html
class MisleadingIndentationCheck : public ClangTidyCheck { class MisleadingIndentationCheck : public ClangTidyCheck {
public: public:
MisleadingIndentationCheck(StringRef Name, ClangTidyContext *Context) MisleadingIndentationCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
llvm::Optional<TraversalKind> getCheckTraversalKind() const override { llvm::Optional<TraversalKind> getCheckTraversalKind() const override {
return TK_IgnoreUnlessSpelledInSource; return TK_IgnoreUnlessSpelledInSource;
Show All 13 Lines

clang-tools-extra/clang-tidy/readability/MisplacedArrayIndexCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace readability { namespace readability {
/// Warn about unusual array index syntax (`index[array]` instead of /// Warn about unusual array index syntax (`index[array]` instead of
/// `array[index]`). /// `array[index]`).
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/readability-misplaced-array-index.html /// https://clang.llvm.org/extra/clang-tidy/checks/readability-misplaced-array-index.html
class MisplacedArrayIndexCheck : public ClangTidyCheck { class MisplacedArrayIndexCheck : public ClangTidyCheck {
public: public:
MisplacedArrayIndexCheck(StringRef Name, ClangTidyContext *Context) MisplacedArrayIndexCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace readability } // namespace readability
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_MISPLACED_ARRAY_INDEX_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_MISPLACED_ARRAY_INDEX_H

clang-tools-extra/clang-tidy/readability/NamespaceCommentCheck.h

Show All 12 Lines
#include "llvm/Support/Regex.h" #include "llvm/Support/Regex.h"
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace readability { namespace readability {
/// Checks that long namespaces have a closing comment. /// Checks that long namespaces have a closing comment.
/// ///
/// http://llvm.org/docs/CodingStandards.html#namespace-indentation /// https://llvm.org/docs/CodingStandards.html#namespace-indentation
/// ///
/// https://google.github.io/styleguide/cppguide.html#Namespaces /// https://google.github.io/styleguide/cppguide.html#Namespaces
class NamespaceCommentCheck : public ClangTidyCheck { class NamespaceCommentCheck : public ClangTidyCheck {
public: public:
NamespaceCommentCheck(StringRef Name, ClangTidyContext *Context); NamespaceCommentCheck(StringRef Name, ClangTidyContext *Context);
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
Show All 17 Lines

clang-tools-extra/clang-tidy/readability/NonConstParameterCheck.h

Show All 12 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace readability { namespace readability {
/// Warn when a pointer function parameter can be const. /// Warn when a pointer function parameter can be const.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/readability-non-const-parameter.html /// https://clang.llvm.org/extra/clang-tidy/checks/readability-non-const-parameter.html
class NonConstParameterCheck : public ClangTidyCheck { class NonConstParameterCheck : public ClangTidyCheck {
public: public:
NonConstParameterCheck(StringRef Name, ClangTidyContext *Context) NonConstParameterCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
void onEndOfTranslationUnit() override; void onEndOfTranslationUnit() override;
llvm::Optional<TraversalKind> getCheckTraversalKind() const override { llvm::Optional<TraversalKind> getCheckTraversalKind() const override {
Show All 37 Lines

clang-tools-extra/clang-tidy/readability/QualifiedAutoCheck.h

Show All 14 Lines
namespace tidy { namespace tidy {
namespace readability { namespace readability {
/// Finds variables declared as auto that could be declared as: /// Finds variables declared as auto that could be declared as:
/// 'auto*' or 'const auto *' and reference variables declared as: /// 'auto*' or 'const auto *' and reference variables declared as:
/// 'const auto &'. /// 'const auto &'.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/readability-qualified-auto.html /// https://clang.llvm.org/extra/clang-tidy/checks/readability-qualified-auto.html
class QualifiedAutoCheck : public ClangTidyCheck { class QualifiedAutoCheck : public ClangTidyCheck {
public: public:
QualifiedAutoCheck(StringRef Name, ClangTidyContext *Context) QualifiedAutoCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context), : ClangTidyCheck(Name, Context),
AddConstToQualified(Options.get("AddConstToQualified", true)) {} AddConstToQualified(Options.get("AddConstToQualified", true)) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus11; return LangOpts.CPlusPlus11;
} }
Show All 13 Lines

clang-tools-extra/clang-tidy/readability/RedundantAccessSpecifiersCheck.h

Show All 12 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace readability { namespace readability {
/// Detects redundant access specifiers inside classes, structs, and unions. /// Detects redundant access specifiers inside classes, structs, and unions.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/readability-redundant-access-specifiers.html /// https://clang.llvm.org/extra/clang-tidy/checks/readability-redundant-access-specifiers.html
class RedundantAccessSpecifiersCheck : public ClangTidyCheck { class RedundantAccessSpecifiersCheck : public ClangTidyCheck {
public: public:
RedundantAccessSpecifiersCheck(StringRef Name, ClangTidyContext *Context) RedundantAccessSpecifiersCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context), : ClangTidyCheck(Name, Context),
CheckFirstDeclaration( CheckFirstDeclaration(
Options.getLocalOrGlobal("CheckFirstDeclaration", false)) {} Options.getLocalOrGlobal("CheckFirstDeclaration", false)) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
Show All 13 Lines

clang-tools-extra/clang-tidy/readability/RedundantControlFlowCheck.h

Show All 15 Lines
namespace readability { namespace readability {
/// Eliminates redundant `return` statements at the end of a function that /// Eliminates redundant `return` statements at the end of a function that
/// returns `void`. /// returns `void`.
/// ///
/// Eliminates redundant `continue` statements at the end of a loop body. /// Eliminates redundant `continue` statements at the end of a loop body.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/readability-redundant-control-flow.html /// https://clang.llvm.org/extra/clang-tidy/checks/readability-redundant-control-flow.html
class RedundantControlFlowCheck : public ClangTidyCheck { class RedundantControlFlowCheck : public ClangTidyCheck {
public: public:
RedundantControlFlowCheck(StringRef Name, ClangTidyContext *Context) RedundantControlFlowCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
llvm::Optional<TraversalKind> getCheckTraversalKind() const override { llvm::Optional<TraversalKind> getCheckTraversalKind() const override {
Show All 22 Lines

clang-tools-extra/clang-tidy/readability/RedundantDeclarationCheck.h

Show All 12 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace readability { namespace readability {
/// Find redundant variable declarations. /// Find redundant variable declarations.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/readability-redundant-declaration.html /// https://clang.llvm.org/extra/clang-tidy/checks/readability-redundant-declaration.html
class RedundantDeclarationCheck : public ClangTidyCheck { class RedundantDeclarationCheck : public ClangTidyCheck {
public: public:
RedundantDeclarationCheck(StringRef Name, ClangTidyContext *Context); RedundantDeclarationCheck(StringRef Name, ClangTidyContext *Context);
void storeOptions(ClangTidyOptions::OptionMap &Opts) override; void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
private: private:
const bool IgnoreMacros; const bool IgnoreMacros;
}; };
} // namespace readability } // namespace readability
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_REDUNDANT_DECLARATION_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_REDUNDANT_DECLARATION_H

clang-tools-extra/clang-tidy/readability/RedundantFunctionPtrDereferenceCheck.h

Show All 12 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace readability { namespace readability {
/// Eliminate redundant dereferences of a function pointer. /// Eliminate redundant dereferences of a function pointer.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/readability-redundant-function-ptr-dereference.html /// https://clang.llvm.org/extra/clang-tidy/checks/readability-redundant-function-ptr-dereference.html
class RedundantFunctionPtrDereferenceCheck : public ClangTidyCheck { class RedundantFunctionPtrDereferenceCheck : public ClangTidyCheck {
public: public:
RedundantFunctionPtrDereferenceCheck(StringRef Name, ClangTidyContext *Context) RedundantFunctionPtrDereferenceCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace readability } // namespace readability
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_REDUNDANT_FUNCTION_PTR_DEREFERENCE_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_REDUNDANT_FUNCTION_PTR_DEREFERENCE_H

clang-tools-extra/clang-tidy/readability/RedundantMemberInitCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace readability { namespace readability {
/// Finds member initializations that are unnecessary because the same default /// Finds member initializations that are unnecessary because the same default
/// constructor would be called if they were not present. /// constructor would be called if they were not present.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/readability-redundant-member-init.html /// https://clang.llvm.org/extra/clang-tidy/checks/readability-redundant-member-init.html
class RedundantMemberInitCheck : public ClangTidyCheck { class RedundantMemberInitCheck : public ClangTidyCheck {
public: public:
RedundantMemberInitCheck(StringRef Name, ClangTidyContext *Context) RedundantMemberInitCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context), : ClangTidyCheck(Name, Context),
IgnoreBaseInCopyConstructors( IgnoreBaseInCopyConstructors(
Options.get("IgnoreBaseInCopyConstructors", false)) {} Options.get("IgnoreBaseInCopyConstructors", false)) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
Show All 17 Lines

clang-tools-extra/clang-tidy/readability/RedundantPreprocessorCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace readability { namespace readability {
/// This check flags redundant preprocessor directives: nested directives with /// This check flags redundant preprocessor directives: nested directives with
/// the same condition. /// the same condition.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/readability-redundant-preprocessor.html /// https://clang.llvm.org/extra/clang-tidy/checks/readability-redundant-preprocessor.html
class RedundantPreprocessorCheck : public ClangTidyCheck { class RedundantPreprocessorCheck : public ClangTidyCheck {
public: public:
RedundantPreprocessorCheck(StringRef Name, ClangTidyContext *Context) RedundantPreprocessorCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP, void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
Preprocessor *ModuleExpanderPP) override; Preprocessor *ModuleExpanderPP) override;
}; };
} // namespace readability } // namespace readability
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_REDUNDANTPREPROCESSORCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_REDUNDANTPREPROCESSORCHECK_H

clang-tools-extra/clang-tidy/readability/SimplifyBooleanExprCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace readability { namespace readability {
/// Looks for boolean expressions involving boolean constants and simplifies /// Looks for boolean expressions involving boolean constants and simplifies
/// them to use the appropriate boolean expression directly. /// them to use the appropriate boolean expression directly.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/readability-simplify-boolean-expr.html /// https://clang.llvm.org/extra/clang-tidy/checks/readability-simplify-boolean-expr.html
class SimplifyBooleanExprCheck : public ClangTidyCheck { class SimplifyBooleanExprCheck : public ClangTidyCheck {
public: public:
SimplifyBooleanExprCheck(StringRef Name, ClangTidyContext *Context); SimplifyBooleanExprCheck(StringRef Name, ClangTidyContext *Context);
void storeOptions(ClangTidyOptions::OptionMap &Options) override; void storeOptions(ClangTidyOptions::OptionMap &Options) override;
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
llvm::Optional<TraversalKind> getCheckTraversalKind() const override { llvm::Optional<TraversalKind> getCheckTraversalKind() const override {
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/readability/SimplifySubscriptExprCheck.h

Show All 12 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace readability { namespace readability {
/// Simplifies subscript expressions. /// Simplifies subscript expressions.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/readability-simplify-subscript-expr.html /// https://clang.llvm.org/extra/clang-tidy/checks/readability-simplify-subscript-expr.html
class SimplifySubscriptExprCheck : public ClangTidyCheck { class SimplifySubscriptExprCheck : public ClangTidyCheck {
public: public:
SimplifySubscriptExprCheck(StringRef Name, ClangTidyContext *Context); SimplifySubscriptExprCheck(StringRef Name, ClangTidyContext *Context);
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
Show All 14 Lines

clang-tools-extra/clang-tidy/readability/StaticAccessedThroughInstanceCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace readability { namespace readability {
/// Checks for member expressions that access static members through /// Checks for member expressions that access static members through
/// instances and replaces them with uses of the appropriate qualified-id. /// instances and replaces them with uses of the appropriate qualified-id.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/readability-static-accessed-through-instance.html /// https://clang.llvm.org/extra/clang-tidy/checks/readability-static-accessed-through-instance.html
class StaticAccessedThroughInstanceCheck : public ClangTidyCheck { class StaticAccessedThroughInstanceCheck : public ClangTidyCheck {
public: public:
StaticAccessedThroughInstanceCheck(StringRef Name, ClangTidyContext *Context) StaticAccessedThroughInstanceCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context), : ClangTidyCheck(Name, Context),
NameSpecifierNestingThreshold( NameSpecifierNestingThreshold(
Options.get("NameSpecifierNestingThreshold", 3U)) {} Options.get("NameSpecifierNestingThreshold", 3U)) {}
void storeOptions(ClangTidyOptions::OptionMap &Opts) override; void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
Show All 15 Lines

clang-tools-extra/clang-tidy/readability/StaticDefinitionInAnonymousNamespaceCheck.h

Show All 12 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace readability { namespace readability {
/// Finds static function and variable definitions in anonymous namespace. /// Finds static function and variable definitions in anonymous namespace.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/readability-static-definition-in-anonymous-namespace.html /// https://clang.llvm.org/extra/clang-tidy/checks/readability-static-definition-in-anonymous-namespace.html
class StaticDefinitionInAnonymousNamespaceCheck : public ClangTidyCheck { class StaticDefinitionInAnonymousNamespaceCheck : public ClangTidyCheck {
public: public:
StaticDefinitionInAnonymousNamespaceCheck(StringRef Name, StaticDefinitionInAnonymousNamespaceCheck(StringRef Name,
ClangTidyContext *Context) ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace readability } // namespace readability
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_STATIC_DEFINITION_IN_ANONYMOUS_NAMESPACE_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_STATIC_DEFINITION_IN_ANONYMOUS_NAMESPACE_H

clang-tools-extra/clang-tidy/readability/StringCompareCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace readability { namespace readability {
/// This check flags all calls compare when used to check for string /// This check flags all calls compare when used to check for string
/// equality or inequality. /// equality or inequality.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/readability-string-compare.html /// https://clang.llvm.org/extra/clang-tidy/checks/readability-string-compare.html
class StringCompareCheck : public ClangTidyCheck { class StringCompareCheck : public ClangTidyCheck {
public: public:
StringCompareCheck(StringRef Name, ClangTidyContext *Context) StringCompareCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace readability } // namespace readability
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_STRINGCOMPARECHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_STRINGCOMPARECHECK_H

clang-tools-extra/clang-tidy/readability/SuspiciousCallArgumentCheck.h

Show All 15 Lines
namespace tidy { namespace tidy {
namespace readability { namespace readability {
/// Finds function calls where the arguments passed are provided out of order, /// Finds function calls where the arguments passed are provided out of order,
/// based on the difference between the argument name and the parameter names /// based on the difference between the argument name and the parameter names
/// of the function. /// of the function.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/readability-suspicious-call-argument.html /// https://clang.llvm.org/extra/clang-tidy/checks/readability-suspicious-call-argument.html
class SuspiciousCallArgumentCheck : public ClangTidyCheck { class SuspiciousCallArgumentCheck : public ClangTidyCheck {
enum class Heuristic { enum class Heuristic {
Equality, Equality,
Abbreviation, Abbreviation,
Prefix, Prefix,
Suffix, Suffix,
Substring, Substring,
Levenshtein, Levenshtein,
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/readability/UniqueptrDeleteReleaseCheck.h

Show All 13 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace readability { namespace readability {
/// Flags statements of the form ``delete <unique_ptr expr>.release();`` and /// Flags statements of the form ``delete <unique_ptr expr>.release();`` and
/// replaces them with: ``<unique_ptr expr> = nullptr;`` /// replaces them with: ``<unique_ptr expr> = nullptr;``
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/readability-uniqueptr-delete-release.html /// https://clang.llvm.org/extra/clang-tidy/checks/readability-uniqueptr-delete-release.html
class UniqueptrDeleteReleaseCheck : public ClangTidyCheck { class UniqueptrDeleteReleaseCheck : public ClangTidyCheck {
public: public:
UniqueptrDeleteReleaseCheck(StringRef Name, ClangTidyContext *Context); UniqueptrDeleteReleaseCheck(StringRef Name, ClangTidyContext *Context);
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
void storeOptions(ClangTidyOptions::OptionMap &Opts) override; void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
llvm::Optional<TraversalKind> getCheckTraversalKind() const override { llvm::Optional<TraversalKind> getCheckTraversalKind() const override {
return TK_IgnoreUnlessSpelledInSource; return TK_IgnoreUnlessSpelledInSource;
Show All 11 Lines

clang-tools-extra/clang-tidy/readability/UppercaseLiteralSuffixCheck.h

Show All 15 Lines
namespace tidy { namespace tidy {
namespace readability { namespace readability {
/// Detects when the integral literal or floating point literal has /// Detects when the integral literal or floating point literal has
/// non-uppercase suffix, and suggests to make the suffix uppercase. /// non-uppercase suffix, and suggests to make the suffix uppercase.
/// Alternatively, a list of destination suffixes can be provided. /// Alternatively, a list of destination suffixes can be provided.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/readability-uppercase-literal-suffix.html /// https://clang.llvm.org/extra/clang-tidy/checks/readability-uppercase-literal-suffix.html
class UppercaseLiteralSuffixCheck : public ClangTidyCheck { class UppercaseLiteralSuffixCheck : public ClangTidyCheck {
public: public:
UppercaseLiteralSuffixCheck(StringRef Name, ClangTidyContext *Context); UppercaseLiteralSuffixCheck(StringRef Name, ClangTidyContext *Context);
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
void storeOptions(ClangTidyOptions::OptionMap &Opts) override; void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
llvm::Optional<TraversalKind> getCheckTraversalKind() const override { llvm::Optional<TraversalKind> getCheckTraversalKind() const override {
return TK_IgnoreUnlessSpelledInSource; return TK_IgnoreUnlessSpelledInSource;
Show All 15 Lines

clang-tools-extra/clang-tidy/readability/UseAnyOfAllOfCheck.h

Show All 14 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace readability { namespace readability {
/// Finds ranged-based for loops that can be replaced by a call to std::any_of /// Finds ranged-based for loops that can be replaced by a call to std::any_of
/// or std::all_of. /// or std::all_of.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/readability-use-anyofallof.html /// https://clang.llvm.org/extra/clang-tidy/checks/readability-use-anyofallof.html
class UseAnyOfAllOfCheck : public ClangTidyCheck { class UseAnyOfAllOfCheck : public ClangTidyCheck {
public: public:
using ClangTidyCheck::ClangTidyCheck; using ClangTidyCheck::ClangTidyCheck;
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override { bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus11; return LangOpts.CPlusPlus11;
} }
Show All 9 Lines

clang-tools-extra/clang-tidy/tool/ClangTidyMain.h

//===--- tools/extra/clang-tidy/ClangTidyMain.h - Clang tidy tool -------===// //===--- tools/extra/clang-tidy/ClangTidyMain.h - Clang tidy tool -------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// ///
/// \file This file declares the main function for the clang-tidy tool. /// \file This file declares the main function for the clang-tidy tool.
/// ///
/// This tool uses the Clang Tooling infrastructure, see /// This tool uses the Clang Tooling infrastructure, see
/// http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html /// https://clang.llvm.org/docs/HowToSetupToolingForLLVM.html
/// for details on setting it up with LLVM source tree. /// for details on setting it up with LLVM source tree.
/// ///
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
namespace clang { namespace clang {
namespace tidy { namespace tidy {
int clangTidyMain(int argc, const char **argv); int clangTidyMain(int argc, const char **argv);
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tools-extra/clang-tidy/tool/ClangTidyMain.cpp

//===--- tools/extra/clang-tidy/ClangTidyMain.cpp - Clang tidy tool -------===// //===--- tools/extra/clang-tidy/ClangTidyMain.cpp - Clang tidy tool -------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// ///
/// \file This file implements a clang-tidy tool. /// \file This file implements a clang-tidy tool.
/// ///
/// This tool uses the Clang Tooling infrastructure, see /// This tool uses the Clang Tooling infrastructure, see
/// http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html /// https://clang.llvm.org/docs/HowToSetupToolingForLLVM.html
/// for details on setting it up with LLVM source tree. /// for details on setting it up with LLVM source tree.
/// ///
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "ClangTidyMain.h" #include "ClangTidyMain.h"
#include "../ClangTidy.h" #include "../ClangTidy.h"
#include "../ClangTidyForceLinker.h" #include "../ClangTidyForceLinker.h"
#include "../GlobList.h" #include "../GlobList.h"
▲ Show 20 Lines • Show All 542 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/tool/ClangTidyToolMain.cpp

//===--- tools/extra/clang-tidy/ClangTidyToolMain.cpp - Clang tidy tool ---===// //===--- tools/extra/clang-tidy/ClangTidyToolMain.cpp - Clang tidy tool ---===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// ///
/// \file This file contains clang-tidy tool entry point main function. /// \file This file contains clang-tidy tool entry point main function.
/// ///
/// This tool uses the Clang Tooling infrastructure, see /// This tool uses the Clang Tooling infrastructure, see
/// http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html /// https://clang.llvm.org/docs/HowToSetupToolingForLLVM.html
/// for details on setting it up with LLVM source tree. /// for details on setting it up with LLVM source tree.
/// ///
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "ClangTidyMain.h" #include "ClangTidyMain.h"
int main(int argc, const char **argv) { int main(int argc, const char **argv) {
return clang::tidy::clangTidyMain(argc, argv); return clang::tidy::clangTidyMain(argc, argv);
} }

clang-tools-extra/clang-tidy/tool/run-clang-tidy.py

Show All 25 Lines- Fix all header guards.
run-clang-tidy.py -fix -checks=-*,llvm-header-guard run-clang-tidy.py -fix -checks=-*,llvm-header-guard
- Fix all header guards included from clang-tidy and header guards - Fix all header guards included from clang-tidy and header guards
for clang-tidy headers. for clang-tidy headers.
run-clang-tidy.py -fix -checks=-*,llvm-header-guard extra/clang-tidy \ run-clang-tidy.py -fix -checks=-*,llvm-header-guard extra/clang-tidy \
-header-filter=extra/clang-tidy -header-filter=extra/clang-tidy
Compilation database setup: Compilation database setup:
http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html https://clang.llvm.org/docs/HowToSetupToolingForLLVM.html
""" """
from __future__ import print_function from __future__ import print_function
import argparse import argparse
import glob import glob
import json import json
import multiprocessing import multiprocessing
▲ Show 20 Lines • Show All 356 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/zircon/TemporaryObjectsCheck.h

Show All 14 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace zircon { namespace zircon {
/// Construction of specific temporary objects in the Zircon kernel is /// Construction of specific temporary objects in the Zircon kernel is
/// discouraged. /// discouraged.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/zircon-temporary-objects.html /// https://clang.llvm.org/extra/clang-tidy/checks/zircon-temporary-objects.html
class TemporaryObjectsCheck : public ClangTidyCheck { class TemporaryObjectsCheck : public ClangTidyCheck {
public: public:
TemporaryObjectsCheck(StringRef Name, ClangTidyContext *Context) TemporaryObjectsCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context), : ClangTidyCheck(Name, Context),
Names(utils::options::parseStringList(Options.get("Names", ""))) {} Names(utils::options::parseStringList(Options.get("Names", ""))) {}
void storeOptions(ClangTidyOptions::OptionMap &Opts) override; void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
Show All 10 Lines

clang-tools-extra/docs/clang-tidy/Integrations.rst

================================== ==================================
Clang-tidy IDE/Editor Integrations Clang-tidy IDE/Editor Integrations
================================== ==================================
.. _clangd: http://clangd.llvm.org/ .. _clangd: https://clangd.llvm.org/
.. _is available: https://clangd.llvm.org/installation.html#editor-plugins .. _is available: https://clangd.llvm.org/installation.html#editor-plugins
.. _more: https://langserver.org/#implementations-client .. _more: https://langserver.org/#implementations-client
Apart from being a standalone tool, :program:`clang-tidy` is integrated into Apart from being a standalone tool, :program:`clang-tidy` is integrated into
various IDEs, code analyzers, and editors. We recommend using clangd_ which various IDEs, code analyzers, and editors. We recommend using clangd_ which
integrates :program:`clang-tidy` and `is available`_ in most major editors integrates :program:`clang-tidy` and `is available`_ in most major editors
through plugins (Vim, Emacs, Visual Studio Code, Sublime Text and more_). through plugins (Vim, Emacs, Visual Studio Code, Sublime Text and more_).
▲ Show 20 Lines • Show All 111 Lines • Show Last 20 Lines

clang/README.txt

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// C Language Family Front-end // C Language Family Front-end
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
Welcome to Clang. This is a compiler front-end for the C family of languages Welcome to Clang. This is a compiler front-end for the C family of languages
(C, C++, Objective-C, and Objective-C++) which is built as part of the LLVM (C, C++, Objective-C, and Objective-C++) which is built as part of the LLVM
compiler infrastructure project. compiler infrastructure project.
Unlike many other compiler frontends, Clang is useful for a number of things Unlike many other compiler frontends, Clang is useful for a number of things
beyond just compiling code: we intend for Clang to be host to a number of beyond just compiling code: we intend for Clang to be host to a number of
different source-level tools. One example of this is the Clang Static Analyzer. different source-level tools. One example of this is the Clang Static Analyzer.
If you're interested in more (including how to build Clang) it is best to read If you're interested in more (including how to build Clang) it is best to read
the relevant web sites. Here are some pointers: the relevant web sites. Here are some pointers:
Information on Clang: http://clang.llvm.org/ Information on Clang: https://clang.llvm.org/
Building and using Clang: http://clang.llvm.org/get_started.html Building and using Clang: https://clang.llvm.org/get_started.html
Clang Static Analyzer: http://clang-analyzer.llvm.org/ Clang Static Analyzer: https://clang-analyzer.llvm.org/
Information on the LLVM project: http://llvm.org/ Information on the LLVM project: https://llvm.org/
If you have questions or comments about Clang, a great place to discuss them is If you have questions or comments about Clang, a great place to discuss them is
on the Clang forums: on the Clang forums:
https://discourse.llvm.org/c/clang/ https://discourse.llvm.org/c/clang/
If you find a bug in Clang, please file it in the LLVM bug tracker: If you find a bug in Clang, please file it in the LLVM bug tracker:
http://llvm.org/bugs/ https://llvm.org/bugs/

clang/docs/LanguageExtensions.rst

Show First 20 Lines • Show All 4,052 Lines • ▼ Show 20 Lines
The pragma can also be used with ``off`` which turns FP contraction off for a The pragma can also be used with ``off`` which turns FP contraction off for a
section of the code. This can be useful when fast contraction is otherwise section of the code. This can be useful when fast contraction is otherwise
enabled for the translation unit with the ``-ffp-contract=fast-honor-pragmas`` flag. enabled for the translation unit with the ``-ffp-contract=fast-honor-pragmas`` flag.
Note that ``-ffp-contract=fast`` will override pragmas to fuse multiply and Note that ``-ffp-contract=fast`` will override pragmas to fuse multiply and
addition across statements regardless of any controlling pragmas. addition across statements regardless of any controlling pragmas.
``#pragma clang fp exceptions`` specifies floating point exception behavior. It ``#pragma clang fp exceptions`` specifies floating point exception behavior. It
may take one of the values: ``ignore``, ``maytrap`` or ``strict``. Meaning of may take one of the values: ``ignore``, ``maytrap`` or ``strict``. Meaning of
these values is same as for `constrained floating point intrinsics <http://llvm.org/docs/LangRef.html#constrained-floating-point-intrinsics>`_. these values is same as for `constrained floating point intrinsics <https://llvm.org/docs/LangRef.html#constrained-floating-point-intrinsics>`_.
.. code-block:: c++ .. code-block:: c++
{ {
// Preserve floating point exceptions // Preserve floating point exceptions
#pragma clang fp exceptions(strict) #pragma clang fp exceptions(strict)
z = x + y; z = x + y;
if (fetestexcept(FE_OVERFLOW)) if (fetestexcept(FE_OVERFLOW))
▲ Show 20 Lines • Show All 600 Lines • Show Last 20 Lines

clang/docs/ThinLTO.rst

Show All 25 Lines
later when the modules are optimized in fully parallel backends. later when the modules are optimized in fully parallel backends.
By default, linkers_ that support ThinLTO are set up to launch By default, linkers_ that support ThinLTO are set up to launch
the ThinLTO backends in threads. So the usage model is not affected the ThinLTO backends in threads. So the usage model is not affected
as the distinction between the fast serial thin link step and the backends as the distinction between the fast serial thin link step and the backends
is transparent to the user. is transparent to the user.
For more information on the ThinLTO design and current performance, For more information on the ThinLTO design and current performance,
see the LLVM blog post `ThinLTO: Scalable and Incremental LTO see the LLVM blog post `ThinLTO: Scalable and Incremental LTO
<http://blog.llvm.org/2016/06/thinlto-scalable-and-incremental-lto.html>`_. <https://blog.llvm.org/2016/06/thinlto-scalable-and-incremental-lto.html>`_.
While tuning is still in progress, results in the blog post show that While tuning is still in progress, results in the blog post show that
ThinLTO already performs well compared to LTO, in many cases matching ThinLTO already performs well compared to LTO, in many cases matching
the performance improvement. the performance improvement.
Current Status Current Status
============== ==============
Clang/LLVM Clang/LLVM
▲ Show 20 Lines • Show All 196 Lines • ▼ Show 20 Lines
stage 3 in case the compiler used for stage 1 does not support the ThinLTO stage 3 in case the compiler used for stage 1 does not support the ThinLTO
option. option.
More Information More Information
================ ================
* From LLVM project blog: * From LLVM project blog:
`ThinLTO: Scalable and Incremental LTO `ThinLTO: Scalable and Incremental LTO
<http://blog.llvm.org/2016/06/thinlto-scalable-and-incremental-lto.html>`_ <https://blog.llvm.org/2016/06/thinlto-scalable-and-incremental-lto.html>`_

clang/docs/UndefinedBehaviorSanitizer.rst

Show First 20 Lines • Show All 359 Lines • ▼ Show 20 Lines
More Information More Information
================ ================
* From Oracle blog, including a discussion of error messages: * From Oracle blog, including a discussion of error messages:
`Improving Application Security with UndefinedBehaviorSanitizer (UBSan) and GCC `Improving Application Security with UndefinedBehaviorSanitizer (UBSan) and GCC
<https://blogs.oracle.com/linux/improving-application-security-with-undefinedbehaviorsanitizer-ubsan-and-gcc>`_ <https://blogs.oracle.com/linux/improving-application-security-with-undefinedbehaviorsanitizer-ubsan-and-gcc>`_
* From LLVM project blog: * From LLVM project blog:
`What Every C Programmer Should Know About Undefined Behavior `What Every C Programmer Should Know About Undefined Behavior
<http://blog.llvm.org/2011/05/what-every-c-programmer-should-know.html>`_ <https://blog.llvm.org/2011/05/what-every-c-programmer-should-know.html>`_
* From John Regehr's *Embedded in Academia* blog: * From John Regehr's *Embedded in Academia* blog:
`A Guide to Undefined Behavior in C and C++ `A Guide to Undefined Behavior in C and C++
<https://blog.regehr.org/archives/213>`_ <https://blog.regehr.org/archives/213>`_

clang/docs/analyzer/checkers.rst

Show First 20 Lines • Show All 2,391 Lines • ▼ Show 20 Lines
Default propagations defined by ``GenericTaintChecker``: Default propagations defined by ``GenericTaintChecker``:
``atoi``, ``atol``, ``atoll``, ``basename``, ``dirname``, ``fgetc``, ``fgetln``, ``fgets``, ``fnmatch``, ``fread``, ``fscanf``, ``fscanf_s``, ``index``, ``inflate``, ``isalnum``, ``isalpha``, ``isascii``, ``isblank``, ``iscntrl``, ``isdigit``, ``isgraph``, ``islower``, ``isprint``, ``ispunct``, ``isspace``, ``isupper``, ``isxdigit``, ``memchr``, ``memrchr``, ``sscanf``, ``getc``, ``getc_unlocked``, ``getdelim``, ``getline``, ``getw``, ``memcmp``, ``memcpy``, ``memmem``, ``memmove``, ``mbtowc``, ``pread``, ``qsort``, ``qsort_r``, ``rawmemchr``, ``read``, ``recv``, ``recvfrom``, ``rindex``, ``strcasestr``, ``strchr``, ``strchrnul``, ``strcasecmp``, ``strcmp``, ``strcspn``, ``strlen``, ``strncasecmp``, ``strncmp``, ``strndup``, ``strndupa``, ``strnlen``, ``strpbrk``, ``strrchr``, ``strsep``, ``strspn``, ``strstr``, ``strtol``, ``strtoll``, ``strtoul``, ``strtoull``, ``tolower``, ``toupper``, ``ttyname``, ``ttyname_r``, ``wctomb``, ``wcwidth`` ``atoi``, ``atol``, ``atoll``, ``basename``, ``dirname``, ``fgetc``, ``fgetln``, ``fgets``, ``fnmatch``, ``fread``, ``fscanf``, ``fscanf_s``, ``index``, ``inflate``, ``isalnum``, ``isalpha``, ``isascii``, ``isblank``, ``iscntrl``, ``isdigit``, ``isgraph``, ``islower``, ``isprint``, ``ispunct``, ``isspace``, ``isupper``, ``isxdigit``, ``memchr``, ``memrchr``, ``sscanf``, ``getc``, ``getc_unlocked``, ``getdelim``, ``getline``, ``getw``, ``memcmp``, ``memcpy``, ``memmem``, ``memmove``, ``mbtowc``, ``pread``, ``qsort``, ``qsort_r``, ``rawmemchr``, ``read``, ``recv``, ``recvfrom``, ``rindex``, ``strcasestr``, ``strchr``, ``strchrnul``, ``strcasecmp``, ``strcmp``, ``strcspn``, ``strlen``, ``strncasecmp``, ``strncmp``, ``strndup``, ``strndupa``, ``strnlen``, ``strpbrk``, ``strrchr``, ``strsep``, ``strspn``, ``strstr``, ``strtol``, ``strtoll``, ``strtoul``, ``strtoull``, ``tolower``, ``toupper``, ``ttyname``, ``ttyname_r``, ``wctomb``, ``wcwidth``
Default sinks defined in ``GenericTaintChecker``: Default sinks defined in ``GenericTaintChecker``:
``printf``, ``setproctitle``, ``system``, ``popen``, ``execl``, ``execle``, ``execlp``, ``execv``, ``execvp``, ``execvP``, ``execve``, ``dlopen``, ``memcpy``, ``memmove``, ``strncpy``, ``strndup``, ``malloc``, ``calloc``, ``alloca``, ``memccpy``, ``realloc``, ``bcopy`` ``printf``, ``setproctitle``, ``system``, ``popen``, ``execl``, ``execle``, ``execlp``, ``execv``, ``execvp``, ``execvP``, ``execve``, ``dlopen``, ``memcpy``, ``memmove``, ``strncpy``, ``strndup``, ``malloc``, ``calloc``, ``alloca``, ``memccpy``, ``realloc``, ``bcopy``
The user can configure taint sources, sinks, and propagation rules by providing a configuration file via checker option ``alpha.security.taint.TaintPropagation:Config``. The user can configure taint sources, sinks, and propagation rules by providing a configuration file via checker option ``alpha.security.taint.TaintPropagation:Config``.
External taint configuration is in `YAML <http://llvm.org/docs/YamlIO.html#introduction-to-yaml>`_ format. The taint-related options defined in the config file extend but do not override the built-in sources, rules, sinks. External taint configuration is in `YAML <https://llvm.org/docs/YamlIO.html#introduction-to-yaml>`_ format. The taint-related options defined in the config file extend but do not override the built-in sources, rules, sinks.
The format of the external taint configuration file is not stable, and could change without any notice even in a non-backward compatible way. The format of the external taint configuration file is not stable, and could change without any notice even in a non-backward compatible way.
For a more detailed description of configuration options, please see the :doc:`user-docs/TaintAnalysisConfiguration`. For an example see :ref:`clangsa-taint-configuration-example`. For a more detailed description of configuration options, please see the :doc:`user-docs/TaintAnalysisConfiguration`. For an example see :ref:`clangsa-taint-configuration-example`.
alpha.unix alpha.unix
^^^^^^^^^^^ ^^^^^^^^^^^
.. _alpha-unix-StdCLibraryFunctionArgs: .. _alpha-unix-StdCLibraryFunctionArgs:
▲ Show 20 Lines • Show All 549 Lines • ▼ Show 20 Lines
""""""""""""""""""" """""""""""""""""""
View Call Graph using GraphViz. View Call Graph using GraphViz.
.. _debug-ViewExplodedGraph: .. _debug-ViewExplodedGraph:
debug.ViewExplodedGraph debug.ViewExplodedGraph
""""""""""""""""""""""" """""""""""""""""""""""
View Exploded Graphs using GraphViz. View Exploded Graphs using GraphViz.

clang/docs/analyzer/user-docs/TaintAnalysisConfiguration.rst

============================ ============================
Taint Analysis Configuration Taint Analysis Configuration
============================ ============================
The Clang Static Analyzer uses taint analysis to detect security-related issues in code. The Clang Static Analyzer uses taint analysis to detect security-related issues in code.
The backbone of taint analysis in the Clang SA is the `GenericTaintChecker`, which the user can access via the :ref:`alpha-security-taint-TaintPropagation` checker alias and this checker has a default taint-related configuration. The backbone of taint analysis in the Clang SA is the `GenericTaintChecker`, which the user can access via the :ref:`alpha-security-taint-TaintPropagation` checker alias and this checker has a default taint-related configuration.
The built-in default settings are defined in code, and they are always in effect once the checker is enabled, either directly or via the alias. The built-in default settings are defined in code, and they are always in effect once the checker is enabled, either directly or via the alias.
The checker also provides a configuration interface for extending the default settings by providing a configuration file in `YAML <http://llvm.org/docs/YamlIO.html#introduction-to-yaml>`_ format. The checker also provides a configuration interface for extending the default settings by providing a configuration file in `YAML <https://llvm.org/docs/YamlIO.html#introduction-to-yaml>`_ format.
This documentation describes the syntax of the configuration file and gives the informal semantics of the configuration options. This documentation describes the syntax of the configuration file and gives the informal semantics of the configuration options.
.. contents:: .. contents::
:local: :local:
.. _clangsa-taint-configuration-overview: .. _clangsa-taint-configuration-overview:
Overview Overview
▲ Show 20 Lines • Show All 75 Lines • ▼ Show 20 Lines
In the example file above, the entries under the `Propagation` key implement the conceptual sources and propagations, and sinks have their dedicated `Sinks` key. In the example file above, the entries under the `Propagation` key implement the conceptual sources and propagations, and sinks have their dedicated `Sinks` key.
The user can define operations (function calls) where the tainted values should be cleansed by listing entries under the `Filters` key. The user can define operations (function calls) where the tainted values should be cleansed by listing entries under the `Filters` key.
Filters model the sanitization of values done by the programmer, and providing these is key to avoiding false-positive findings. Filters model the sanitization of values done by the programmer, and providing these is key to avoiding false-positive findings.
Configuration file syntax and semantics Configuration file syntax and semantics
_______________________________________ _______________________________________
The configuration file should have valid `YAML <http://llvm.org/docs/YamlIO.html#introduction-to-yaml>`_ syntax. The configuration file should have valid `YAML <https://llvm.org/docs/YamlIO.html#introduction-to-yaml>`_ syntax.
The configuration file can have the following top-level keys: The configuration file can have the following top-level keys:
- Filters - Filters
- Propagations - Propagations
- Sinks - Sinks
Under the `Filters` key, the user can specify a list of operations that remove taint (see :ref:`clangsa-taint-filter-details` for details). Under the `Filters` key, the user can specify a list of operations that remove taint (see :ref:`clangsa-taint-filter-details` for details).
Under the `Propagations` key, the user can specify a list of operations that introduce and propagate taint (see :ref:`clangsa-taint-propagation-details` for details). Under the `Propagations` key, the user can specify a list of operations that introduce and propagate taint (see :ref:`clangsa-taint-propagation-details` for details).
The user can mark taint sources with a `SrcArgs` key in the `Propagation` key, while propagations have none. The user can mark taint sources with a `SrcArgs` key in the `Propagation` key, while propagations have none.
The lack of the `SrcArgs` key means unconditional propagation, which is how sources are modeled. The lack of the `SrcArgs` key means unconditional propagation, which is how sources are modeled.
The semantics of propagations are such, that if any of the source arguments are tainted (specified by indexes in `SrcArgs`) then all of the destination arguments (specified by indexes in `DstArgs`) also become tainted. The semantics of propagations are such, that if any of the source arguments are tainted (specified by indexes in `SrcArgs`) then all of the destination arguments (specified by indexes in `DstArgs`) also become tainted.
Under the `Sinks` key, the user can specify a list of operations where the checker should emit a bug report if tainted data reaches it (see :ref:`clangsa-taint-sink-details` for details). Under the `Sinks` key, the user can specify a list of operations where the checker should emit a bug report if tainted data reaches it (see :ref:`clangsa-taint-sink-details` for details).
.. _clangsa-taint-filter-details: .. _clangsa-taint-filter-details:
Filter syntax and semantics Filter syntax and semantics
########################### ###########################
An entry under `Filters` is a `YAML <http://llvm.org/docs/YamlIO.html#introduction-to-yaml>`_ object with the following mandatory keys: An entry under `Filters` is a `YAML <https://llvm.org/docs/YamlIO.html#introduction-to-yaml>`_ object with the following mandatory keys:
- `Name` is a string that specifies the name of a function. - `Name` is a string that specifies the name of a function.
Encountering this function during symbolic execution the checker will sanitize taint from the memory region referred to by the given arguments or return a sanitized value. Encountering this function during symbolic execution the checker will sanitize taint from the memory region referred to by the given arguments or return a sanitized value.
- `Args` is a list of numbers in the range of ``[-1..int_max]``. - `Args` is a list of numbers in the range of ``[-1..int_max]``.
It indicates the indexes of arguments in the function call. It indicates the indexes of arguments in the function call.
The number ``-1`` signifies the return value; other numbers identify call arguments. The number ``-1`` signifies the return value; other numbers identify call arguments.
The values of these arguments are considered clean after the function call. The values of these arguments are considered clean after the function call.
The following keys are optional: The following keys are optional:
- `Scope` is a string that specifies the prefix of the function's name in its fully qualified name. This option restricts the set of matching function calls. It can encode not only namespaces but struct/class names as well to match member functions. - `Scope` is a string that specifies the prefix of the function's name in its fully qualified name. This option restricts the set of matching function calls. It can encode not only namespaces but struct/class names as well to match member functions.
.. _clangsa-taint-propagation-details: .. _clangsa-taint-propagation-details:
Propagation syntax and semantics Propagation syntax and semantics
################################ ################################
An entry under `Propagation` is a `YAML <http://llvm.org/docs/YamlIO.html#introduction-to-yaml>`_ object with the following mandatory keys: An entry under `Propagation` is a `YAML <https://llvm.org/docs/YamlIO.html#introduction-to-yaml>`_ object with the following mandatory keys:
- `Name` is a string that specifies the name of a function. - `Name` is a string that specifies the name of a function.
Encountering this function during symbolic execution propagate taint from one or more arguments to other arguments and possibly the return value. Encountering this function during symbolic execution propagate taint from one or more arguments to other arguments and possibly the return value.
It helps model the taint-related behavior of functions that are not analyzable otherwise. It helps model the taint-related behavior of functions that are not analyzable otherwise.
The following keys are optional: The following keys are optional:
- `Scope` is a string that specifies the prefix of the function's name in its fully qualified name. This option restricts the set of matching function calls. - `Scope` is a string that specifies the prefix of the function's name in its fully qualified name. This option restricts the set of matching function calls.
- `SrcArgs` is a list of numbers in the range of ``[0..int_max]`` that indicates the indexes of arguments in the function call. - `SrcArgs` is a list of numbers in the range of ``[0..int_max]`` that indicates the indexes of arguments in the function call.
Taint-propagation considers the values of these arguments during the evaluation of the function call. Taint-propagation considers the values of these arguments during the evaluation of the function call.
Show All 9 Lines
- `VariadicIndex` is a number in the range of ``[0..int_max]``. It indicates the starting index of the variadic argument in the signature of the function. - `VariadicIndex` is a number in the range of ``[0..int_max]``. It indicates the starting index of the variadic argument in the signature of the function.
.. _clangsa-taint-sink-details: .. _clangsa-taint-sink-details:
Sink syntax and semantics Sink syntax and semantics
######################### #########################
An entry under `Sinks` is a `YAML <http://llvm.org/docs/YamlIO.html#introduction-to-yaml>`_ object with the following mandatory keys: An entry under `Sinks` is a `YAML <https://llvm.org/docs/YamlIO.html#introduction-to-yaml>`_ object with the following mandatory keys:
- `Name` is a string that specifies the name of a function. - `Name` is a string that specifies the name of a function.
Encountering this function during symbolic execution will emit a taint-related diagnostic if any of the arguments specified with `Args` are tainted at the call site. Encountering this function during symbolic execution will emit a taint-related diagnostic if any of the arguments specified with `Args` are tainted at the call site.
- `Args` is a list of numbers in the range of ``[0..int_max]`` that indicates the indexes of arguments in the function call. - `Args` is a list of numbers in the range of ``[0..int_max]`` that indicates the indexes of arguments in the function call.
The checker reports an error if any of the specified arguments are tainted. The checker reports an error if any of the specified arguments are tainted.
The following keys are optional: The following keys are optional:
- `Scope` is a string that specifies the prefix of the function's name in its fully qualified name. This option restricts the set of matching function calls. - `Scope` is a string that specifies the prefix of the function's name in its fully qualified name. This option restricts the set of matching function calls.

clang/docs/conf.py

Show First 20 Lines • Show All 226 Lines • ▼ Show 20 Lines
# One entry per manual page. List of tuples # One entry per manual page. List of tuples
# (source start file, name, description, authors, manual section). # (source start file, name, description, authors, manual section).
man_pages = [] man_pages = []
# Automatically derive the list of man pages from the contents of the command # Automatically derive the list of man pages from the contents of the command
# guide subdirectory. This was copied from llvm/docs/conf.py. # guide subdirectory. This was copied from llvm/docs/conf.py.
basedir = os.path.dirname(__file__) basedir = os.path.dirname(__file__)
man_page_authors = u'Maintained by the Clang / LLVM Team (<http://clang.llvm.org>)' man_page_authors = u'Maintained by the Clang / LLVM Team (<https://clang.llvm.org>)'
command_guide_subpath = 'CommandGuide' command_guide_subpath = 'CommandGuide'
command_guide_path = os.path.join(basedir, command_guide_subpath) command_guide_path = os.path.join(basedir, command_guide_subpath)
for name in os.listdir(command_guide_path): for name in os.listdir(command_guide_path):
# Ignore non-ReST files and the index page. # Ignore non-ReST files and the index page.
if not name.endswith('.rst') or name in ('index.rst',): if not name.endswith('.rst') or name in ('index.rst',):
continue continue
# Otherwise, automatically extract the description. # Otherwise, automatically extract the description.
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

clang/include/clang/AST/RecursiveASTVisitor.h

Show First 20 Lines • Show All 2,312 Lines • ▼ Show 20 Lines
// ----------------- Stmt traversal ----------------- // ----------------- Stmt traversal -----------------
// //
// For stmts, we automate (in the DEF_TRAVERSE_STMT macro) iterating // For stmts, we automate (in the DEF_TRAVERSE_STMT macro) iterating
// over the children defined in children() (every stmt defines these, // over the children defined in children() (every stmt defines these,
// though sometimes the range is empty). Each individual Traverse* // though sometimes the range is empty). Each individual Traverse*
// method only needs to worry about children other than those. To see // method only needs to worry about children other than those. To see
// what children() does for a given class, see, e.g., // what children() does for a given class, see, e.g.,
// http://clang.llvm.org/doxygen/Stmt_8cpp_source.html // https://clang.llvm.org/doxygen/Stmt_8cpp_source.html
// This macro makes available a variable S, the passed-in stmt. // This macro makes available a variable S, the passed-in stmt.
#define DEF_TRAVERSE_STMT(STMT, CODE) \ #define DEF_TRAVERSE_STMT(STMT, CODE) \
template <typename Derived> \ template <typename Derived> \
bool RecursiveASTVisitor<Derived>::Traverse##STMT( \ bool RecursiveASTVisitor<Derived>::Traverse##STMT( \
STMT *S, DataRecursionQueue *Queue) { \ STMT *S, DataRecursionQueue *Queue) { \
bool ShouldVisitChildren = true; \ bool ShouldVisitChildren = true; \
bool ReturnValue = true; \ bool ReturnValue = true; \
▲ Show 20 Lines • Show All 1,496 Lines • ▼ Show 20 Lines
// had lots of sub-types to explore. // had lots of sub-types to explore.
// //
// VisitOverloadExpr and its children: recurse on template args? etc? // VisitOverloadExpr and its children: recurse on template args? etc?
// FIXME: go through all the stmts and exprs again, and see which of them // FIXME: go through all the stmts and exprs again, and see which of them
// create new types, and recurse on the types (TypeLocs?) of those. // create new types, and recurse on the types (TypeLocs?) of those.
// Candidates: // Candidates:
// //
// http://clang.llvm.org/doxygen/classclang_1_1CXXTypeidExpr.html // https://clang.llvm.org/doxygen/classclang_1_1CXXTypeidExpr.html
// http://clang.llvm.org/doxygen/classclang_1_1UnaryExprOrTypeTraitExpr.html // https://clang.llvm.org/doxygen/classclang_1_1UnaryExprOrTypeTraitExpr.html
// http://clang.llvm.org/doxygen/classclang_1_1TypesCompatibleExpr.html // https://clang.llvm.org/doxygen/classclang_1_1TypesCompatibleExpr.html
// Every class that has getQualifier. // Every class that has getQualifier.
#undef DEF_TRAVERSE_STMT #undef DEF_TRAVERSE_STMT
#undef TRAVERSE_STMT #undef TRAVERSE_STMT
#undef TRAVERSE_STMT_BASE #undef TRAVERSE_STMT_BASE
#undef TRY_TO #undef TRY_TO
} // end namespace clang } // end namespace clang
#endif // LLVM_CLANG_AST_RECURSIVEASTVISITOR_H #endif // LLVM_CLANG_AST_RECURSIVEASTVISITOR_H

clang/include/clang/Basic/AttrDocs.td

Show First 20 Lines • Show All 1,664 Lines • ▼ Show 20 Lines
.. code-block:: c .. code-block:: c
#pragma clang attribute push (__attribute__((availability(iOS, unavailable))), apply_to=function) #pragma clang attribute push (__attribute__((availability(iOS, unavailable))), apply_to=function)
void infersTVOSAvailabilityFromAttributeNextToDeclaration(void) void infersTVOSAvailabilityFromAttributeNextToDeclaration(void)
__attribute__((availability(iOS,introduced=11.0))); __attribute__((availability(iOS,introduced=11.0)));
#pragma clang attribute pop #pragma clang attribute pop
Also see the documentation for `@available Also see the documentation for `@available
<http://clang.llvm.org/docs/LanguageExtensions.html#objective-c-available>`_ <https://clang.llvm.org/docs/LanguageExtensions.html#objective-c-available>`_
}]; }];
} }
def ExternalSourceSymbolDocs : Documentation { def ExternalSourceSymbolDocs : Documentation {
let Category = DocCatDecl; let Category = DocCatDecl;
let Content = [{ let Content = [{
The ``external_source_symbol`` attribute specifies that a declaration originates The ``external_source_symbol`` attribute specifies that a declaration originates
from an external source and describes the nature of that source. from an external source and describes the nature of that source.
▲ Show 20 Lines • Show All 1,779 Lines • ▼ Show 20 Linesdef LoopHintDocs : Documentation {
let Heading = "#pragma clang loop"; let Heading = "#pragma clang loop";
let Content = [{ let Content = [{
The ``#pragma clang loop`` directive allows loop optimization hints to be The ``#pragma clang loop`` directive allows loop optimization hints to be
specified for the subsequent loop. The directive allows pipelining to be specified for the subsequent loop. The directive allows pipelining to be
disabled, or vectorization, vector predication, interleaving, and unrolling to disabled, or vectorization, vector predication, interleaving, and unrolling to
be enabled or disabled. Vector width, vector predication, interleave count, be enabled or disabled. Vector width, vector predication, interleave count,
unrolling count, and the initiation interval for pipelining can be explicitly unrolling count, and the initiation interval for pipelining can be explicitly
specified. See `language extensions specified. See `language extensions
<http://clang.llvm.org/docs/LanguageExtensions.html#extensions-for-loop-hint-optimizations>`_ <https://clang.llvm.org/docs/LanguageExtensions.html#extensions-for-loop-hint-optimizations>`_
for details. for details.
}]; }];
} }
def UnrollHintDocs : Documentation { def UnrollHintDocs : Documentation {
let Category = DocCatStmt; let Category = DocCatStmt;
let Heading = "#pragma unroll, #pragma nounroll"; let Heading = "#pragma unroll, #pragma nounroll";
let Content = [{ let Content = [{
Show All 40 Lines for (...) {
... ...
} }
``#pragma unroll`` and ``#pragma unroll _value_`` have identical semantics to ``#pragma unroll`` and ``#pragma unroll _value_`` have identical semantics to
``#pragma clang loop unroll(full)`` and ``#pragma clang loop unroll(full)`` and
``#pragma clang loop unroll_count(_value_)`` respectively. ``#pragma nounroll`` ``#pragma clang loop unroll_count(_value_)`` respectively. ``#pragma nounroll``
is equivalent to ``#pragma clang loop unroll(disable)``. See is equivalent to ``#pragma clang loop unroll(disable)``. See
`language extensions `language extensions
<http://clang.llvm.org/docs/LanguageExtensions.html#extensions-for-loop-hint-optimizations>`_ <https://clang.llvm.org/docs/LanguageExtensions.html#extensions-for-loop-hint-optimizations>`_
for further details including limitations of the unroll hints. for further details including limitations of the unroll hints.
}]; }];
} }
def PipelineHintDocs : Documentation { def PipelineHintDocs : Documentation {
let Category = DocCatStmt; let Category = DocCatStmt;
let Heading = "#pragma clang loop pipeline, #pragma clang loop pipeline_initiation_interval"; let Heading = "#pragma clang loop pipeline, #pragma clang loop pipeline_initiation_interval";
let Content = [{ let Content = [{
▲ Show 20 Lines • Show All 2,064 Lines • ▼ Show 20 Lines
represent an implicit "this" pointer in class methods. If there is no implicit represent an implicit "this" pointer in class methods. If there is no implicit
"this" pointer it shall not be referenced. The index '-1', or the name "__", "this" pointer it shall not be referenced. The index '-1', or the name "__",
represents an unknown callback callee argument. This can be a value which is represents an unknown callback callee argument. This can be a value which is
not present in the declared parameter list, or one that is, but is potentially not present in the declared parameter list, or one that is, but is potentially
inspected, captured, or modified. Parameter names and indices can be mixed in inspected, captured, or modified. Parameter names and indices can be mixed in
the callback attribute. the callback attribute.
The ``callback`` attribute, which is directly translated to ``callback`` The ``callback`` attribute, which is directly translated to ``callback``
metadata <http://llvm.org/docs/LangRef.html#callback-metadata>, make the metadata <https://llvm.org/docs/LangRef.html#callback-metadata>, make the
connection between the call to the annotated function and the callback callee. connection between the call to the annotated function and the callback callee.
This can enable interprocedural optimizations which were otherwise impossible. This can enable interprocedural optimizations which were otherwise impossible.
If a function parameter is mentioned in the ``callback`` attribute, through its If a function parameter is mentioned in the ``callback`` attribute, through its
position, it is undefined if that parameter is used for anything other than the position, it is undefined if that parameter is used for anything other than the
actual callback. Inspected, captured, or modified parameters shall not be actual callback. Inspected, captured, or modified parameters shall not be
listed in the ``callback`` metadata. listed in the ``callback`` metadata.
Example encodings for the callback performed by ``pthread_create`` are shown Example encodings for the callback performed by ``pthread_create`` are shown
▲ Show 20 Lines • Show All 939 Lines • Show Last 20 Lines

clang/include/clang/Format/Format.h

Show First 20 Lines • Show All 4,024 Lines • ▼ Show 20 Linesprivate:
friend std::error_code friend std::error_code
parseConfiguration(llvm::MemoryBufferRef Config, FormatStyle *Style, parseConfiguration(llvm::MemoryBufferRef Config, FormatStyle *Style,
bool AllowUnknownOptions, bool AllowUnknownOptions,
llvm::SourceMgr::DiagHandlerTy DiagHandler, llvm::SourceMgr::DiagHandlerTy DiagHandler,
void *DiagHandlerCtxt); void *DiagHandlerCtxt);
}; };
/// Returns a format style complying with the LLVM coding standards: /// Returns a format style complying with the LLVM coding standards:
/// http://llvm.org/docs/CodingStandards.html. /// https://llvm.org/docs/CodingStandards.html.
FormatStyle getLLVMStyle( FormatStyle getLLVMStyle(
FormatStyle::LanguageKind Language = FormatStyle::LanguageKind::LK_Cpp); FormatStyle::LanguageKind Language = FormatStyle::LanguageKind::LK_Cpp);
/// Returns a format style complying with one of Google's style guides: /// Returns a format style complying with one of Google's style guides:
/// http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml. /// http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml.
/// http://google-styleguide.googlecode.com/svn/trunk/javascriptguide.xml. /// http://google-styleguide.googlecode.com/svn/trunk/javascriptguide.xml.
/// https://developers.google.com/protocol-buffers/docs/style. /// https://developers.google.com/protocol-buffers/docs/style.
FormatStyle getGoogleStyle(FormatStyle::LanguageKind Language); FormatStyle getGoogleStyle(FormatStyle::LanguageKind Language);
▲ Show 20 Lines • Show All 260 Lines • Show Last 20 Lines

clang/include/clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h

Show First 20 Lines • Show All 1,056 Lines • ▼ Show 20 Lines
/// Represents the memory deallocation call in a C++ delete-expression. /// Represents the memory deallocation call in a C++ delete-expression.
/// ///
/// This is a call to "operator delete". /// This is a call to "operator delete".
// FIXME: CXXDeleteExpr isn't present for custom delete operators, or even for // FIXME: CXXDeleteExpr isn't present for custom delete operators, or even for
// some those that are in the standard library, like the no-throw or align_val // some those that are in the standard library, like the no-throw or align_val
// versions. // versions.
// Some pointers: // Some pointers:
// http://lists.llvm.org/pipermail/cfe-dev/2020-April/065080.html // https://lists.llvm.org/pipermail/cfe-dev/2020-April/065080.html
// clang/test/Analysis/cxx-dynamic-memory-analysis-order.cpp // clang/test/Analysis/cxx-dynamic-memory-analysis-order.cpp
// clang/unittests/StaticAnalyzer/CallEventTest.cpp // clang/unittests/StaticAnalyzer/CallEventTest.cpp
class CXXDeallocatorCall : public AnyFunctionCall { class CXXDeallocatorCall : public AnyFunctionCall {
friend class CallEventManager; friend class CallEventManager;
protected: protected:
CXXDeallocatorCall(const CXXDeleteExpr *E, ProgramStateRef St, CXXDeallocatorCall(const CXXDeleteExpr *E, ProgramStateRef St,
const LocationContext *LCtx) const LocationContext *LCtx)
▲ Show 20 Lines • Show All 316 Lines • Show Last 20 Lines

clang/include/clang/Tooling/CommonOptionsParser.h

Show All 12 Lines
// //
// It provides a common subset of command-line options, common algorithm // It provides a common subset of command-line options, common algorithm
// for locating a compilation database and source files, and help messages // for locating a compilation database and source files, and help messages
// for the basic command-line interface. // for the basic command-line interface.
// //
// It creates a CompilationDatabase and reads common command-line options. // It creates a CompilationDatabase and reads common command-line options.
// //
// This class uses the Clang Tooling infrastructure, see // This class uses the Clang Tooling infrastructure, see
// http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html // https://clang.llvm.org/docs/HowToSetupToolingForLLVM.html
// for details on setting it up with LLVM source tree. // for details on setting it up with LLVM source tree.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_CLANG_TOOLING_COMMONOPTIONSPARSER_H #ifndef LLVM_CLANG_TOOLING_COMMONOPTIONSPARSER_H
#define LLVM_CLANG_TOOLING_COMMONOPTIONSPARSER_H #define LLVM_CLANG_TOOLING_COMMONOPTIONSPARSER_H
#include "clang/Tooling/ArgumentsAdjusters.h" #include "clang/Tooling/ArgumentsAdjusters.h"
▲ Show 20 Lines • Show All 115 Lines • Show Last 20 Lines

clang/lib/Analysis/RetainSummaryManager.cpp

Show First 20 Lines • Show All 1,237 Lines • ▼ Show 20 Lines Summ = getPersistentSummary(NoRet, ScratchArgs, ArgEffect(Autorelease,
ObjKind::ObjC)); ObjKind::ObjC));
addNSObjectMethSummary(GetNullarySelector("autorelease", Ctx), Summ); addNSObjectMethSummary(GetNullarySelector("autorelease", Ctx), Summ);
// For NSWindow, allocated objects are (initially) self-owned. // For NSWindow, allocated objects are (initially) self-owned.
// FIXME: For now we opt for false negatives with NSWindow, as these objects // FIXME: For now we opt for false negatives with NSWindow, as these objects
// self-own themselves. However, they only do this once they are displayed. // self-own themselves. However, they only do this once they are displayed.
// Thus, we need to track an NSWindow's display status. // Thus, we need to track an NSWindow's display status.
// This is tracked in <rdar://problem/6062711>. // This is tracked in <rdar://problem/6062711>.
// See also http://llvm.org/bugs/show_bug.cgi?id=3714. // See also https://llvm.org/bugs/show_bug.cgi?id=3714.
const RetainSummary *NoTrackYet = const RetainSummary *NoTrackYet =
getPersistentSummary(RetEffect::MakeNoRet(), ScratchArgs, getPersistentSummary(RetEffect::MakeNoRet(), ScratchArgs,
ArgEffect(StopTracking), ArgEffect(StopTracking)); ArgEffect(StopTracking), ArgEffect(StopTracking));
addClassMethSummary("NSWindow", "alloc", NoTrackYet); addClassMethSummary("NSWindow", "alloc", NoTrackYet);
// For NSPanel (which subclasses NSWindow), allocated objects are not // For NSPanel (which subclasses NSWindow), allocated objects are not
// self-owned. // self-owned.
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

clang/lib/Analysis/ThreadSafety.cpp

//===- ThreadSafety.cpp ---------------------------------------------------===// //===- ThreadSafety.cpp ---------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// A intra-procedural analysis for thread safety (e.g. deadlocks and race // A intra-procedural analysis for thread safety (e.g. deadlocks and race
// conditions), based off of an annotation system. // conditions), based off of an annotation system.
// //
// See http://clang.llvm.org/docs/ThreadSafetyAnalysis.html // See https://clang.llvm.org/docs/ThreadSafetyAnalysis.html
// for more information. // for more information.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "clang/Analysis/Analyses/ThreadSafety.h" #include "clang/Analysis/Analyses/ThreadSafety.h"
#include "clang/AST/Attr.h" #include "clang/AST/Attr.h"
#include "clang/AST/Decl.h" #include "clang/AST/Decl.h"
#include "clang/AST/DeclCXX.h" #include "clang/AST/DeclCXX.h"
▲ Show 20 Lines • Show All 2,471 Lines • Show Last 20 Lines

clang/lib/Basic/Targets/PPC.h

Show First 20 Lines • Show All 481 Lines • ▼ Show 20 Lines
class LLVM_LIBRARY_VISIBILITY DarwinPPC32TargetInfo class LLVM_LIBRARY_VISIBILITY DarwinPPC32TargetInfo
: public DarwinTargetInfo<PPC32TargetInfo> { : public DarwinTargetInfo<PPC32TargetInfo> {
public: public:
DarwinPPC32TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) DarwinPPC32TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
: DarwinTargetInfo<PPC32TargetInfo>(Triple, Opts) { : DarwinTargetInfo<PPC32TargetInfo>(Triple, Opts) {
HasAlignMac68kSupport = true; HasAlignMac68kSupport = true;
BoolWidth = BoolAlign = 32; // XXX support -mone-byte-bool? BoolWidth = BoolAlign = 32; // XXX support -mone-byte-bool?
PtrDiffType = SignedInt; // for http://llvm.org/bugs/show_bug.cgi?id=15726 PtrDiffType = SignedInt; // for https://llvm.org/bugs/show_bug.cgi?id=15726
LongLongAlign = 32; LongLongAlign = 32;
resetDataLayout("E-m:o-p:32:32-f64:32:64-n32", "_"); resetDataLayout("E-m:o-p:32:32-f64:32:64-n32", "_");
} }
BuiltinVaListKind getBuiltinVaListKind() const override { BuiltinVaListKind getBuiltinVaListKind() const override {
return TargetInfo::CharPtrBuiltinVaList; return TargetInfo::CharPtrBuiltinVaList;
} }
}; };
Show All 29 Lines

clang/lib/CodeGen/CGCall.cpp

Show First 20 Lines • Show All 2,794 Lines • ▼ Show 20 Lines for (FunctionArgList::const_iterator i = Args.begin(), e = Args.end();
case ABIArgInfo::Extend: case ABIArgInfo::Extend:
case ABIArgInfo::Direct: { case ABIArgInfo::Direct: {
auto AI = Fn->getArg(FirstIRArg); auto AI = Fn->getArg(FirstIRArg);
llvm::Type *LTy = ConvertType(Arg->getType()); llvm::Type *LTy = ConvertType(Arg->getType());
// Prepare parameter attributes. So far, only attributes for pointer // Prepare parameter attributes. So far, only attributes for pointer
// parameters are prepared. See // parameters are prepared. See
// http://llvm.org/docs/LangRef.html#paramattrs. // https://llvm.org/docs/LangRef.html#paramattrs.
if (ArgI.getDirectOffset() == 0 && LTy->isPointerTy() && if (ArgI.getDirectOffset() == 0 && LTy->isPointerTy() &&
ArgI.getCoerceToType()->isPointerTy()) { ArgI.getCoerceToType()->isPointerTy()) {
assert(NumIRArgs == 1); assert(NumIRArgs == 1);
if (const ParmVarDecl *PVD = dyn_cast<ParmVarDecl>(Arg)) { if (const ParmVarDecl *PVD = dyn_cast<ParmVarDecl>(Arg)) {
// Set `nonnull` attribute if any. // Set `nonnull` attribute if any.
if (getNonNullAttr(CurCodeDecl, PVD, PVD->getType(), if (getNonNullAttr(CurCodeDecl, PVD, PVD->getType(),
PVD->getFunctionScopeIndex()) && PVD->getFunctionScopeIndex()) &&
▲ Show 20 Lines • Show All 2,803 Lines • Show Last 20 Lines

clang/lib/Format/Format.cpp

Show First 20 Lines • Show All 2,766 Lines • ▼ Show 20 Linestooling::Replacements sortCppIncludes(const FormatStyle &Style, StringRef Code,
unsigned SearchFrom = 0; unsigned SearchFrom = 0;
llvm::Regex IncludeRegex(CppIncludeRegexPattern); llvm::Regex IncludeRegex(CppIncludeRegexPattern);
SmallVector<StringRef, 4> Matches; SmallVector<StringRef, 4> Matches;
SmallVector<IncludeDirective, 16> IncludesInBlock; SmallVector<IncludeDirective, 16> IncludesInBlock;
// In compiled files, consider the first #include to be the main #include of // In compiled files, consider the first #include to be the main #include of
// the file if it is not a system #include. This ensures that the header // the file if it is not a system #include. This ensures that the header
// doesn't have hidden dependencies // doesn't have hidden dependencies
// (http://llvm.org/docs/CodingStandards.html#include-style). // (https://llvm.org/docs/CodingStandards.html#include-style).
// //
// FIXME: Do some validation, e.g. edit distance of the base name, to fix // FIXME: Do some validation, e.g. edit distance of the base name, to fix
// cases where the first #include is unlikely to be the main header. // cases where the first #include is unlikely to be the main header.
tooling::IncludeCategoryManager Categories(Style.IncludeStyle, FileName); tooling::IncludeCategoryManager Categories(Style.IncludeStyle, FileName);
bool FirstIncludeBlock = true; bool FirstIncludeBlock = true;
bool MainIncludeFound = false; bool MainIncludeFound = false;
bool FormattingOff = false; bool FormattingOff = false;
▲ Show 20 Lines • Show All 888 Lines • Show Last 20 Lines

clang/lib/Format/WhitespaceManager.cpp

Show First 20 Lines • Show All 333 Lines • ▼ Show 20 Lines for (unsigned i = Start; i != End; ++i) {
// spaces it has to be shifted, so the rest of the changes on the line are // spaces it has to be shifted, so the rest of the changes on the line are
// shifted by the same amount // shifted by the same amount
if (!FoundMatchOnLine && !SkipMatchCheck && Matches(Changes[i])) { if (!FoundMatchOnLine && !SkipMatchCheck && Matches(Changes[i])) {
FoundMatchOnLine = true; FoundMatchOnLine = true;
Shift = Column - (RightJustify ? Changes[i].TokenLength : 0) - Shift = Column - (RightJustify ? Changes[i].TokenLength : 0) -
Changes[i].StartOfTokenColumn; Changes[i].StartOfTokenColumn;
Changes[i].Spaces += Shift; Changes[i].Spaces += Shift;
// FIXME: This is a workaround that should be removed when we fix // FIXME: This is a workaround that should be removed when we fix
// http://llvm.org/PR53699. An assertion later below verifies this. // https://llvm.org/PR53699. An assertion later below verifies this.
if (Changes[i].NewlinesBefore == 0) { if (Changes[i].NewlinesBefore == 0) {
Changes[i].Spaces = Changes[i].Spaces =
std::max(Changes[i].Spaces, std::max(Changes[i].Spaces,
static_cast<int>(Changes[i].Tok->SpacesRequiredBefore)); static_cast<int>(Changes[i].Tok->SpacesRequiredBefore));
} }
} }
// This is for function parameters that are split across multiple lines, // This is for function parameters that are split across multiple lines,
▲ Show 20 Lines • Show All 1,169 Lines • Show Last 20 Lines

clang/lib/FrontendTool/ExecuteCompilerInvocation.cpp

Show First 20 Lines • Show All 188 Lines • ▼ Show 20 Lines#endif
return Act; return Act;
} }
bool ExecuteCompilerInvocation(CompilerInstance *Clang) { bool ExecuteCompilerInvocation(CompilerInstance *Clang) {
// Honor -help. // Honor -help.
if (Clang->getFrontendOpts().ShowHelp) { if (Clang->getFrontendOpts().ShowHelp) {
driver::getDriverOptTable().printHelp( driver::getDriverOptTable().printHelp(
llvm::outs(), "clang -cc1 [options] file...", llvm::outs(), "clang -cc1 [options] file...",
"LLVM 'Clang' Compiler: http://clang.llvm.org", "LLVM 'Clang' Compiler: https://clang.llvm.org",
/*Include=*/driver::options::CC1Option, /*Include=*/driver::options::CC1Option,
/*Exclude=*/0, /*ShowAllAliases=*/false); /*Exclude=*/0, /*ShowAllAliases=*/false);
return true; return true;
} }
// Honor -version. // Honor -version.
// //
// FIXME: Use a better -version message? // FIXME: Use a better -version message?
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

clang/lib/StaticAnalyzer/Checkers/CheckObjCDealloc.cpp

Show First 20 Lines • Show All 1,013 Lines • ▼ Show 20 Lines for ( ; ID ; ID = ID->getSuperClass()) {
IdentifierInfo *II = ID->getIdentifier(); IdentifierInfo *II = ID->getIdentifier();
if (II == NSObjectII) if (II == NSObjectII)
return false; return false;
// FIXME: For now, ignore classes that subclass SenTestCase and XCTestCase, // FIXME: For now, ignore classes that subclass SenTestCase and XCTestCase,
// as these don't need to implement -dealloc. They implement tear down in // as these don't need to implement -dealloc. They implement tear down in
// another way, which we should try and catch later. // another way, which we should try and catch later.
// http://llvm.org/bugs/show_bug.cgi?id=3187 // https://llvm.org/bugs/show_bug.cgi?id=3187
if (II == XCTestCaseII || II == SenTestCaseII) if (II == XCTestCaseII || II == SenTestCaseII)
return true; return true;
} }
return true; return true;
} }
/// The -dealloc method in CIFilter highly unusual in that is will release /// The -dealloc method in CIFilter highly unusual in that is will release
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

clang/lib/StaticAnalyzer/Checkers/PointerArithChecker.cpp

Show First 20 Lines • Show All 70 Lines • ▼ Show 20 Lines
}; };
} // end namespace } // end namespace
REGISTER_MAP_WITH_PROGRAMSTATE(RegionState, const MemRegion *, AllocKind) REGISTER_MAP_WITH_PROGRAMSTATE(RegionState, const MemRegion *, AllocKind)
void PointerArithChecker::checkDeadSymbols(SymbolReaper &SR, void PointerArithChecker::checkDeadSymbols(SymbolReaper &SR,
CheckerContext &C) const { CheckerContext &C) const {
// TODO: intentional leak. Some information is garbage collected too early, // TODO: intentional leak. Some information is garbage collected too early,
// see http://reviews.llvm.org/D14203 for further information. // see https://reviews.llvm.org/D14203 for further information.
/*ProgramStateRef State = C.getState(); /*ProgramStateRef State = C.getState();
RegionStateTy RegionStates = State->get<RegionState>(); RegionStateTy RegionStates = State->get<RegionState>();
for (RegionStateTy::iterator I = RegionStates.begin(), E = RegionStates.end(); for (RegionStateTy::iterator I = RegionStates.begin(), E = RegionStates.end();
I != E; ++I) { I != E; ++I) {
if (!SR.isLiveRegion(I->first)) if (!SR.isLiveRegion(I->first))
State = State->remove<RegionState>(I->first); State = State->remove<RegionState>(I->first);
} }
C.addTransition(State);*/ C.addTransition(State);*/
▲ Show 20 Lines • Show All 261 Lines • Show Last 20 Lines

clang/lib/Tooling/CommonOptionsParser.cpp

Show All 12 Lines
// //
// It provides a common subset of command-line options, common algorithm // It provides a common subset of command-line options, common algorithm
// for locating a compilation database and source files, and help messages // for locating a compilation database and source files, and help messages
// for the basic command-line interface. // for the basic command-line interface.
// //
// It creates a CompilationDatabase and reads common command-line options. // It creates a CompilationDatabase and reads common command-line options.
// //
// This class uses the Clang Tooling infrastructure, see // This class uses the Clang Tooling infrastructure, see
// http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html // https://clang.llvm.org/docs/HowToSetupToolingForLLVM.html
// for details on setting it up with LLVM source tree. // for details on setting it up with LLVM source tree.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "clang/Tooling/CommonOptionsParser.h" #include "clang/Tooling/CommonOptionsParser.h"
#include "clang/Tooling/Tooling.h" #include "clang/Tooling/Tooling.h"
#include "llvm/Support/CommandLine.h" #include "llvm/Support/CommandLine.h"
▲ Show 20 Lines • Show All 147 Lines • Show Last 20 Lines

clang/test/Analysis/CFRetainRelease_NSAssertionHandler.m

Show All 20 Lines
+ (NSAssertionHandler *)currentHandler; + (NSAssertionHandler *)currentHandler;
- (void)handleFailureInMethod:(SEL)selector object:(id)object file:(NSString *)fileName lineNumber:(NSInteger)line description:(NSString *)format,...; - (void)handleFailureInMethod:(SEL)selector object:(id)object file:(NSString *)fileName lineNumber:(NSInteger)line description:(NSString *)format,...;
- (void)handleFailureInFunction:(NSString *)functionName file:(NSString *)fileName lineNumber:(NSInteger)line description:(NSString *)format,...; - (void)handleFailureInFunction:(NSString *)functionName file:(NSString *)fileName lineNumber:(NSInteger)line description:(NSString *)format,...;
@end @end
extern NSString * const NSConnectionReplyMode; extern NSString * const NSConnectionReplyMode;
//----------------------------------------------------------------------------// //----------------------------------------------------------------------------//
// The following test case was filed in PR 2593: // The following test case was filed in PR 2593:
// http://llvm.org/bugs/show_bug.cgi?id=2593 // https://llvm.org/bugs/show_bug.cgi?id=2593
// //
// There should be no null dereference flagged by the checker because of // There should be no null dereference flagged by the checker because of
// NSParameterAssert and NSAssert. // NSParameterAssert and NSAssert.
@interface TestAssert : NSObject {} @interface TestAssert : NSObject {}
@end @end
Show All 36 Lines

clang/test/Analysis/MissingDealloc.m

Show First 20 Lines • Show All 137 Lines • ▼ Show 20 Lines
IBOutlet NSWindow *window; IBOutlet NSWindow *window;
} }
@end @end
@implementation HasOutlet // no-warning @implementation HasOutlet // no-warning
@end @end
//===------------------------------------------------------------------------=== //===------------------------------------------------------------------------===
// PR 3187: http://llvm.org/bugs/show_bug.cgi?id=3187 // PR 3187: https://llvm.org/bugs/show_bug.cgi?id=3187
// - Disable the missing -dealloc check for classes that subclass SenTestCase // - Disable the missing -dealloc check for classes that subclass SenTestCase
@class NSString; @class NSString;
@interface SenTestCase : NSObject {} @interface SenTestCase : NSObject {}
@end @end
@interface MyClassTest : SenTestCase { @interface MyClassTest : SenTestCase {
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

clang/test/Analysis/PR24184.cpp

// UNSUPPORTED: z3 // UNSUPPORTED: z3
// RUN: %clang_analyze_cc1 -w -fcxx-exceptions -analyzer-checker=core -analyzer-checker=alpha.core.PointerArithm,alpha.core.CastToStruct -analyzer-max-loop 64 -verify %s // RUN: %clang_analyze_cc1 -w -fcxx-exceptions -analyzer-checker=core -analyzer-checker=alpha.core.PointerArithm,alpha.core.CastToStruct -analyzer-max-loop 64 -verify %s
// RUN: %clang_analyze_cc1 -w -analyzer-checker=core -analyzer-checker=cplusplus -fcxx-exceptions -analyzer-checker alpha.core.PointerArithm,alpha.core.CastToStruct -analyzer-max-loop 63 -verify %s // RUN: %clang_analyze_cc1 -w -analyzer-checker=core -analyzer-checker=cplusplus -fcxx-exceptions -analyzer-checker alpha.core.PointerArithm,alpha.core.CastToStruct -analyzer-max-loop 63 -verify %s
// These tests used to hit an assertion in the bug report. Test case from http://llvm.org/PR24184. // These tests used to hit an assertion in the bug report. Test case from https://llvm.org/PR24184.
typedef struct { typedef struct {
int cbData; int cbData;
unsigned pbData; unsigned pbData;
} CRYPT_DATA_BLOB; } CRYPT_DATA_BLOB;
typedef enum { DT_NONCE_FIXED } DATA_TYPE; typedef enum { DT_NONCE_FIXED } DATA_TYPE;
int a; int a;
typedef int *vcreate_t(int *, DATA_TYPE, int, int); typedef int *vcreate_t(int *, DATA_TYPE, int, int);
▲ Show 20 Lines • Show All 85 Lines • Show Last 20 Lines

clang/test/Analysis/cxx-uninitialized-object.cpp

Show First 20 Lines • Show All 404 Lines • ▼ Show 20 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Tests for classes containing unions. // Tests for classes containing unions.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// FIXME: As of writing this checker, there is no good support for union types // FIXME: As of writing this checker, there is no good support for union types
// in the Static Analyzer. Here is non-exhaustive list of cases. // in the Static Analyzer. Here is non-exhaustive list of cases.
// Note that the rules for unions are different in C and C++. // Note that the rules for unions are different in C and C++.
// http://lists.llvm.org/pipermail/cfe-dev/2017-March/052910.html // https://lists.llvm.org/pipermail/cfe-dev/2017-March/052910.html
class ContainsSimpleUnionTest1 { class ContainsSimpleUnionTest1 {
union SimpleUnion { union SimpleUnion {
float uf; float uf;
int ui; int ui;
char uc; char uc;
} u; } u;
▲ Show 20 Lines • Show All 763 Lines • Show Last 20 Lines

clang/test/Analysis/dead-stores.c

Show First 20 Lines • Show All 212 Lines • ▼ Show 20 Lines
void f18_d(void) { void f18_d(void) {
int x = 0; // no-warning int x = 0; // no-warning
do do
x = 10; // non-nested-warning {{Value stored to 'x' is never read}} x = 10; // non-nested-warning {{Value stored to 'x' is never read}}
while (1); while (1);
} }
// PR 3514: false positive `dead initialization` warning for init to global // PR 3514: false positive `dead initialization` warning for init to global
// http://llvm.org/bugs/show_bug.cgi?id=3514 // https://llvm.org/bugs/show_bug.cgi?id=3514
extern const int MyConstant; extern const int MyConstant;
int f19(void) { int f19(void) {
int x = MyConstant; // no-warning int x = MyConstant; // no-warning
x = 1; x = 1;
return x; return x;
} }
int f19b(void) { // This case is the same as f19. int f19b(void) { // This case is the same as f19.
▲ Show 20 Lines • Show All 449 Lines • Show Last 20 Lines

clang/test/Analysis/dead-stores.m

Show All 21 Lines
+ (void)exposeBinding:(NSString *)binding; + (void)exposeBinding:(NSString *)binding;
- (NSArray *)exposedBindings; - (NSArray *)exposedBindings;
@end @end
extern NSString *NSAlignmentBinding; extern NSString *NSAlignmentBinding;
// This test case was reported as a false positive due to a bug in the // This test case was reported as a false positive due to a bug in the
// LiveVariables <-> deadcode.DeadStores interplay. We should not flag a warning // LiveVariables <-> deadcode.DeadStores interplay. We should not flag a warning
// here. The test case was reported in: // here. The test case was reported in:
// http://lists.llvm.org/pipermail/cfe-dev/2008-July/002157.html // https://lists.llvm.org/pipermail/cfe-dev/2008-July/002157.html
void DeadStoreTest(NSObject *anObject) { void DeadStoreTest(NSObject *anObject) {
NSArray *keys; NSArray *keys;
if ((keys = [anObject exposedBindings]) && // no-warning if ((keys = [anObject exposedBindings]) && // no-warning
([keys containsObject:@"name"] && [keys containsObject:@"icon"])) {} ([keys containsObject:@"name"] && [keys containsObject:@"icon"])) {}
} }
// This test case was a false positive due to how clang models // This test case was a false positive due to how clang models
// pointer types and ObjC object pointer types differently. Here // pointer types and ObjC object pointer types differently. Here
▲ Show 20 Lines • Show All 81 Lines • Show Last 20 Lines

clang/test/Analysis/misc-ps-eager-assume.m

Show First 20 Lines • Show All 58 Lines • ▼ Show 20 Linesvoid handle_symbolic_cast_in_condition(void) {
BOOL needsAnArray = [@"aString" isEqualToString:@"anotherString"]; BOOL needsAnArray = [@"aString" isEqualToString:@"anotherString"];
NSMutableArray* array = needsAnArray ? [[NSMutableArray alloc] init] : 0; NSMutableArray* array = needsAnArray ? [[NSMutableArray alloc] init] : 0;
if(needsAnArray) if(needsAnArray)
[array release]; [array release];
[pool drain]; [pool drain];
} }
// From PR 3836 (http://llvm.org/bugs/show_bug.cgi?id=3836) // From PR 3836 (https://llvm.org/bugs/show_bug.cgi?id=3836)
// //
// In this test case, the double '!' works fine with our symbolic constraints, // In this test case, the double '!' works fine with our symbolic constraints,
// but we don't support comparing SymConstraint != SymConstraint. By eagerly // but we don't support comparing SymConstraint != SymConstraint. By eagerly
// assuming the truth of !!a or !!b, we can compare these values directly. // assuming the truth of !!a or !!b, we can compare these values directly.
// //
void pr3836(int *a, int *b) { void pr3836(int *a, int *b) {
if (!!a != !!b) /* one of them is NULL */ if (!!a != !!b) /* one of them is NULL */
return; return;
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Lines for( Which = 0;
Which++ ) Which++ )
// This statement can only execute if Count > 0 which can only // This statement can only execute if Count > 0 which can only
// happen when Flag1 and Flag2 are both true and Flag2 will only // happen when Flag1 and Flag2 are both true and Flag2 will only
// be true when Pointer is not NULL. // be true when Pointer is not NULL.
rdar7342806_aux(*Pointer); // no-warning rdar7342806_aux(*Pointer); // no-warning
} }
//===---------------------------------------------------------------------===// //===---------------------------------------------------------------------===//
// PR 5627 - http://llvm.org/bugs/show_bug.cgi?id=5627 // PR 5627 - https://llvm.org/bugs/show_bug.cgi?id=5627
// This test case depends on using -analyzer-config eagerly-assume=true and // This test case depends on using -analyzer-config eagerly-assume=true and
// -analyzer-store=region. The 'eagerly-assume=true' causes the path // -analyzer-store=region. The 'eagerly-assume=true' causes the path
// to bifurcate when evaluating the function call argument, and a state // to bifurcate when evaluating the function call argument, and a state
// caching bug in ExprEngine::CheckerVisit (and friends) caused the store // caching bug in ExprEngine::CheckerVisit (and friends) caused the store
// to 'p' to not be evaluated along one path, but then an autotransition caused // to 'p' to not be evaluated along one path, but then an autotransition caused
// the path to keep on propagating with 'p' still set to an undefined value. // the path to keep on propagating with 'p' still set to an undefined value.
// We would then get a bogus report of returning uninitialized memory. // We would then get a bogus report of returning uninitialized memory.
// Note: CheckerVisit mistakenly cleared an existing node, and the cleared // Note: CheckerVisit mistakenly cleared an existing node, and the cleared
// node was resurrected by GRStmtNodeBuilder::~GRStmtNodeBuilder(), where // node was resurrected by GRStmtNodeBuilder::~GRStmtNodeBuilder(), where
// 'p' was not assigned. // 'p' was not assigned.
//===---------------------------------------------------------------------===// //===---------------------------------------------------------------------===//
float *pr5627_f(int y); float *pr5627_f(int y);
float *pr5627_g(int x) { float *pr5627_g(int x) {
float *p; float *p;
p = pr5627_f(!x); p = pr5627_f(!x);
return p; // no-warning return p; // no-warning
} }

clang/test/Analysis/misc-ps.m

Show First 20 Lines • Show All 62 Lines • ▼ Show 20 Lines
@interface A @end @interface A @end
@implementation A @implementation A
- (void)foo:(void (^)(NSObject *x))block { - (void)foo:(void (^)(NSObject *x))block {
if (!((block != ((void *)0)))) {} if (!((block != ((void *)0)))) {}
} }
@end @end
// Reduced test case from crash in PR 2796; // Reduced test case from crash in PR 2796;
// http://llvm.org/bugs/show_bug.cgi?id=2796 // https://llvm.org/bugs/show_bug.cgi?id=2796
unsigned foo(unsigned x) { return __alignof__((x)) + sizeof(x); } unsigned foo(unsigned x) { return __alignof__((x)) + sizeof(x); }
// Improvement to path-sensitivity involving compound assignments. // Improvement to path-sensitivity involving compound assignments.
// Addresses false positive in <rdar://problem/6268365> // Addresses false positive in <rdar://problem/6268365>
// //
unsigned r6268365Aux(void); unsigned r6268365Aux(void);
Show All 34 Lines
typedef long long __m128i __attribute__ ((__vector_size__ (16), __may_alias__)); typedef long long __m128i __attribute__ ((__vector_size__ (16), __may_alias__));
__m128i vec128i(long long __q1, long long __q0) { __m128i vec128i(long long __q1, long long __q0) {
// This compound literal returns true for both isVectorType() and // This compound literal returns true for both isVectorType() and
// isIntegerType(). // isIntegerType().
return __extension__ (__m128i)(__v2di){ __q0, __q1 }; return __extension__ (__m128i)(__v2di){ __q0, __q1 };
} }
// sizeof(void) // sizeof(void)
// - Tests a regression reported in PR 3211: http://llvm.org/bugs/show_bug.cgi?id=3211 // - Tests a regression reported in PR 3211: https://llvm.org/bugs/show_bug.cgi?id=3211
void handle_sizeof_void(unsigned flag) { void handle_sizeof_void(unsigned flag) {
int* p = 0; int* p = 0;
if (flag) { if (flag) {
if (sizeof(void) == 1) if (sizeof(void) == 1)
return; return;
// Infeasible. // Infeasible.
*p = 1; // no-warning *p = 1; // no-warning
▲ Show 20 Lines • Show All 1,220 Lines • ▼ Show 20 Lines
static void rdar1196620_call_assert(struct rdar1196620_s* s) { static void rdar1196620_call_assert(struct rdar1196620_s* s) {
int i = 0; int i = 0;
s?(void)0:__assert_fail(); s?(void)0:__assert_fail();
} }
static void rdar1196620(struct rdar1196620_s* s) { static void rdar1196620(struct rdar1196620_s* s) {
rdar1196620_call_assert(s); rdar1196620_call_assert(s);
} }

clang/test/Analysis/no-exit-cfg.c

// RUN: %clang_analyze_cc1 -analyzer-checker=core,alpha.core -analyzer-store=region -verify %s // RUN: %clang_analyze_cc1 -analyzer-checker=core,alpha.core -analyzer-store=region -verify %s
// expected-no-diagnostics // expected-no-diagnostics
// This is a test case for the issue reported in PR 2819: // This is a test case for the issue reported in PR 2819:
// http://llvm.org/bugs/show_bug.cgi?id=2819 // https://llvm.org/bugs/show_bug.cgi?id=2819
// The flow-sensitive dataflow solver should work even when no block in // The flow-sensitive dataflow solver should work even when no block in
// the CFG reaches the exit block. // the CFG reaches the exit block.
int g(int x); int g(int x);
void h(int x); void h(int x);
int f(int x) int f(int x)
{ {
out_err: out_err:
if (g(x)) { if (g(x)) {
h(x); h(x);
} }
goto out_err; goto out_err;
} }

clang/test/Analysis/pr_4164.c

// RUN: %clang_analyze_cc1 -triple x86_64-apple-darwin9 -analyzer-checker=core,alpha.core -analyzer-store=region -verify %s // RUN: %clang_analyze_cc1 -triple x86_64-apple-darwin9 -analyzer-checker=core,alpha.core -analyzer-store=region -verify %s
// expected-no-diagnostics // expected-no-diagnostics
// PR 4164: http://llvm.org/bugs/show_bug.cgi?id=4164 // PR 4164: https://llvm.org/bugs/show_bug.cgi?id=4164
// //
// Eventually this should be pulled into misc-ps.m. This is in a separate test // Eventually this should be pulled into misc-ps.m. This is in a separate test
// file for now to play around with the specific issues for BasicStoreManager // file for now to play around with the specific issues for BasicStoreManager
// and StoreManager (i.e., we can make a copy of this file for either // and StoreManager (i.e., we can make a copy of this file for either
// StoreManager should one start to fail in the near future). // StoreManager should one start to fail in the near future).
// //
// The basic issue is that the VarRegion for 'size' is casted to (char*), // The basic issue is that the VarRegion for 'size' is casted to (char*),
// resulting in an ElementRegion. 'getsockopt' is an unknown function that // resulting in an ElementRegion. 'getsockopt' is an unknown function that
Show All 20 Lines
// data) we strip off the ElementRegion when doing the invalidation. // data) we strip off the ElementRegion when doing the invalidation.
int takes_charptr(char* p); int takes_charptr(char* p);
int test2(void) { int test2(void) {
int size; int size;
if (takes_charptr((char*)&size)) if (takes_charptr((char*)&size))
return -1; return -1;
return size; // no-warning return size; // no-warning
} }

clang/test/Analysis/svalbuilder-logic.c

// RUN: %clang_analyze_cc1 -analyzer-checker=core,unix -Wno-pointer-to-int-cast -verify %s // RUN: %clang_analyze_cc1 -analyzer-checker=core,unix -Wno-pointer-to-int-cast -verify %s
// expected-no-diagnostics // expected-no-diagnostics
// Testing core functionality of the SValBuilder. // Testing core functionality of the SValBuilder.
int SValBuilderLogicNoCrash(int *x) { int SValBuilderLogicNoCrash(int *x) {
return 3 - (int)(x +3); return 3 - (int)(x +3);
} }
// http://llvm.org/bugs/show_bug.cgi?id=15863 // https://llvm.org/bugs/show_bug.cgi?id=15863
// Don't crash when mixing 'bool' and 'int' in implicit comparisons to 0. // Don't crash when mixing 'bool' and 'int' in implicit comparisons to 0.
void pr15863(void) { void pr15863(void) {
extern int getBool(void); extern int getBool(void);
_Bool a = getBool(); _Bool a = getBool();
(void)!a; // no-warning (void)!a; // no-warning
} }

clang/test/CodeGen/vla.c

Show First 20 Lines • Show All 80 Lines • ▼ Show 20 Linesint test2(int n)
GLOB = 0; GLOB = 0;
char b[1][n+3]; /* Variable length array. */ char b[1][n+3]; /* Variable length array. */
// CHECK: [[tmp_1:%.*]] = load i32, i32* @GLOB, align 4 // CHECK: [[tmp_1:%.*]] = load i32, i32* @GLOB, align 4
// CHECK-NEXT: add nsw i32 [[tmp_1]], 1 // CHECK-NEXT: add nsw i32 [[tmp_1]], 1
__typeof__(b[GLOB++]) c; __typeof__(b[GLOB++]) c;
return GLOB; return GLOB;
} }
// http://llvm.org/PR8567 // https://llvm.org/PR8567
// CHECK-LABEL: define{{.*}} double @test_PR8567 // CHECK-LABEL: define{{.*}} double @test_PR8567
double test_PR8567(int n, double (*p)[n][5]) { double test_PR8567(int n, double (*p)[n][5]) {
// CHECK: [[NV:%.*]] = alloca i32, align 4 // CHECK: [[NV:%.*]] = alloca i32, align 4
// CHECK-NEXT: [[PV:%.*]] = alloca [5 x double]*, align 4 // CHECK-NEXT: [[PV:%.*]] = alloca [5 x double]*, align 4
// CHECK-NEXT: store // CHECK-NEXT: store
// CHECK-NEXT: store // CHECK-NEXT: store
// CHECK-NEXT: [[N:%.*]] = load i32, i32* [[NV]], align 4 // CHECK-NEXT: [[N:%.*]] = load i32, i32* [[NV]], align 4
// CHECK-NEXT: [[P:%.*]] = load [5 x double]*, [5 x double]** [[PV]], align 4 // CHECK-NEXT: [[P:%.*]] = load [5 x double]*, [5 x double]** [[PV]], align 4
▲ Show 20 Lines • Show All 127 Lines • Show Last 20 Lines

clang/test/CodeGenCUDA/link-device-bitcode.cu

// Test for linking with CUDA's libdevice as outlined in // Test for linking with CUDA's libdevice as outlined in
// http://llvm.org/docs/NVPTXUsage.html#linking-with-libdevice // https://llvm.org/docs/NVPTXUsage.html#linking-with-libdevice
// //
// REQUIRES: nvptx-registered-target // REQUIRES: nvptx-registered-target
// //
// Prepare bitcode file to link with // Prepare bitcode file to link with
// RUN: %clang_cc1 -triple nvptx-unknown-cuda -emit-llvm-bc \ // RUN: %clang_cc1 -triple nvptx-unknown-cuda -emit-llvm-bc \
// RUN: -disable-llvm-passes -o %t.bc %S/Inputs/device-code.ll // RUN: -disable-llvm-passes -o %t.bc %S/Inputs/device-code.ll
// RUN: %clang_cc1 -triple nvptx-unknown-cuda -emit-llvm-bc \ // RUN: %clang_cc1 -triple nvptx-unknown-cuda -emit-llvm-bc \
// RUN: -disable-llvm-passes -o %t-2.bc %S/Inputs/device-code-2.ll // RUN: -disable-llvm-passes -o %t-2.bc %S/Inputs/device-code-2.ll
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

clang/test/CodeGenCXX/cfi-nvcall.cpp

Show All 19 Linesextern "C" void bg(B *b) {
// CHECK: call i1 @llvm.type.test(i8* {{%[^ ]*}}, metadata !"_ZTS1B") // CHECK: call i1 @llvm.type.test(i8* {{%[^ ]*}}, metadata !"_ZTS1B")
// CHECK-STRICT: call i1 @llvm.type.test(i8* {{%[^ ]*}}, metadata !"_ZTS1B") // CHECK-STRICT: call i1 @llvm.type.test(i8* {{%[^ ]*}}, metadata !"_ZTS1B")
b->g(); b->g();
} }
// CHECK-LABEL: @cg // CHECK-LABEL: @cg
// CHECK-STRICT-LABEL: @cg // CHECK-STRICT-LABEL: @cg
extern "C" void cg(C *c) { extern "C" void cg(C *c) {
// http://clang.llvm.org/docs/ControlFlowIntegrity.html#strictness // https://clang.llvm.org/docs/ControlFlowIntegrity.html#strictness
// In this case C's layout is the same as its base class, so we allow // In this case C's layout is the same as its base class, so we allow
// c to be of type A in non-strict mode. // c to be of type A in non-strict mode.
// CHECK: call i1 @llvm.type.test(i8* {{%[^ ]*}}, metadata !"_ZTS1A") // CHECK: call i1 @llvm.type.test(i8* {{%[^ ]*}}, metadata !"_ZTS1A")
// CHECK-STRICT: call i1 @llvm.type.test(i8* {{%[^ ]*}}, metadata !"_ZTS1C") // CHECK-STRICT: call i1 @llvm.type.test(i8* {{%[^ ]*}}, metadata !"_ZTS1C")
c->g(); c->g();
} }

clang/test/CodeGenCXX/microsoft-abi-array-cookies.cpp

Show All 32 Lines// CHECK: bitcast i8* [[ARRAY]] to [[CLASS:%.*]]*
delete [] array; delete [] array;
// CHECK: [[ARRAY_AS_CHAR:%.*]] = bitcast [[CLASS]]* {{%.*}} to i8* // CHECK: [[ARRAY_AS_CHAR:%.*]] = bitcast [[CLASS]]* {{%.*}} to i8*
// CHECK: getelementptr inbounds i8, i8* [[ARRAY_AS_CHAR]], i32 -4 // CHECK: getelementptr inbounds i8, i8* [[ARRAY_AS_CHAR]], i32 -4
} }
struct __attribute__((aligned(8))) ClassWithAlignment { struct __attribute__((aligned(8))) ClassWithAlignment {
// FIXME: replace __attribute__((aligned(8))) with __declspec(align(8)) once // FIXME: replace __attribute__((aligned(8))) with __declspec(align(8)) once
// http://llvm.org/bugs/show_bug.cgi?id=12631 is fixed. // https://llvm.org/bugs/show_bug.cgi?id=12631 is fixed.
int *x, *y; int *x, *y;
~ClassWithAlignment() {} ~ClassWithAlignment() {}
}; };
void check_array_cookies_aligned() { void check_array_cookies_aligned() {
// CHECK: define {{.*}} @"?check_array_cookies_aligned@@YAXXZ"() // CHECK: define {{.*}} @"?check_array_cookies_aligned@@YAXXZ"()
ClassWithAlignment *array = new ClassWithAlignment[42]; ClassWithAlignment *array = new ClassWithAlignment[42];
// CHECK: [[ALLOCATED:%.*]] = call noalias noundef nonnull i8* @"??_U@YAPAXI@Z"(i32 noundef 344) // CHECK: [[ALLOCATED:%.*]] = call noalias noundef nonnull i8* @"??_U@YAPAXI@Z"(i32 noundef 344)
Show All 22 Lines

clang/test/CodeGenObjCXX/encode.mm

Show First 20 Lines • Show All 153 Lines • ▼ Show 20 Lines
extern const char g2[] = @encode(DBase); extern const char g2[] = @encode(DBase);
// CHECK: @g3 ={{.*}} constant [26 x i8] c"{Sub_with_virt=^^?q^^?cd}\00" // CHECK: @g3 ={{.*}} constant [26 x i8] c"{Sub_with_virt=^^?q^^?cd}\00"
extern const char g3[] = @encode(Sub_with_virt); extern const char g3[] = @encode(Sub_with_virt);
// CHECK: @g4 ={{.*}} constant [19 x i8] c"{Sub2=^^?qcf^^?cd}\00" // CHECK: @g4 ={{.*}} constant [19 x i8] c"{Sub2=^^?qcf^^?cd}\00"
extern const char g4[] = @encode(Sub2); extern const char g4[] = @encode(Sub2);
// http://llvm.org/PR9927 // https://llvm.org/PR9927
class allocator { class allocator {
}; };
class basic_string { class basic_string {
struct _Alloc_hider : allocator { struct _Alloc_hider : allocator {
char* _M_p; char* _M_p;
}; };
_Alloc_hider _M_dataplus; _Alloc_hider _M_dataplus;
}; };
▲ Show 20 Lines • Show All 172 Lines • Show Last 20 Lines

clang/test/CodeGenOpenCL/vector_shufflevector.cl

// RUN: %clang_cc1 -emit-llvm -O0 %s -o - | FileCheck %s // RUN: %clang_cc1 -emit-llvm -O0 %s -o - | FileCheck %s
// The shuffle vector mask must always be of i32 vector type // The shuffle vector mask must always be of i32 vector type
// See http://reviews.llvm.org/D10838 and https://llvm.org/bugs/show_bug.cgi?id=23800#c2 // See https://reviews.llvm.org/D10838 and https://llvm.org/bugs/show_bug.cgi?id=23800#c2
// for more information about a bug where a 64 bit index operand causes the generation // for more information about a bug where a 64 bit index operand causes the generation
// of an invalid mask // of an invalid mask
typedef unsigned int uint2 __attribute((ext_vector_type(2))); typedef unsigned int uint2 __attribute((ext_vector_type(2)));
void vector_shufflevector_valid(void) { void vector_shufflevector_valid(void) {
//CHECK: {{%.*}} = shufflevector <2 x i32> {{%.*}}, <2 x i32> undef, <2 x i32> <i32 0, i32 undef> //CHECK: {{%.*}} = shufflevector <2 x i32> {{%.*}}, <2 x i32> undef, <2 x i32> <i32 0, i32 undef>
(uint2)(((uint2)(0)).s0, 0); (uint2)(((uint2)(0)).s0, 0);
} }

clang/test/Driver/cuda-simple.cu

// Verify that we can parse a simple CUDA file with or without -save-temps // Verify that we can parse a simple CUDA file with or without -save-temps
// http://llvm.org/PR22936 // https://llvm.org/PR22936
// RUN: %clang --cuda-path=%S/Inputs/CUDA/usr/local/cuda \ // RUN: %clang --cuda-path=%S/Inputs/CUDA/usr/local/cuda \
// RUN: -nocudainc -nocudalib -Werror -fsyntax-only -c %s // RUN: -nocudainc -nocudalib -Werror -fsyntax-only -c %s
// //
// Verify that we pass -x cuda-cpp-output to compiler after // Verify that we pass -x cuda-cpp-output to compiler after
// preprocessing a CUDA file // preprocessing a CUDA file
// RUN: %clang --cuda-path=%S/Inputs/CUDA/usr/local/cuda \ // RUN: %clang --cuda-path=%S/Inputs/CUDA/usr/local/cuda \
// RUN: -Werror -### -save-temps -c %s 2>&1 | FileCheck %s // RUN: -Werror -### -save-temps -c %s 2>&1 | FileCheck %s
// CHECK-LABEL: "-cc1" // CHECK-LABEL: "-cc1"
Show All 17 Lines

clang/test/Frontend/ast-main.cpp

// RUN: env SDKROOT="/" %clang -emit-llvm -S -o %t1.ll -x c++ - < %s // RUN: env SDKROOT="/" %clang -emit-llvm -S -o %t1.ll -x c++ - < %s
// RUN: env SDKROOT="/" %clang -fno-delayed-template-parsing -emit-ast -o %t.ast %s // RUN: env SDKROOT="/" %clang -fno-delayed-template-parsing -emit-ast -o %t.ast %s
// RUN: env SDKROOT="/" %clang -emit-llvm -S -o %t2.ll -x ast - < %t.ast // RUN: env SDKROOT="/" %clang -emit-llvm -S -o %t2.ll -x ast - < %t.ast
// RUN: diff %t1.ll %t2.ll // RUN: diff %t1.ll %t2.ll
// http://llvm.org/bugs/show_bug.cgi?id=15377 // https://llvm.org/bugs/show_bug.cgi?id=15377
template<typename T> template<typename T>
struct S { struct S {
T *mf(); T *mf();
}; };
template<typename T> template<typename T>
T *S<T>::mf() { T *S<T>::mf() {
// warning: non-void function does not return a value [-Wreturn-type] // warning: non-void function does not return a value [-Wreturn-type]
} }
void f() { void f() {
S<int>().mf(); S<int>().mf();
} }
int main() { int main() {
return 0; return 0;
} }

clang/test/Lexer/gnu-flags.c

Show All 40 Lines
#if ALL || BINARYLITERAL #if ALL || BINARYLITERAL
// expected-warning@+3 {{binary integer literals are a GNU extension}} // expected-warning@+3 {{binary integer literals are a GNU extension}}
#endif #endif
int b = 0b0101; int b = 0b0101;
// This case is handled differently because lit has a bug whereby #line 0 is reported to be on line 4294967295 // This case is handled differently because lit has a bug whereby #line 0 is reported to be on line 4294967295
// http://llvm.org/bugs/show_bug.cgi?id=16952 // https://llvm.org/bugs/show_bug.cgi?id=16952
#if ALL || LINE0 #if ALL || LINE0
#line 0 // expected-warning {{#line directive with zero argument is a GNU extension}} #line 0 // expected-warning {{#line directive with zero argument is a GNU extension}}
#else #else
#line 0 #line 0
#endif #endif
// WARNING: Do not add more tests after the #line 0 line! Add them before the LINE0 test // WARNING: Do not add more tests after the #line 0 line! Add them before the LINE0 test

clang/test/Misc/diag-trailing-null-bytes.cpp

// RUN: not %clang_cc1 -fsyntax-only %s 2>&1 | FileCheck -strict-whitespace %s // RUN: not %clang_cc1 -fsyntax-only %s 2>&1 | FileCheck -strict-whitespace %s
// CHECK: {{ERR_DNS_SERVER_REQUIRES_TCP$}} // CHECK: {{ERR_DNS_SERVER_REQUIRES_TCP$}}
// http://llvm.org/PR12674 // https://llvm.org/PR12674
#define NET_ERROR(label, value) ERR_ ## label = value, #define NET_ERROR(label, value) ERR_ ## label = value,
NET_ERROR(DNS_SERVER_REQUIRES_TCP, -801) NET_ERROR(DNS_SERVER_REQUIRES_TCP, -801)
#undef NET_ERROR #undef NET_ERROR

clang/test/PCH/objc_methods.h

/* For use with the methods.m test */ /* For use with the methods.m test */
@interface TestPCH @interface TestPCH
+ alloc; + alloc;
- (instancetype)instMethod; - (instancetype)instMethod;
@end @end
@class TestForwardClassDecl; @class TestForwardClassDecl;
// FIXME: @compatibility_alias AliasForTestPCH TestPCH; // FIXME: @compatibility_alias AliasForTestPCH TestPCH;
// http://llvm.org/PR12689 // https://llvm.org/PR12689
@interface PR12689 @interface PR12689
@end @end
@implementation PR12689 @implementation PR12689
-(void)mugi:(int)x { -(void)mugi:(int)x {
switch(x) { switch(x) {
case 23: {} case 23: {}
} }
Show All 21 Lines

clang/test/Parser/cxx2a-template-lambdas.cpp

// RUN: %clang_cc1 -std=c++2b %s -verify // RUN: %clang_cc1 -std=c++2b %s -verify
// RUN: %clang_cc1 -std=c++2a %s -verify // RUN: %clang_cc1 -std=c++2a %s -verify
auto L0 = []<> { }; //expected-error {{cannot be empty}} auto L0 = []<> { }; //expected-error {{cannot be empty}}
auto L1 = []<typename T1, typename T2> { }; auto L1 = []<typename T1, typename T2> { };
auto L2 = []<typename T1, typename T2>(T1 arg1, T2 arg2) -> T1 { }; auto L2 = []<typename T1, typename T2>(T1 arg1, T2 arg2) -> T1 { };
auto L3 = []<typename T>(auto arg) { T t; }; auto L3 = []<typename T>(auto arg) { T t; };
auto L4 = []<int I>() { }; auto L4 = []<int I>() { };
// http://llvm.org/PR49736 // https://llvm.org/PR49736
auto L5 = []<auto>(){}; auto L5 = []<auto>(){};
auto L6 = []<auto>{}; auto L6 = []<auto>{};
auto L7 = []<auto>() noexcept {}; auto L7 = []<auto>() noexcept {};
auto L8 = []<auto> noexcept {}; auto L8 = []<auto> noexcept {};
#if __cplusplus <= 202002L #if __cplusplus <= 202002L
// expected-warning@-2 {{lambda without a parameter clause is a C++2b extension}} // expected-warning@-2 {{lambda without a parameter clause is a C++2b extension}}
#endif #endif
auto L9 = []<auto> requires true {}; auto L9 = []<auto> requires true {};
Show All 15 Lines

clang/test/Parser/cxx2b-lambdas.cpp

Show All 28 Lines
auto XL3 = []( constexpr mutable constexpr {}; // expected-error{{invalid storage class specifier}} \ auto XL3 = []( constexpr mutable constexpr {}; // expected-error{{invalid storage class specifier}} \
// expected-error{{function parameter cannot be constexpr}} \ // expected-error{{function parameter cannot be constexpr}} \
// expected-error{{a type specifier is required}} \ // expected-error{{a type specifier is required}} \
// expected-error{{expected ')'}} \ // expected-error{{expected ')'}} \
// expected-note{{to match this '('}} \ // expected-note{{to match this '('}} \
// expected-error{{expected body}} \ // expected-error{{expected body}} \
// expected-warning{{duplicate 'constexpr'}} // expected-warning{{duplicate 'constexpr'}}
// http://llvm.org/PR49736 // https://llvm.org/PR49736
auto XL4 = [] requires true {}; // expected-error{{expected body}} auto XL4 = [] requires true {}; // expected-error{{expected body}}
auto XL5 = []<auto> requires true requires true {}; // expected-error{{expected body}} auto XL5 = []<auto> requires true requires true {}; // expected-error{{expected body}}
auto XL6 = []<auto> requires true noexcept requires true {}; // expected-error{{expected body}} auto XL6 = []<auto> requires true noexcept requires true {}; // expected-error{{expected body}}

clang/test/Preprocessor/pp-record.c

// RUN: %clang_cc1 -fsyntax-only -detailed-preprocessing-record %s // RUN: %clang_cc1 -fsyntax-only -detailed-preprocessing-record %s
// http://llvm.org/PR11120 // https://llvm.org/PR11120
#define STRINGIZE(text) STRINGIZE_I(text) #define STRINGIZE(text) STRINGIZE_I(text)
#define STRINGIZE_I(text) #text #define STRINGIZE_I(text) #text
#define INC pp-record.h #define INC pp-record.h
#include STRINGIZE(INC) #include STRINGIZE(INC)
Show All 23 Lines

clang/test/Preprocessor/traditional-cpp.c

Show First 20 Lines • Show All 81 Lines • ▼ Show 20 Lines
/* Comments are whitespace too */ /* Comments are whitespace too */
#endif #endif
/* CHECK-NOT: {{^}}a b c in skipped block{{$}} /* CHECK-NOT: {{^}}a b c in skipped block{{$}}
* CHECK-NOT: {{^}}/* Comments are whitespace too * CHECK-NOT: {{^}}/* Comments are whitespace too
*/ */
Preserve URLs: http://clang.llvm.org Preserve URLs: https://clang.llvm.org
/* CHECK: {{^}}Preserve URLs: http://clang.llvm.org{{$}} /* CHECK: {{^}}Preserve URLs: https://clang.llvm.org{{$}}
*/ */
/* The following tests ensure we ignore # and ## in macro bodies */ /* The following tests ensure we ignore # and ## in macro bodies */
#define FOO_NO_STRINGIFY(a) test(# a) #define FOO_NO_STRINGIFY(a) test(# a)
FOO_NO_STRINGIFY(foobar) FOO_NO_STRINGIFY(foobar)
/* CHECK: {{^}}test(# foobar){{$}} /* CHECK: {{^}}test(# foobar){{$}}
*/ */
Show All 10 Lines

clang/test/Sema/PR2923.c

// RUN: %clang_cc1 -fsyntax-only -verify %s // RUN: %clang_cc1 -fsyntax-only -verify %s
// expected-no-diagnostics // expected-no-diagnostics
// Test for absence of crash reported in PR 2923: // Test for absence of crash reported in PR 2923:
// //
// http://llvm.org/bugs/show_bug.cgi?id=2923 // https://llvm.org/bugs/show_bug.cgi?id=2923
// //
// Previously we had a crash when deallocating the FunctionDecl for 'bar' // Previously we had a crash when deallocating the FunctionDecl for 'bar'
// because FunctionDecl::getNumParams() just used the type of foo to determine // because FunctionDecl::getNumParams() just used the type of foo to determine
// the number of parameters it has. In the case of 'bar' there are no // the number of parameters it has. In the case of 'bar' there are no
// ParmVarDecls. // ParmVarDecls.
int foo(int x, int y) { return x + y; } int foo(int x, int y) { return x + y; }
extern typeof(foo) bar; extern typeof(foo) bar;

clang/test/Sema/types.c

Show First 20 Lines • Show All 55 Lines • ▼ Show 20 Lines
// rdar://6880951 // rdar://6880951
int __attribute__ ((vector_size (8), vector_size (8))) v; // expected-error {{invalid vector element type}} int __attribute__ ((vector_size (8), vector_size (8))) v; // expected-error {{invalid vector element type}}
void test(int i) { void test(int i) {
char c = (char __attribute__((aligned(8)))) i; // expected-warning {{'aligned' attribute ignored when parsing type}} char c = (char __attribute__((aligned(8)))) i; // expected-warning {{'aligned' attribute ignored when parsing type}}
} }
// http://llvm.org/PR11082 // https://llvm.org/PR11082
// //
// FIXME: This may or may not be the correct approach (no warning or error), // FIXME: This may or may not be the correct approach (no warning or error),
// but large amounts of Linux and FreeBSD code need this attribute to not be // but large amounts of Linux and FreeBSD code need this attribute to not be
// a hard error in order to work correctly. // a hard error in order to work correctly.
void test2(int i) { void test2(int i) {
char c = (char __attribute__((may_alias))) i; char c = (char __attribute__((may_alias))) i;
} }
Show All 26 Lines

clang/test/SemaCXX/compound-literal.cpp

// RUN: %clang_cc1 -fsyntax-only -std=c++03 -verify -ast-dump %s > %t-03 // RUN: %clang_cc1 -fsyntax-only -std=c++03 -verify -ast-dump %s > %t-03
// RUN: FileCheck --input-file=%t-03 %s // RUN: FileCheck --input-file=%t-03 %s
// RUN: %clang_cc1 -fsyntax-only -std=c++11 -verify -ast-dump %s > %t-11 // RUN: %clang_cc1 -fsyntax-only -std=c++11 -verify -ast-dump %s > %t-11
// RUN: FileCheck --input-file=%t-11 %s // RUN: FileCheck --input-file=%t-11 %s
// RUN: FileCheck --input-file=%t-11 %s --check-prefix=CHECK-CXX11 // RUN: FileCheck --input-file=%t-11 %s --check-prefix=CHECK-CXX11
// http://llvm.org/PR7905 // https://llvm.org/PR7905
namespace PR7905 { namespace PR7905 {
struct S; // expected-note {{forward declaration}} struct S; // expected-note {{forward declaration}}
void foo1() { void foo1() {
(void)(S[]) {{3}}; // expected-error {{array has incomplete element type}} (void)(S[]) {{3}}; // expected-error {{array has incomplete element type}}
} }
template <typename T> struct M { T m; }; template <typename T> struct M { T m; };
void foo2() { void foo2() {
▲ Show 20 Lines • Show All 95 Lines • Show Last 20 Lines

clang/test/SemaCXX/crashes.cpp

Show First 20 Lines • Show All 42 Lines • ▼ Show 20 Lines
struct { struct {
Y obj; Y obj;
} objs[] = { } objs[] = {
new Y // expected-error{{no viable conversion}} new Y // expected-error{{no viable conversion}}
}; };
} }
// http://llvm.org/PR8234 // https://llvm.org/PR8234
namespace PR8234 { namespace PR8234 {
template<typename Signature> template<typename Signature>
class callback class callback
{ {
}; };
template<typename R , typename ARG_TYPE0> template<typename R , typename ARG_TYPE0>
class callback<R( ARG_TYPE0)> class callback<R( ARG_TYPE0)>
▲ Show 20 Lines • Show All 175 Lines • ▼ Show 20 Linesnamespace pr16989 {
}; };
void C2::f() {} void C2::f() {}
} }
namespace pr20660 { namespace pr20660 {
appendList(int[]...); // expected-error {{a type specifier is required for all declarations}} appendList(int[]...); // expected-error {{a type specifier is required for all declarations}}
appendList(int[]...) { } // expected-error {{a type specifier is required for all declarations}} appendList(int[]...) { } // expected-error {{a type specifier is required for all declarations}}
} }

clang/test/SemaCXX/member-pointer-ms.cpp

// RUN: %clang_cc1 -std=c++11 -fms-compatibility -fsyntax-only -triple=i386-pc-win32 -verify -DVMB %s // RUN: %clang_cc1 -std=c++11 -fms-compatibility -fsyntax-only -triple=i386-pc-win32 -verify -DVMB %s
// RUN: %clang_cc1 -std=c++11 -fms-compatibility -fsyntax-only -triple=x86_64-pc-win32 -verify -DVMB %s // RUN: %clang_cc1 -std=c++11 -fms-compatibility -fsyntax-only -triple=x86_64-pc-win32 -verify -DVMB %s
// RUN: %clang_cc1 -std=c++11 -fms-compatibility -fsyntax-only -triple=x86_64-pc-win32 -verify -DVMV -fms-memptr-rep=virtual %s // RUN: %clang_cc1 -std=c++11 -fms-compatibility -fsyntax-only -triple=x86_64-pc-win32 -verify -DVMV -fms-memptr-rep=virtual %s
// //
// This file should also give no diagnostics when run through cl.exe from MSVS // This file should also give no diagnostics when run through cl.exe from MSVS
// 2012, which supports C++11 and static_assert. It should pass for both 64-bit // 2012, which supports C++11 and static_assert. It should pass for both 64-bit
// and 32-bit x86. // and 32-bit x86.
// //
// Test the size of various member pointer combinations: // Test the size of various member pointer combinations:
// - complete and incomplete // - complete and incomplete
// - single, multiple, and virtual inheritance (and unspecified for incomplete) // - single, multiple, and virtual inheritance (and unspecified for incomplete)
// - data and function pointers // - data and function pointers
// - templated with declared specializations with annotations // - templated with declared specializations with annotations
// - template that can be instantiated // - template that can be instantiated
// http://llvm.org/PR12070 // https://llvm.org/PR12070
struct Foo { struct Foo {
typedef int Foo::*FooInt; typedef int Foo::*FooInt;
int f; int f;
}; };
#ifdef VMB #ifdef VMB
enum { enum {
kSingleDataAlign = 1 * sizeof(int), kSingleDataAlign = 1 * sizeof(int),
▲ Show 20 Lines • Show All 277 Lines • Show Last 20 Lines

clang/test/SemaCXX/nested-name-spec.cpp

Show First 20 Lines • Show All 268 Lines • ▼ Show 20 Lines
namespace rdar7980179 { namespace rdar7980179 {
class A { void f0(); }; // expected-note {{previous}} class A { void f0(); }; // expected-note {{previous}}
int A::f0() {} // expected-error {{return type of out-of-line definition of 'rdar7980179::A::f0' differs}} int A::f0() {} // expected-error {{return type of out-of-line definition of 'rdar7980179::A::f0' differs}}
} }
namespace alias = A; namespace alias = A;
double *dp = (alias::C*)0; // expected-error{{cannot initialize a variable of type 'double *' with an rvalue of type 'alias::C *'}} double *dp = (alias::C*)0; // expected-error{{cannot initialize a variable of type 'double *' with an rvalue of type 'alias::C *'}}
// http://llvm.org/PR10109 // https://llvm.org/PR10109
namespace PR10109 { namespace PR10109 {
template<typename T> template<typename T>
struct A { struct A {
protected: protected:
struct B; struct B;
struct B::C; // expected-error {{requires a template parameter list}} \ struct B::C; // expected-error {{requires a template parameter list}} \
// expected-error {{no struct named 'C'}} \ // expected-error {{no struct named 'C'}} \
// expected-error{{non-friend class member 'C' cannot have a qualified name}} // expected-error{{non-friend class member 'C' cannot have a qualified name}}
▲ Show 20 Lines • Show All 190 Lines • Show Last 20 Lines

clang/test/SemaCXX/scope-check.cpp

Show First 20 Lines • Show All 178 Lines • ▼ Show 20 Lines case 2:
S s; S s;
if (y > 42) return x + y; if (y > 42) return x + y;
default: default:
return x - 2; return x - 2;
} }
} }
} }
// http://llvm.org/PR10462 // https://llvm.org/PR10462
namespace PR10462 { namespace PR10462 {
enum MyEnum { enum MyEnum {
something_valid, something_valid,
something_invalid something_invalid
}; };
bool recurse() { bool recurse() {
MyEnum K; MyEnum K;
▲ Show 20 Lines • Show All 452 Lines • Show Last 20 Lines

clang/test/SemaCXX/warn-shadow.cpp

Show First 20 Lines • Show All 53 Lines • ▼ Show 20 Lines A(int f1, int f2, int f3, int f4) // expected-note-re 4 {{variable 'f{{[0-4]}}' is declared here}}
--f3; // expected-warning {{modifying constructor parameter 'f3' that shadows a field of 'A'}} --f3; // expected-warning {{modifying constructor parameter 'f3' that shadows a field of 'A'}}
f4 += 2; // expected-warning {{modifying constructor parameter 'f4' that shadows a field of 'A'}} f4 += 2; // expected-warning {{modifying constructor parameter 'f4' that shadows a field of 'A'}}
} }
// The initialization is safe, but the modifications are not. // The initialization is safe, but the modifications are not.
// expected-warning-re@+1 4 {{constructor parameter 'f{{[0-4]}}' shadows the field 'f{{[0-9]}}' of 'A'}} // expected-warning-re@+1 4 {{constructor parameter 'f{{[0-4]}}' shadows the field 'f{{[0-9]}}' of 'A'}}
A(int f1, int f2, int f3, int f4, double overload_dummy) {} A(int f1, int f2, int f3, int f4, double overload_dummy) {}
void test() { void test() {
char *field; // expected-warning {{declaration shadows a field of 'A'}} char *field; // expected-warning {{declaration shadows a field of 'A'}}
char *data; // expected-warning {{declaration shadows a static data member of 'A'}} char *data; // expected-warning {{declaration shadows a static data member of 'A'}}
char *a1; // no warning char *a1; // no warning
char *a2; // no warning char *a2; // no warning
char *jj; // no warning char *jj; // no warning
char *jjj; // no warning char *jjj; // no warning
} }
void test2() { void test2() {
typedef char field; // no warning typedef char field; // no warning
typedef char data; // no warning typedef char data; // no warning
typedef char a1; // expected-warning {{declaration shadows a typedef in 'A'}} typedef char a1; // expected-warning {{declaration shadows a typedef in 'A'}}
typedef char a2; // expected-warning {{declaration shadows a type alias in 'A'}} typedef char a2; // expected-warning {{declaration shadows a type alias in 'A'}}
typedef char jj; // expected-warning {{declaration shadows a typedef in namespace 'one::two'}} typedef char jj; // expected-warning {{declaration shadows a typedef in namespace 'one::two'}}
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Linesvoid Foo::Baz1() {
typedef int Bar; // Don't warn. typedef int Bar; // Don't warn.
} }
void Foo::Baz2() { void Foo::Baz2() {
using Bar=int; // Don't warn. using Bar=int; // Don't warn.
} }
} }
// http://llvm.org/PR9160 // https://llvm.org/PR9160
namespace PR9160 { namespace PR9160 {
struct V { struct V {
V(int); V(int);
}; };
struct S { struct S {
V v; V v;
static void m() { static void m() {
if (1) { if (1) {
▲ Show 20 Lines • Show All 53 Lines • ▼ Show 20 Linesvoid avoidWarningWhenRedefining(int b) { // expected-note {{previous definition is here}}
int g; // expected-error {{redefinition of 'g'}} int g; // expected-error {{redefinition of 'g'}}
typedef int h; // expected-note {{previous definition is here}} typedef int h; // expected-note {{previous definition is here}}
int h; // expected-error {{redefinition of 'h'}} int h; // expected-error {{redefinition of 'h'}}
int k; // expected-note {{previous definition is here}} int k; // expected-note {{previous definition is here}}
typedef int k; // expected-error {{redefinition of 'k'}} typedef int k; // expected-error {{redefinition of 'k'}}
using l=char; // no warning or error. using l=char; // no warning or error.
using l=char; // no warning or error. using l=char; // no warning or error.
typedef char l; // no warning or error. typedef char l; // no warning or error.
typedef char n; // no warning or error. typedef char n; // no warning or error.
typedef char n; // no warning or error. typedef char n; // no warning or error.
using n=char; // no warning or error. using n=char; // no warning or error.
} }
} }
extern "C" { extern "C" {
typedef int externC; // expected-note {{previous declaration is here}} typedef int externC; // expected-note {{previous declaration is here}}
} }
void handleLinkageSpec() { void handleLinkageSpec() {
typedef void externC; // expected-warning {{declaration shadows a typedef in the global namespace}} typedef void externC; // expected-warning {{declaration shadows a typedef in the global namespace}}
} }
namespace PR33947 { namespace PR33947 {
void f(int a) { void f(int a) {
struct A { struct A {
void g(int a) {} void g(int a) {}
A() { int a; } A() { int a; }
}; };
} }
} }
namespace PR34120 { namespace PR34120 {
struct A { struct A {
int B; // expected-note 2 {{declared here}} int B; // expected-note 2 {{declared here}}
}; };
class C : public A { class C : public A {
void D(int B) {} // expected-warning {{parameter 'B' shadows member inherited from type 'A'}} void D(int B) {} // expected-warning {{parameter 'B' shadows member inherited from type 'A'}}
void E() { void E() {
extern void f(int B); // Ok extern void f(int B); // Ok
} }
void F(int B); // Ok, declaration; not definition. void F(int B); // Ok, declaration; not definition.
void G(int B); void G(int B);
}; };
void C::G(int B) { // expected-warning {{parameter 'B' shadows member inherited from type 'A'}} void C::G(int B) { // expected-warning {{parameter 'B' shadows member inherited from type 'A'}}
} }
class Private { class Private {
int B; int B;
}; };
class Derived : Private { class Derived : Private {
void D(int B) {} // Ok void D(int B) {} // Ok
}; };
struct Static { struct Static {
static int B; static int B;
}; };
struct Derived2 : Static { struct Derived2 : Static {
void D(int B) {} void D(int B) {}
}; };
} }
int PR24718; int PR24718;
enum class X { PR24718 }; // Ok, not shadowing enum class X { PR24718 }; // Ok, not shadowing
struct PR24718_1; struct PR24718_1;
struct PR24718_2 { struct PR24718_2 {
enum { enum {
PR24718_1 // Does not shadow a type. PR24718_1 // Does not shadow a type.
Show All 34 Linesvoid test4() {
{ {
int a = 4; // expected-warning {{declaration shadows a structured binding}} int a = 4; // expected-warning {{declaration shadows a structured binding}}
} }
{ {
const auto [a, b] = S(); // expected-warning 2 {{declaration shadows a structured binding}} const auto [a, b] = S(); // expected-warning 2 {{declaration shadows a structured binding}}
} }
} }
}; // namespace structured_binding_tests }; // namespace structured_binding_tests
No newline at end of file

clang/test/SemaObjC/comptypes-9.m

// RUN: %clang_cc1 -fsyntax-only %s // RUN: %clang_cc1 -fsyntax-only %s
// FIXME: This test case tests the patch applied in: http://lists.llvm.org/pipermail/cfe-commits/Week-of-Mon-20080602/006017.html // FIXME: This test case tests the patch applied in: https://lists.llvm.org/pipermail/cfe-commits/Week-of-Mon-20080602/006017.html
// Eventually that logic should be treated as an extension. // Eventually that logic should be treated as an extension.
typedef signed char BOOL; typedef signed char BOOL;
typedef int NSInteger; typedef int NSInteger;
typedef unsigned int NSUInteger; typedef unsigned int NSUInteger;
typedef struct _NSZone NSZone; typedef struct _NSZone NSZone;
@class NSInvocation, NSMethodSignature, NSCoder, NSString, NSEnumerator; @class NSInvocation, NSMethodSignature, NSCoder, NSString, NSEnumerator;
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

clang/tools/clang-check/ClangCheck.cpp

//===--- tools/clang-check/ClangCheck.cpp - Clang check tool --------------===// //===--- tools/clang-check/ClangCheck.cpp - Clang check tool --------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements a clang-check tool that runs clang based on the info // This file implements a clang-check tool that runs clang based on the info
// stored in a compilation database. // stored in a compilation database.
// //
// This tool uses the Clang Tooling infrastructure, see // This tool uses the Clang Tooling infrastructure, see
// http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html // https://clang.llvm.org/docs/HowToSetupToolingForLLVM.html
// for details on setting it up with LLVM source tree. // for details on setting it up with LLVM source tree.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "clang/AST/ASTConsumer.h" #include "clang/AST/ASTConsumer.h"
#include "clang/CodeGen/ObjectFilePCHContainerOperations.h" #include "clang/CodeGen/ObjectFilePCHContainerOperations.h"
#include "clang/Driver/Options.h" #include "clang/Driver/Options.h"
#include "clang/Frontend/ASTConsumers.h" #include "clang/Frontend/ASTConsumers.h"
▲ Show 20 Lines • Show All 236 Lines • Show Last 20 Lines

clang/tools/clang-format-vs/ClangFormat/ClangFormatPackage.cs

Show First 20 Lines • Show All 92 Lines • ▼ Show 20 Lines public class OptionPageGrid : DialogPage
" configuration file.\n" + " configuration file.\n" +
" - A YAML configuration snippet.\n\n" + " - A YAML configuration snippet.\n\n" +
"'File':\n" + "'File':\n" +
" Searches for a .clang-format or _clang-format configuration file\n" + " Searches for a .clang-format or _clang-format configuration file\n" +
" in the source file's directory and its parents.\n\n" + " in the source file's directory and its parents.\n\n" +
"YAML configuration snippet:\n" + "YAML configuration snippet:\n" +
" The content of a .clang-format configuration file, as string.\n" + " The content of a .clang-format configuration file, as string.\n" +
" Example: '{BasedOnStyle: \"LLVM\", IndentWidth: 8}'\n\n" + " Example: '{BasedOnStyle: \"LLVM\", IndentWidth: 8}'\n\n" +
"See also: http://clang.llvm.org/docs/ClangFormatStyleOptions.html.")] "See also: https://clang.llvm.org/docs/ClangFormatStyleOptions.html.")]
[TypeConverter(typeof(StyleConverter))] [TypeConverter(typeof(StyleConverter))]
public string Style public string Style
{ {
get { return style; } get { return style; }
set { style = value; } set { style = value; }
} }
public sealed class FilenameConverter : TypeConverter public sealed class FilenameConverter : TypeConverter
▲ Show 20 Lines • Show All 53 Lines • ▼ Show 20 Lines public class OptionPageGrid : DialogPage
{ {
get { return fallbackStyle; } get { return fallbackStyle; }
set { fallbackStyle = value; } set { fallbackStyle = value; }
} }
[Category("Format Options")] [Category("Format Options")]
[DisplayName("Sort includes")] [DisplayName("Sort includes")]
[Description("Sort touched include lines.\n\n" + [Description("Sort touched include lines.\n\n" +
"See also: http://clang.llvm.org/docs/ClangFormat.html.")] "See also: https://clang.llvm.org/docs/ClangFormat.html.")]
public bool SortIncludes public bool SortIncludes
{ {
get { return sortIncludes; } get { return sortIncludes; }
set { sortIncludes = value; } set { sortIncludes = value; }
} }
[Category("Format On Save")] [Category("Format On Save")]
[DisplayName("Enable")] [DisplayName("Enable")]
▲ Show 20 Lines • Show All 285 Lines • Show Last 20 Lines

clang/tools/clang-format-vs/source.extension.vsixmanifest.in

<?xml version="1.0" encoding="utf-8"?> <?xml version="1.0" encoding="utf-8"?>
<PackageManifest Version="2.0.0" xmlns="http://schemas.microsoft.com/developer/vsx-schema/2011" xmlns:d="http://schemas.microsoft.com/developer/vsx-schema-design/2011"> <PackageManifest Version="2.0.0" xmlns="http://schemas.microsoft.com/developer/vsx-schema/2011" xmlns:d="http://schemas.microsoft.com/developer/vsx-schema-design/2011">
<Metadata> <Metadata>
<Identity Id="3cb18a5e-97e9-11e7-abc4-cec278b6b50a" Version="@CLANG_FORMAT_VS_VERSION@" Language="en-US" Publisher="LLVM"/> <Identity Id="3cb18a5e-97e9-11e7-abc4-cec278b6b50a" Version="@CLANG_FORMAT_VS_VERSION@" Language="en-US" Publisher="LLVM"/>
<DisplayName>ClangFormat</DisplayName> <DisplayName>ClangFormat</DisplayName>
<Description xml:space="preserve">A tool to format C/C++/Obj-C code.</Description> <Description xml:space="preserve">A tool to format C/C++/Obj-C code.</Description>
<MoreInfo>http://clang.llvm.org/docs/ClangFormat.html</MoreInfo> <MoreInfo>https://clang.llvm.org/docs/ClangFormat.html</MoreInfo>
<License>license.txt</License> <License>license.txt</License>
</Metadata> </Metadata>
<Installation InstalledByMsi="false"> <Installation InstalledByMsi="false">
<InstallationTarget Id="Microsoft.VisualStudio.Pro" Version="[11.0, 17.0)" /> <InstallationTarget Id="Microsoft.VisualStudio.Pro" Version="[11.0, 17.0)" />
</Installation> </Installation>
<Dependencies> <Dependencies>
<Dependency Id="Microsoft.VisualStudio.MPF" MinVersion="11.0" DisplayName="Visual Studio MPF" /> <Dependency Id="Microsoft.VisualStudio.MPF" MinVersion="11.0" DisplayName="Visual Studio MPF" />
</Dependencies> </Dependencies>
<Prerequisites> <Prerequisites>
<Prerequisite Id="Microsoft.VisualStudio.Component.CoreEditor" Version="[11.0,)" DisplayName="Visual Studio core editor" /> <Prerequisite Id="Microsoft.VisualStudio.Component.CoreEditor" Version="[11.0,)" DisplayName="Visual Studio core editor" />
</Prerequisites> </Prerequisites>
</PackageManifest> </PackageManifest>

clang/tools/clang-format/clang-format.el

;;; clang-format.el --- Format code using clang-format -*- lexical-binding: t; -*- ;;; clang-format.el --- Format code using clang-format -*- lexical-binding: t; -*-
;; Keywords: tools, c ;; Keywords: tools, c
;; Package-Requires: ((cl-lib "0.3")) ;; Package-Requires: ((cl-lib "0.3"))
;; SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception ;; SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
;;; Commentary: ;;; Commentary:
;; This package allows to filter code through clang-format to fix its formatting. ;; This package allows to filter code through clang-format to fix its formatting.
;; clang-format is a tool that formats C/C++/Obj-C code according to a set of ;; clang-format is a tool that formats C/C++/Obj-C code according to a set of
;; style options, see <http://clang.llvm.org/docs/ClangFormatStyleOptions.html>. ;; style options, see <https://clang.llvm.org/docs/ClangFormatStyleOptions.html>.
;; Note that clang-format 3.4 or newer is required. ;; Note that clang-format 3.4 or newer is required.
;; clang-format.el is available via MELPA and can be installed via ;; clang-format.el is available via MELPA and can be installed via
;; ;;
;; M-x package-install clang-format ;; M-x package-install clang-format
;; ;;
;; when ("melpa" . "http://melpa.org/packages/") is included in ;; when ("melpa" . "http://melpa.org/packages/") is included in
;; `package-archives'. Alternatively, ensure the directory of this ;; `package-archives'. Alternatively, ensure the directory of this
▲ Show 20 Lines • Show All 201 Lines • Show Last 20 Lines

clang/tools/clang-fuzzer/Dockerfile

Show All 12 LinesRUN apt-get install -y autoconf automake libtool curl make g++ unzip wget git \
pkg-config docbook2x pkg-config docbook2x
WORKDIR /root WORKDIR /root
# Get protobuf # Get protobuf
RUN wget -qO- https://github.com/google/protobuf/releases/download/v3.3.0/protobuf-cpp-3.3.0.tar.gz | tar zxf - RUN wget -qO- https://github.com/google/protobuf/releases/download/v3.3.0/protobuf-cpp-3.3.0.tar.gz | tar zxf -
RUN cd protobuf-3.3.0 && ./autogen.sh && ./configure && make -j $(nproc) && make check -j $(nproc) && make install && ldconfig RUN cd protobuf-3.3.0 && ./autogen.sh && ./configure && make -j $(nproc) && make check -j $(nproc) && make install && ldconfig
# Get LLVM # Get LLVM
RUN svn co http://llvm.org/svn/llvm-project/llvm/trunk llvm RUN svn co https://llvm.org/svn/llvm-project/llvm/trunk llvm
RUN cd llvm/tools && svn co http://llvm.org/svn/llvm-project/cfe/trunk clang -r $(cd ../ && svn info | grep Revision | awk '{print $2}') RUN cd llvm/tools && svn co https://llvm.org/svn/llvm-project/cfe/trunk clang -r $(cd ../ && svn info | grep Revision | awk '{print $2}')
RUN cd llvm/projects && svn co http://llvm.org/svn/llvm-project/compiler-rt/trunk compiler-rt -r $(cd ../ && svn info | grep Revision | awk '{print $2}') RUN cd llvm/projects && svn co https://llvm.org/svn/llvm-project/compiler-rt/trunk compiler-rt -r $(cd ../ && svn info | grep Revision | awk '{print $2}')
# Build plain LLVM (stage 0) # Build plain LLVM (stage 0)
RUN mkdir build0 && cd build0 && cmake -GNinja -DCMAKE_BUILD_TYPE=Release ../llvm && ninja RUN mkdir build0 && cd build0 && cmake -GNinja -DCMAKE_BUILD_TYPE=Release ../llvm && ninja
# Configure instrumented LLVM (stage 1) # Configure instrumented LLVM (stage 1)
RUN mkdir build1 && cd build1 && cmake -GNinja -DCMAKE_BUILD_TYPE=Release ../llvm \ RUN mkdir build1 && cd build1 && cmake -GNinja -DCMAKE_BUILD_TYPE=Release ../llvm \
-DLLVM_ENABLE_ASSERTIONS=ON \ -DLLVM_ENABLE_ASSERTIONS=ON \
-DCMAKE_C_COMPILER=`pwd`/../build0/bin/clang \ -DCMAKE_C_COMPILER=`pwd`/../build0/bin/clang \
-DCMAKE_CXX_COMPILER=`pwd`/../build0/bin/clang++ \ -DCMAKE_CXX_COMPILER=`pwd`/../build0/bin/clang++ \
-DLLVM_USE_SANITIZE_COVERAGE=YES \ -DLLVM_USE_SANITIZE_COVERAGE=YES \
Show All 10 Lines

clang/tools/scan-build-py/README.md

Show First 20 Lines • Show All 135 Lines • ▼ Show 20 Lines
License License
------- -------
The project is licensed under Apache-2.0 with LLVM exceptions. The project is licensed under Apache-2.0 with LLVM exceptions.
See LICENSE.TXT for details. See LICENSE.TXT for details.
[1]: http://clang.llvm.org/docs/JSONCompilationDatabase.html [1]: https://clang.llvm.org/docs/JSONCompilationDatabase.html
[2]: https://pypi.python.org/pypi/scan-build [2]: https://pypi.python.org/pypi/scan-build
[3]: https://llvm.org/bugs/enter_bug.cgi?product=clang [3]: https://llvm.org/bugs/enter_bug.cgi?product=clang

clang/tools/scan-build/bin/scan-build

Show First 20 Lines • Show All 100 Lines • ▼ Show 20 Linessub ErrorDiag {
} }
} }
sub DiagCrashes { sub DiagCrashes {
my $Dir = shift; my $Dir = shift;
Diag ("The analyzer encountered problems on some source files.\n"); Diag ("The analyzer encountered problems on some source files.\n");
Diag ("Preprocessed versions of these sources were deposited in '$Dir/failures'.\n"); Diag ("Preprocessed versions of these sources were deposited in '$Dir/failures'.\n");
Diag ("Please consider submitting a bug report using these files:\n"); Diag ("Please consider submitting a bug report using these files:\n");
Diag (" http://clang-analyzer.llvm.org/filing_bugs.html\n") Diag (" https://clang-analyzer.llvm.org/filing_bugs.html\n")
} }
sub DieDiag { sub DieDiag {
if ($UseColor) { if ($UseColor) {
print STDERR BOLD, RED "$Prog: "; print STDERR BOLD, RED "$Prog: ";
print STDERR RESET, RED @_; print STDERR RESET, RED @_;
print STDERR RESET; print STDERR RESET;
} }
▲ Show 20 Lines • Show All 760 Lines • ▼ Show 20 Lines if (scalar @failures) {
if (defined $prefix) { $srcfile =~ s/^\Q$prefix//; } if (defined $prefix) { $srcfile =~ s/^\Q$prefix//; }
print OUT "<tr><td>$problem</td><td>$srcfile</td><td><a href=\"failures/$ppfile\">$ppfile</a></td><td><a href=\"failures/$ppfile.stderr.txt\">$ppfile.stderr.txt</a></td></tr>\n"; print OUT "<tr><td>$problem</td><td>$srcfile</td><td><a href=\"failures/$ppfile\">$ppfile</a></td><td><a href=\"failures/$ppfile.stderr.txt\">$ppfile.stderr.txt</a></td></tr>\n";
my $ppfile_clang = $ppfile; my $ppfile_clang = $ppfile;
$ppfile_clang =~ s/[.](.+)$/.clang.$1/; $ppfile_clang =~ s/[.](.+)$/.clang.$1/;
print OUT " <!-- REPORTPROBLEM src=\"$srcfile\" file=\"failures/$ppfile\" clangfile=\"failures/$ppfile_clang\" stderr=\"failures/$ppfile.stderr.txt\" info=\"failures/$ppfile.info.txt\" -->\n"; print OUT " <!-- REPORTPROBLEM src=\"$srcfile\" file=\"failures/$ppfile\" clangfile=\"failures/$ppfile_clang\" stderr=\"failures/$ppfile.stderr.txt\" info=\"failures/$ppfile.info.txt\" -->\n";
} }
print OUT "</table>\n"; print OUT "</table>\n";
} }
print OUT "<p>Please consider submitting preprocessed files as <a href=\"http://clang-analyzer.llvm.org/filing_bugs.html\">bug reports</a>. <!-- REPORTCRASHES --> </p>\n"; print OUT "<p>Please consider submitting preprocessed files as <a href=\"https://clang-analyzer.llvm.org/filing_bugs.html\">bug reports</a>. <!-- REPORTCRASHES --> </p>\n";
} }
print OUT "</body></html>\n"; print OUT "</body></html>\n";
close(OUT); close(OUT);
CopyFiles($Dir); CopyFiles($Dir);
# Make sure $Dir and $BaseDir are world readable/executable. # Make sure $Dir and $BaseDir are world readable/executable.
chmod(0755, $Dir); chmod(0755, $Dir);
▲ Show 20 Lines • Show All 1,079 Lines • Show Last 20 Lines

clang/unittests/Format/FormatTest.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 17,594 Lines • ▼ Show 20 Lines verifyFormat("struct test {\n"
"};\n", "};\n",
Alignment); Alignment);
verifyFormat("struct test {\n" verifyFormat("struct test {\n"
" long long int foo();\n" " long long int foo();\n"
" int operator()(int a);\n" " int operator()(int a);\n"
" double bar();\n" " double bar();\n"
"};\n", "};\n",
Alignment); Alignment);
// http://llvm.org/PR52914 // https://llvm.org/PR52914
verifyFormat("char *a[] = {\"a\", // comment\n" verifyFormat("char *a[] = {\"a\", // comment\n"
" \"bb\"};\n" " \"bb\"};\n"
"int bbbbbbb = 0;", "int bbbbbbb = 0;",
Alignment); Alignment);
// PAS_Right // PAS_Right
EXPECT_EQ("void SomeFunction(int parameter = 0) {\n" EXPECT_EQ("void SomeFunction(int parameter = 0) {\n"
" int const i = 1;\n" " int const i = 1;\n"
▲ Show 20 Lines • Show All 8,674 Lines • Show Last 20 Lines

clang/unittests/Format/TokenAnnotatorTest.cpp

Show First 20 Lines • Show All 477 Lines • ▼ Show 20 Lines Tokens = annotate("template <typename T>\n"
"};"); "};");
ASSERT_EQ(Tokens.size(), 43u) << Tokens; ASSERT_EQ(Tokens.size(), 43u) << Tokens;
EXPECT_TOKEN(Tokens[8], tok::kw_requires, TT_RequiresExpression); EXPECT_TOKEN(Tokens[8], tok::kw_requires, TT_RequiresExpression);
EXPECT_TOKEN(Tokens[9], tok::l_paren, TT_RequiresExpressionLParen); EXPECT_TOKEN(Tokens[9], tok::l_paren, TT_RequiresExpressionLParen);
EXPECT_TOKEN(Tokens[13], tok::l_brace, TT_RequiresExpressionLBrace); EXPECT_TOKEN(Tokens[13], tok::l_brace, TT_RequiresExpressionLBrace);
EXPECT_TOKEN(Tokens[29], tok::kw_requires, EXPECT_TOKEN(Tokens[29], tok::kw_requires,
TT_RequiresClauseInARequiresExpression); TT_RequiresClauseInARequiresExpression);
// Invalid Code, but we don't want to crash. See http://llvm.org/PR54350. // Invalid Code, but we don't want to crash. See https://llvm.org/PR54350.
Tokens = annotate("bool r10 = requires (struct new_struct { int x; } s) { " Tokens = annotate("bool r10 = requires (struct new_struct { int x; } s) { "
"requires true; };"); "requires true; };");
ASSERT_EQ(Tokens.size(), 21u) << Tokens; ASSERT_EQ(Tokens.size(), 21u) << Tokens;
EXPECT_TOKEN(Tokens[3], tok::kw_requires, TT_RequiresExpression); EXPECT_TOKEN(Tokens[3], tok::kw_requires, TT_RequiresExpression);
EXPECT_TOKEN(Tokens[4], tok::l_paren, TT_RequiresExpressionLParen); EXPECT_TOKEN(Tokens[4], tok::l_paren, TT_RequiresExpressionLParen);
EXPECT_TOKEN(Tokens[14], tok::l_brace, TT_RequiresExpressionLBrace); EXPECT_TOKEN(Tokens[14], tok::l_brace, TT_RequiresExpressionLBrace);
} }
▲ Show 20 Lines • Show All 285 Lines • Show Last 20 Lines

clang/utils/FindSpecRefs

Show First 20 Lines • Show All 883 Lines • ▼ Show 20 Lines for i,node in enumerate(refTree[1]):
relativePath = relativePath[1:] relativePath = relativePath[1:]
# XXX this is broken, how does doxygen mangle w/ multiple # XXX this is broken, how does doxygen mangle w/ multiple
# refs? Can we just read its map? # refs? Can we just read its map?
filename = os.path.basename(relativePath) filename = os.path.basename(relativePath)
doxyName = '%s-source.html'%(filename.replace('.','_8'),) doxyName = '%s-source.html'%(filename.replace('.','_8'),)
# Grrr, why can't doxygen write line number references. # Grrr, why can't doxygen write line number references.
lineReference = findClosestLineReference(root,doxyName,item.line) lineReference = findClosestLineReference(root,doxyName,item.line)
if lineReference is not None: if lineReference is not None:
linkStr = 'http://clang.llvm.org/doxygen/%s#%s'%(doxyName,lineReference) linkStr = 'https://clang.llvm.org/doxygen/%s#%s'%(doxyName,lineReference)
else: else:
linkStr = 'http://clang.llvm.org/doxygen/%s'%(doxyName,) linkStr = 'https://clang.llvm.org/doxygen/%s'%(doxyName,)
if item.section.paragraph is not None: if item.section.paragraph is not None:
paraText = '&nbsp;(p%d)'%(item.section.paragraph,) paraText = '&nbsp;(p%d)'%(item.section.paragraph,)
else: else:
paraText = '' paraText = ''
print >>f,'<a href="%s">%s:%d</a>%s<br>'%(linkStr,relativePath,item.line,paraText) print >>f,'<a href="%s">%s:%d</a>%s<br>'%(linkStr,relativePath,item.line,paraText)
print >>f, '\t\t</td>' print >>f, '\t\t</td>'
print >>f, '\t</tr>' print >>f, '\t</tr>'
print >>f, '</table>' print >>f, '</table>'
print >>f, '<hr>' print >>f, '<hr>'
print >>f, 'Generated: %s<br>'%(time.strftime('%Y-%m-%d %H:%M'),) print >>f, 'Generated: %s<br>'%(time.strftime('%Y-%m-%d %H:%M'),)
print >>f, 'SVN Revision: %s'%(getRevision(root),) print >>f, 'SVN Revision: %s'%(getRevision(root),)
print >>f, '</body>' print >>f, '</body>'
f.close() f.close()
if __name__=='__main__': if __name__=='__main__':
main() main()

clang/www/analyzer/menu.html.incl

<table width="100%" id="nav" cellspacing=0 cellpadding=0> <table width="100%" id="nav" cellspacing=0 cellpadding=0>
<tr><td> <tr><td>
<ul style="margin:0; padding:0" class="menubar"> <ul style="margin:0; padding:0" class="menubar">
<li style="padding-left:5em"> <li style="padding-left:5em">
<a href="/index.html">About</a> <a href="/index.html">About</a>
<ul class="menubar"> <ul class="menubar">
<li><a href="/index.html">About the Analyzer</a></li> <li><a href="/index.html">About the Analyzer</a></li>
<li><a href="http://llvm.org/">LLVM Project</a></li> <li><a href="https://llvm.org/">LLVM Project</a></li>
<li><a href="http://clang.llvm.org/">Clang Project</a></li> <li><a href="https://clang.llvm.org/">Clang Project</a></li>
</ul> </ul>
</li> </li>
<li> <li>
<a href="/filing_bugs.html">Filing Bugs</a> <a href="/filing_bugs.html">Filing Bugs</a>
</li> </li>
<li> <li>
User Manual User Manual
<ul> <ul>
Show All 12 Lines <ul>
<li><a href="/open_projects.html">Open Projects</a></li> <li><a href="/open_projects.html">Open Projects</a></li>
<li><a href="/potential_checkers.html">Potential Future Checkers</a></li> <li><a href="/potential_checkers.html">Potential Future Checkers</a></li>
</ul> </ul>
</li> </li>
<li> <li>
Mailing List & Forums Mailing List & Forums
<ul> <ul>
<li><a href="https://discourse.llvm.org/c/clang">Clang Frontend Forums</a></li> <li><a href="https://discourse.llvm.org/c/clang">Clang Frontend Forums</a></li>
<li><a href="http://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a></li> <li><a href="https://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a></li>
</ul> </ul>
</li> </li>
</ul> </ul>
</td></tr> </td></tr>
</table> </table>

clang/www/demo/index.cgi

Show First 20 Lines • Show All 118 Lines • ▼ Show 20 Lines
print <<EOF; print <<EOF;
<html> <html>
<head> <head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1"> <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<title>Try out LLVM in your browser!</title> <title>Try out LLVM in your browser!</title>
<style> <style>
\@import url("syntax.css"); \@import url("syntax.css");
\@import url("http://llvm.org/llvm.css"); \@import url("https://llvm.org/llvm.css");
</style> </style>
</head> </head>
<body leftmargin="10" marginwidth="10"> <body leftmargin="10" marginwidth="10">
<div class="www_sectiontitle"> <div class="www_sectiontitle">
Try out LLVM in your browser! Try out LLVM in your browser!
</div> </div>
▲ Show 20 Lines • Show All 327 Lines • Show Last 20 Lines

clang/www/demo/what is this directory.txt

This is for the LLVM+Clang browser based demo. This is for the LLVM+Clang browser based demo.
It is supposed to work like the LLVM+GCC demo here: http://llvm.org/demo/ but for the BSD licensed Clang instead. It is supposed to work like the LLVM+GCC demo here: https://llvm.org/demo/ but for the BSD licensed Clang instead.
Perhaps it could also be used for getting crash information and details on errors.... I'm not sure if this would require some major changes or not to report this info. Maybe also adding ways that people can use it to test for errors and a way to report such errors would also be good. Perhaps it could also be used for getting crash information and details on errors.... I'm not sure if this would require some major changes or not to report this info. Maybe also adding ways that people can use it to test for errors and a way to report such errors would also be good.
Status: Status:
Anyways, right now, these file a basically just a copy of the LLVM+GCC demo (no changes have been made). The files don't even work right in this location on the server. As such, someone will need to edit the file or rewrite it. Anyways, right now, these file a basically just a copy of the LLVM+GCC demo (no changes have been made). The files don't even work right in this location on the server. As such, someone will need to edit the file or rewrite it.
If nobody in the LLVM community has the skills, one suggestion would be to post a request on a friendly Perl forum and see if anybody might be interested in taking on the challenge. If nobody in the LLVM community has the skills, one suggestion would be to post a request on a friendly Perl forum and see if anybody might be interested in taking on the challenge.
Alternatively, you could try a PHP, Python, Ruby, or Lisp mailing list and see if there are any takers who would be interested (and willing to do a rewrite to their language of choice). Alternatively, you could try a PHP, Python, Ruby, or Lisp mailing list and see if there are any takers who would be interested (and willing to do a rewrite to their language of choice).
-- --
BTW, once this feature was working, my intention was to link to it from the index.html page in the section entitled: BTW, once this feature was working, my intention was to link to it from the index.html page in the section entitled:
Try Clang Try Clang
No newline at end of file

clang/www/menu.html.incl

<div id="menu"> <div id="menu">
<div> <div>
<a href="http://llvm.org/">LLVM Home</a> <a href="https://llvm.org/">LLVM Home</a>
</div> </div>
<div class="submenu"> <div class="submenu">
<label>Clang Info</label> <label>Clang Info</label>
<a href="http://llvm.org/releases/download.html">Download</a> <a href="https://llvm.org/releases/download.html">Download</a>
<a href="/index.html">About</a> <a href="/index.html">About</a>
<a href="/features.html">Features</a> <a href="/features.html">Features</a>
<a href="/related.html">Related Projects</a> <a href="/related.html">Related Projects</a>
<a href="/docs/UsersManual.html">User's Manual</a> <a href="/docs/UsersManual.html">User's Manual</a>
<a href="/compatibility.html">Language&nbsp;Compatibility</a> <a href="/compatibility.html">Language&nbsp;Compatibility</a>
<a href="/docs/LanguageExtensions.html">Language&nbsp;Extensions</a> <a href="/docs/LanguageExtensions.html">Language&nbsp;Extensions</a>
<a href="/c_status.html">C Status</a> <a href="/c_status.html">C Status</a>
<a href="/cxx_status.html">C++ Status</a> <a href="/cxx_status.html">C++ Status</a>
</div> </div>
<div class="submenu"> <div class="submenu">
<label>Clang Development</label> <label>Clang Development</label>
<a href="/get_started.html">Get&nbsp;Started</a> <a href="/get_started.html">Get&nbsp;Started</a>
<a href="/get_involved.html">Get&nbsp;Involved</a> <a href="/get_involved.html">Get&nbsp;Involved</a>
<a href="/OpenProjects.html">Open&nbsp;Projects</a> <a href="/OpenProjects.html">Open&nbsp;Projects</a>
<a href="/docs/InternalsManual.html">Clang&nbsp;Internals</a> <a href="/docs/InternalsManual.html">Clang&nbsp;Internals</a>
<a href="/hacking.html">Hacking on Clang</a> <a href="/hacking.html">Hacking on Clang</a>
</div> </div>
<div class="submenu"> <div class="submenu">
<label>Clang Tools</label> <label>Clang Tools</label>
<a href="http://clang-analyzer.llvm.org">Automatic Bug-Finding</a> <a href="https://clang-analyzer.llvm.org">Automatic Bug-Finding</a>
<a href="/docs/Tooling.html">Writing Clang Tools</a> <a href="/docs/Tooling.html">Writing Clang Tools</a>
</div> </div>
<div class="submenu"> <div class="submenu">
<label>Communication</label> <label>Communication</label>
<a href="https://discourse.llvm.org/c/clang">Clang Forum</a> <a href="https://discourse.llvm.org/c/clang">Clang Forum</a>
<a href="http://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits List</a> <a href="https://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits List</a>
<a href="https://github.com/llvm/llvm-project/issues">Bug Reports</a> <a href="https://github.com/llvm/llvm-project/issues">Bug Reports</a>
<a href="http://planet.clang.org/">Planet Clang</a> <a href="http://planet.clang.org/">Planet Clang</a>
<a href="irc://irc.oftc.net/llvm">IRC: irc.oftc.net#llvm</a> <a href="irc://irc.oftc.net/llvm">IRC: irc.oftc.net#llvm</a>
</div> </div>
<div class="submenu"> <div class="submenu">
<label>The Code</label> <label>The Code</label>
<a href="/get_started.html#build">Check Out Sources</a> <a href="/get_started.html#build">Check Out Sources</a>
<a href="https://github.com/llvm/llvm-project/tree/main/clang/">Browse Sources</a> <a href="https://github.com/llvm/llvm-project/tree/main/clang/">Browse Sources</a>
<a href="http://clang.llvm.org/doxygen/">doxygen</a> <a href="https://clang.llvm.org/doxygen/">doxygen</a>
</div> </div>
<div class="submenu"> <div class="submenu">
<label>Quick Links</label> <label>Quick Links</label>
<a href="http://llvm.org/reports/coverage/">Testing Coverage</a> <a href="https://llvm.org/reports/coverage/">Testing Coverage</a>
</div> </div>
<div class="submenu"> <div class="submenu">
<label>Clang Events</label> <label>Clang Events</label>
<a href="http://llvm.org/devmtg/">LLVM Meeting</a> <a href="https://llvm.org/devmtg/">LLVM Meeting</a>
</div> </div>
</div> </div>

compiler-rt/cmake/Modules/CompilerRTCompile.cmake

Show First 20 Lines • Show All 127 Lines • ▼ Show 20 Lines set(CMD
" then echo 'e.g. with:'" " then echo 'e.g. with:'"
" echo ' cp -r' $(dirname $(dirname $(xcrun -f clang)))/include/c++ '${LLVM_BINARY_DIR}/include/'" " echo ' cp -r' $(dirname $(dirname $(xcrun -f clang)))/include/c++ '${LLVM_BINARY_DIR}/include/'"
" elif [ -d $(dirname $(dirname $(xcrun -f clang)))/lib/c++ ]" " elif [ -d $(dirname $(dirname $(xcrun -f clang)))/lib/c++ ]"
" then echo 'e.g. with:'" " then echo 'e.g. with:'"
" echo ' cp -r' $(dirname $(dirname $(xcrun -f clang)))/lib/c++ '${LLVM_BINARY_DIR}/include/'" " echo ' cp -r' $(dirname $(dirname $(xcrun -f clang)))/lib/c++ '${LLVM_BINARY_DIR}/include/'"
" fi" " fi"
" echo 'This can also be fixed by checking out the libcxx project from llvm.org and installing the headers'" " echo 'This can also be fixed by checking out the libcxx project from llvm.org and installing the headers'"
" echo 'into your build directory:'" " echo 'into your build directory:'"
" echo ' cd ${LLVM_MAIN_SRC_DIR}/projects && svn co http://llvm.org/svn/llvm-project/libcxx/trunk libcxx'" " echo ' cd ${LLVM_MAIN_SRC_DIR}/projects && svn co https://llvm.org/svn/llvm-project/libcxx/trunk libcxx'"
" echo ' cd ${LLVM_BINARY_DIR} && make -C ${LLVM_MAIN_SRC_DIR}/projects/libcxx installheaders HEADER_DIR=${LLVM_BINARY_DIR}/include'" " echo ' cd ${LLVM_BINARY_DIR} && make -C ${LLVM_MAIN_SRC_DIR}/projects/libcxx installheaders HEADER_DIR=${LLVM_BINARY_DIR}/include'"
" echo" " echo"
" false" " false"
"fi" "fi"
) )
add_custom_target(CompilerRTUnitTestCheckCxx add_custom_target(CompilerRTUnitTestCheckCxx
COMMAND bash -c "${CMD}" COMMAND bash -c "${CMD}"
COMMENT "Checking that just-built clang can find C++ headers..." COMMENT "Checking that just-built clang can find C++ headers..."
VERBATIM) VERBATIM)
if (NOT COMPILER_RT_STANDALONE_BUILD AND NOT LLVM_RUNTIMES_BUILD) if (NOT COMPILER_RT_STANDALONE_BUILD AND NOT LLVM_RUNTIMES_BUILD)
ADD_DEPENDENCIES(CompilerRTUnitTestCheckCxx clang) ADD_DEPENDENCIES(CompilerRTUnitTestCheckCxx clang)
endif() endif()
endif() endif()
endmacro() endmacro()

compiler-rt/lib/asan/asan_interceptors_memintrinsics.h

Show First 20 Lines • Show All 71 Lines • ▼ Show 20 Lines if (!QuickCheckForUnpoisonedRegion(__offset, __size) && \
GET_CURRENT_PC_BP_SP; \ GET_CURRENT_PC_BP_SP; \
ReportGenericError(pc, bp, sp, __bad, isWrite, __size, 0, false);\ ReportGenericError(pc, bp, sp, __bad, isWrite, __size, 0, false);\
} \ } \
} \ } \
} while (0) } while (0)
// memcpy is called during __asan_init() from the internals of printf(...). // memcpy is called during __asan_init() from the internals of printf(...).
// We do not treat memcpy with to==from as a bug. // We do not treat memcpy with to==from as a bug.
// See http://llvm.org/bugs/show_bug.cgi?id=11763. // See https://llvm.org/bugs/show_bug.cgi?id=11763.
#define ASAN_MEMCPY_IMPL(ctx, to, from, size) \ #define ASAN_MEMCPY_IMPL(ctx, to, from, size) \
do { \ do { \
if (UNLIKELY(!asan_inited)) return internal_memcpy(to, from, size); \ if (UNLIKELY(!asan_inited)) return internal_memcpy(to, from, size); \
if (asan_init_is_running) { \ if (asan_init_is_running) { \
return REAL(memcpy)(to, from, size); \ return REAL(memcpy)(to, from, size); \
} \ } \
ENSURE_ASAN_INITED(); \ ENSURE_ASAN_INITED(); \
if (flags()->replace_intrin) { \ if (flags()->replace_intrin) { \
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

compiler-rt/lib/asan/tests/asan_exceptions_test.cpp

// See http://llvm.org/bugs/show_bug.cgi?id=11468 // See https://llvm.org/bugs/show_bug.cgi?id=11468
#include <stdio.h> #include <stdio.h>
#include <string> #include <string>
class Action { class Action {
public: public:
Action() {} Action() {}
void PrintString(const std::string& msg) const { void PrintString(const std::string& msg) const {
fprintf(stderr, "%s\n", msg.c_str()); fprintf(stderr, "%s\n", msg.c_str());
Show All 18 Lines

compiler-rt/lib/asan/tests/asan_str_test.cpp

Show First 20 Lines • Show All 497 Lines • ▼ Show 20 Lines#if PLATFORM_HAS_DIFFERENT_MEMCPY_AND_MEMMOVE
Ident(memcpy)(str + 1, str + 11, 10); Ident(memcpy)(str + 1, str + 11, 10);
Ident(memcpy)(str, str, 0); Ident(memcpy)(str, str, 0);
EXPECT_DEATH(Ident(memcpy)(str, str + 14, 15), OverlapErrorMessage("memcpy")); EXPECT_DEATH(Ident(memcpy)(str, str + 14, 15), OverlapErrorMessage("memcpy"));
EXPECT_DEATH(Ident(memcpy)(str + 14, str, 15), OverlapErrorMessage("memcpy")); EXPECT_DEATH(Ident(memcpy)(str + 14, str, 15), OverlapErrorMessage("memcpy"));
#endif #endif
#endif #endif
// We do not treat memcpy with to==from as a bug. // We do not treat memcpy with to==from as a bug.
// See http://llvm.org/bugs/show_bug.cgi?id=11763. // See https://llvm.org/bugs/show_bug.cgi?id=11763.
// EXPECT_DEATH(Ident(memcpy)(str + 20, str + 20, 1), // EXPECT_DEATH(Ident(memcpy)(str + 20, str + 20, 1),
// OverlapErrorMessage("memcpy")); // OverlapErrorMessage("memcpy"));
// Check "strcpy". // Check "strcpy".
memset(str, 'z', size); memset(str, 'z', size);
str[9] = '\0'; str[9] = '\0';
strcpy(str + 10, str); strcpy(str + 10, str);
EXPECT_DEATH(strcpy(str + 9, str), OverlapErrorMessage("strcpy")); EXPECT_DEATH(strcpy(str + 9, str), OverlapErrorMessage("strcpy"));
▲ Show 20 Lines • Show All 118 Lines • Show Last 20 Lines

compiler-rt/lib/asan/tests/asan_test.cpp

//===-- asan_test.cpp -----------------------------------------------------===// //===-- asan_test.cpp -----------------------------------------------------===//
Lint: Lint
Inline Actions

clang-format suggested style edits found:

Lint: Lint: clang-format suggested style edits found:
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file is a part of AddressSanitizer, an address sanity checker. // This file is a part of AddressSanitizer, an address sanity checker.
▲ Show 20 Lines • Show All 1,158 Lines • ▼ Show 20 Lines#endif
EXPECT_EQ(0, munlock((void*)0x987, 0x654)); EXPECT_EQ(0, munlock((void*)0x987, 0x654));
} }
#endif #endif
struct LargeStruct { struct LargeStruct {
int foo[100]; int foo[100];
}; };
// Test for bug http://llvm.org/bugs/show_bug.cgi?id=11763. // Test for bug https://llvm.org/bugs/show_bug.cgi?id=11763.
// Struct copy should not cause asan warning even if lhs == rhs. // Struct copy should not cause asan warning even if lhs == rhs.
TEST(AddressSanitizer, LargeStructCopyTest) { TEST(AddressSanitizer, LargeStructCopyTest) {
LargeStruct a; LargeStruct a;
*Ident(&a) = *Ident(&a); *Ident(&a) = *Ident(&a);
} }
ATTRIBUTE_NO_SANITIZE_ADDRESS ATTRIBUTE_NO_SANITIZE_ADDRESS
static void NoSanitizeAddress() { static void NoSanitizeAddress() {
▲ Show 20 Lines • Show All 124 Lines • ▼ Show 20 LinesTEST(AddressSanitizer, BufferOverflowAfterManyFrees) {
EXPECT_DEATH(x[Ident(8192)] = 0, "AddressSanitizer: heap-buffer-overflow"); EXPECT_DEATH(x[Ident(8192)] = 0, "AddressSanitizer: heap-buffer-overflow");
delete [] Ident(x); delete [] Ident(x);
} }
#endif #endif
// Test that instrumentation of stack allocations takes into account // Test that instrumentation of stack allocations takes into account
// AllocSize of a type, and not its StoreSize (16 vs 10 bytes for long double). // AllocSize of a type, and not its StoreSize (16 vs 10 bytes for long double).
// See http://llvm.org/bugs/show_bug.cgi?id=12047 for more details. // See https://llvm.org/bugs/show_bug.cgi?id=12047 for more details.
TEST(AddressSanitizer, LongDoubleNegativeTest) { TEST(AddressSanitizer, LongDoubleNegativeTest) {
long double a, b; long double a, b;
static long double c; static long double c;
memcpy(Ident(&a), Ident(&b), sizeof(long double)); memcpy(Ident(&a), Ident(&b), sizeof(long double));
memcpy(Ident(&c), Ident(&b), sizeof(long double)); memcpy(Ident(&c), Ident(&b), sizeof(long double));
} }
#if !defined(_WIN32) #if !defined(_WIN32)
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

compiler-rt/lib/fuzzer/README.txt

See http://llvm.org/docs/LibFuzzer.html See https://llvm.org/docs/LibFuzzer.html

compiler-rt/lib/memprof/memprof_interceptors_memintrinsics.h

Show All 28 Lines
// relevant information only. // relevant information only.
#define ACCESS_MEMORY_RANGE(offset, size) \ #define ACCESS_MEMORY_RANGE(offset, size) \
do { \ do { \
__memprof_record_access_range(offset, size); \ __memprof_record_access_range(offset, size); \
} while (0) } while (0)
// memcpy is called during __memprof_init() from the internals of printf(...). // memcpy is called during __memprof_init() from the internals of printf(...).
// We do not treat memcpy with to==from as a bug. // We do not treat memcpy with to==from as a bug.
// See http://llvm.org/bugs/show_bug.cgi?id=11763. // See https://llvm.org/bugs/show_bug.cgi?id=11763.
#define MEMPROF_MEMCPY_IMPL(to, from, size) \ #define MEMPROF_MEMCPY_IMPL(to, from, size) \
do { \ do { \
if (UNLIKELY(!memprof_inited)) \ if (UNLIKELY(!memprof_inited)) \
return internal_memcpy(to, from, size); \ return internal_memcpy(to, from, size); \
if (memprof_init_is_running) { \ if (memprof_init_is_running) { \
return REAL(memcpy)(to, from, size); \ return REAL(memcpy)(to, from, size); \
} \ } \
ENSURE_MEMPROF_INITED(); \ ENSURE_MEMPROF_INITED(); \
Show All 34 Lines

compiler-rt/lib/sanitizer_common/sanitizer_atomic_clang.h

Show All 19 Lines
# include "sanitizer_atomic_clang_other.h" # include "sanitizer_atomic_clang_other.h"
#endif #endif
namespace __sanitizer { namespace __sanitizer {
// We would like to just use compiler builtin atomic operations // We would like to just use compiler builtin atomic operations
// for loads and stores, but they are mostly broken in clang: // for loads and stores, but they are mostly broken in clang:
// - they lead to vastly inefficient code generation // - they lead to vastly inefficient code generation
// (http://llvm.org/bugs/show_bug.cgi?id=17281) // (https://llvm.org/bugs/show_bug.cgi?id=17281)
// - 64-bit atomic operations are not implemented on x86_32 // - 64-bit atomic operations are not implemented on x86_32
// (http://llvm.org/bugs/show_bug.cgi?id=15034) // (https://llvm.org/bugs/show_bug.cgi?id=15034)
// - they are not implemented on ARM // - they are not implemented on ARM
// error: undefined reference to '__atomic_load_4' // error: undefined reference to '__atomic_load_4'
// See http://www.cl.cam.ac.uk/~pes20/cpp/cpp0xmappings.html // See http://www.cl.cam.ac.uk/~pes20/cpp/cpp0xmappings.html
// for mappings of the memory model to different processors. // for mappings of the memory model to different processors.
inline void atomic_signal_fence(memory_order) { inline void atomic_signal_fence(memory_order) {
__asm__ __volatile__("" ::: "memory"); __asm__ __volatile__("" ::: "memory");
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

compiler-rt/lib/sanitizer_common/tests/sanitizer_atomic_test.cpp

Show First 20 Lines • Show All 100 Lines • ▼ Show 20 Lines CheckStoreLoad<atomic_uintptr_t, memory_order_acquire, memory_order_relaxed>
(); ();
CheckStoreLoad<atomic_uintptr_t, memory_order_relaxed, memory_order_release> CheckStoreLoad<atomic_uintptr_t, memory_order_relaxed, memory_order_release>
(); ();
CheckStoreLoad<atomic_uintptr_t, memory_order_seq_cst, memory_order_seq_cst> CheckStoreLoad<atomic_uintptr_t, memory_order_seq_cst, memory_order_seq_cst>
(); ();
} }
// Clang crashes while compiling this test for Android: // Clang crashes while compiling this test for Android:
// http://llvm.org/bugs/show_bug.cgi?id=15587 // https://llvm.org/bugs/show_bug.cgi?id=15587
#if !SANITIZER_ANDROID #if !SANITIZER_ANDROID
template<typename T> template<typename T>
void CheckAtomicCompareExchange() { void CheckAtomicCompareExchange() {
typedef typename T::Type Type; typedef typename T::Type Type;
{ {
Type old_val = 42; Type old_val = 42;
Type new_val = 24; Type new_val = 24;
Type var = old_val; Type var = old_val;
Show All 30 Lines

compiler-rt/lib/tsan/rtl-old/tsan_rtl_report.cpp

Show First 20 Lines • Show All 949 Lines • ▼ Show 20 Linesvoid PrintCurrentStack(ThreadState *thr, uptr pc) {
PrintStack(SymbolizeStack(trace)); PrintStack(SymbolizeStack(trace));
} }
// Always inlining PrintCurrentStackSlow, because LocatePcInTrace assumes // Always inlining PrintCurrentStackSlow, because LocatePcInTrace assumes
// __sanitizer_print_stack_trace exists in the actual unwinded stack, but // __sanitizer_print_stack_trace exists in the actual unwinded stack, but
// tail-call to PrintCurrentStackSlow breaks this assumption because // tail-call to PrintCurrentStackSlow breaks this assumption because
// __sanitizer_print_stack_trace disappears after tail-call. // __sanitizer_print_stack_trace disappears after tail-call.
// However, this solution is not reliable enough, please see dvyukov's comment // However, this solution is not reliable enough, please see dvyukov's comment
// http://reviews.llvm.org/D19148#406208 // https://reviews.llvm.org/D19148#406208
// Also see PR27280 comment 2 and 3 for breaking examples and analysis. // Also see PR27280 comment 2 and 3 for breaking examples and analysis.
ALWAYS_INLINE USED void PrintCurrentStackSlow(uptr pc) { ALWAYS_INLINE USED void PrintCurrentStackSlow(uptr pc) {
#if !SANITIZER_GO #if !SANITIZER_GO
uptr bp = GET_CURRENT_FRAME(); uptr bp = GET_CURRENT_FRAME();
auto *ptrace = New<BufferedStackTrace>(); auto *ptrace = New<BufferedStackTrace>();
ptrace->Unwind(pc, bp, nullptr, false); ptrace->Unwind(pc, bp, nullptr, false);
for (uptr i = 0; i < ptrace->size / 2; i++) { for (uptr i = 0; i < ptrace->size / 2; i++) {
Show All 18 Lines

compiler-rt/lib/tsan/rtl-old/tsan_suppressions.cpp

//===-- tsan_suppressions.cpp ---------------------------------------------===// //===-- tsan_suppressions.cpp ---------------------------------------------===//
Lint: Lint
Inline Actions

clang-format suggested style edits found:

Lint: Lint: clang-format suggested style edits found:
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file is a part of ThreadSanitizer (TSan), a race detector. // This file is a part of ThreadSanitizer (TSan), a race detector.
Show All 14 Lines
// Suppressions for true/false positives in standard libraries. // Suppressions for true/false positives in standard libraries.
static const char *const std_suppressions = static const char *const std_suppressions =
// Libstdc++ 4.4 has data races in std::string. // Libstdc++ 4.4 has data races in std::string.
// See http://crbug.com/181502 for an example. // See http://crbug.com/181502 for an example.
"race:^_M_rep$\n" "race:^_M_rep$\n"
"race:^_M_is_leaked$\n" "race:^_M_is_leaked$\n"
// False positive when using std <thread>. // False positive when using std <thread>.
// Happens because we miss atomic synchronization in libstdc++. // Happens because we miss atomic synchronization in libstdc++.
// See http://llvm.org/bugs/show_bug.cgi?id=17066 for details. // See https://llvm.org/bugs/show_bug.cgi?id=17066 for details.
"race:std::_Sp_counted_ptr_inplace<std::thread::_Impl\n"; "race:std::_Sp_counted_ptr_inplace<std::thread::_Impl\n";
// Can be overriden in frontend. // Can be overriden in frontend.
SANITIZER_WEAK_DEFAULT_IMPL SANITIZER_WEAK_DEFAULT_IMPL
const char *__tsan_default_suppressions() { const char *__tsan_default_suppressions() {
return 0; return 0;
} }
#endif #endif
▲ Show 20 Lines • Show All 121 Lines • Show Last 20 Lines

compiler-rt/lib/tsan/rtl/tsan_rtl_report.cpp

Show First 20 Lines • Show All 848 Lines • ▼ Show 20 Linesvoid PrintCurrentStack(ThreadState *thr, uptr pc) {
PrintStack(SymbolizeStack(trace)); PrintStack(SymbolizeStack(trace));
} }
// Always inlining PrintCurrentStackSlow, because LocatePcInTrace assumes // Always inlining PrintCurrentStackSlow, because LocatePcInTrace assumes
// __sanitizer_print_stack_trace exists in the actual unwinded stack, but // __sanitizer_print_stack_trace exists in the actual unwinded stack, but
// tail-call to PrintCurrentStackSlow breaks this assumption because // tail-call to PrintCurrentStackSlow breaks this assumption because
// __sanitizer_print_stack_trace disappears after tail-call. // __sanitizer_print_stack_trace disappears after tail-call.
// However, this solution is not reliable enough, please see dvyukov's comment // However, this solution is not reliable enough, please see dvyukov's comment
// http://reviews.llvm.org/D19148#406208 // https://reviews.llvm.org/D19148#406208
// Also see PR27280 comment 2 and 3 for breaking examples and analysis. // Also see PR27280 comment 2 and 3 for breaking examples and analysis.
ALWAYS_INLINE USED void PrintCurrentStackSlow(uptr pc) { ALWAYS_INLINE USED void PrintCurrentStackSlow(uptr pc) {
#if !SANITIZER_GO #if !SANITIZER_GO
uptr bp = GET_CURRENT_FRAME(); uptr bp = GET_CURRENT_FRAME();
auto *ptrace = New<BufferedStackTrace>(); auto *ptrace = New<BufferedStackTrace>();
ptrace->Unwind(pc, bp, nullptr, false); ptrace->Unwind(pc, bp, nullptr, false);
for (uptr i = 0; i < ptrace->size / 2; i++) { for (uptr i = 0; i < ptrace->size / 2; i++) {
Show All 18 Lines

compiler-rt/lib/tsan/rtl/tsan_suppressions.cpp

//===-- tsan_suppressions.cpp ---------------------------------------------===// //===-- tsan_suppressions.cpp ---------------------------------------------===//
Lint: Lint
Inline Actions

clang-format suggested style edits found:

Lint: Lint: clang-format suggested style edits found:
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file is a part of ThreadSanitizer (TSan), a race detector. // This file is a part of ThreadSanitizer (TSan), a race detector.
Show All 14 Lines
// Suppressions for true/false positives in standard libraries. // Suppressions for true/false positives in standard libraries.
static const char *const std_suppressions = static const char *const std_suppressions =
// Libstdc++ 4.4 has data races in std::string. // Libstdc++ 4.4 has data races in std::string.
// See http://crbug.com/181502 for an example. // See http://crbug.com/181502 for an example.
"race:^_M_rep$\n" "race:^_M_rep$\n"
"race:^_M_is_leaked$\n" "race:^_M_is_leaked$\n"
// False positive when using std <thread>. // False positive when using std <thread>.
// Happens because we miss atomic synchronization in libstdc++. // Happens because we miss atomic synchronization in libstdc++.
// See http://llvm.org/bugs/show_bug.cgi?id=17066 for details. // See https://llvm.org/bugs/show_bug.cgi?id=17066 for details.
"race:std::_Sp_counted_ptr_inplace<std::thread::_Impl\n"; "race:std::_Sp_counted_ptr_inplace<std::thread::_Impl\n";
// Can be overriden in frontend. // Can be overriden in frontend.
SANITIZER_WEAK_DEFAULT_IMPL SANITIZER_WEAK_DEFAULT_IMPL
const char *__tsan_default_suppressions() { const char *__tsan_default_suppressions() {
return 0; return 0;
} }
#endif #endif
▲ Show 20 Lines • Show All 121 Lines • Show Last 20 Lines

compiler-rt/test/asan/TestCases/vla_chrome_testcase.cpp

// RUN: %clangxx_asan -O0 -mllvm -asan-instrument-dynamic-allocas %s -o %t // RUN: %clangxx_asan -O0 -mllvm -asan-instrument-dynamic-allocas %s -o %t
// RUN: not %run %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
// //
// This is reduced testcase based on Chromium code. // This is reduced testcase based on Chromium code.
// See http://reviews.llvm.org/D6055?vs=on&id=15616&whitespace=ignore-all#toc. // See https://reviews.llvm.org/D6055?vs=on&id=15616&whitespace=ignore-all#toc.
#include <stdint.h> #include <stdint.h>
#include <assert.h> #include <assert.h>
int a = 7; int a = 7;
int b; int b;
int c; int c;
int *p; int *p;
Show All 16 Lines

compiler-rt/test/cfi/CMakeLists.txt

Show All 33 Lines
if(APPLE) if(APPLE)
darwin_filter_host_archs(CFI_SUPPORTED_ARCH CFI_TEST_ARCH) darwin_filter_host_archs(CFI_SUPPORTED_ARCH CFI_TEST_ARCH)
endif() endif()
foreach(arch ${CFI_TEST_ARCH}) foreach(arch ${CFI_TEST_ARCH})
set(CFI_TEST_TARGET_ARCH ${arch}) set(CFI_TEST_TARGET_ARCH ${arch})
get_test_cc_for_arch(${arch} CFI_TEST_TARGET_CC CFI_TEST_TARGET_CFLAGS) get_test_cc_for_arch(${arch} CFI_TEST_TARGET_CC CFI_TEST_TARGET_CFLAGS)
if (APPLE) if (APPLE)
# FIXME: enable ThinLTO tests after fixing http://llvm.org/pr32741 # FIXME: enable ThinLTO tests after fixing https://llvm.org/pr32741
add_cfi_test_suites(False False False) add_cfi_test_suites(False False False)
elseif(WIN32) elseif(WIN32)
add_cfi_test_suites(True False) add_cfi_test_suites(True False)
add_cfi_test_suites(True True) add_cfi_test_suites(True True)
else() else()
add_cfi_test_suites(False False) add_cfi_test_suites(False False)
add_cfi_test_suites(False True) add_cfi_test_suites(False True)
if (COMPILER_RT_HAS_LLD AND NOT arch STREQUAL "i386") if (COMPILER_RT_HAS_LLD AND NOT arch STREQUAL "i386")
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

compiler-rt/test/lsan/TestCases/leak_check_before_thread_started.cpp

// Regression test for http://llvm.org/bugs/show_bug.cgi?id=21621 // Regression test for https://llvm.org/bugs/show_bug.cgi?id=21621
// This test relies on timing between threads, so any failures will be flaky. // This test relies on timing between threads, so any failures will be flaky.
// RUN: %clangxx_lsan %s -o %t // RUN: %clangxx_lsan %s -o %t
// RUN: %env_lsan_opts="log_pointers=1:log_threads=1" %run %t // RUN: %env_lsan_opts="log_pointers=1:log_threads=1" %run %t
#include <assert.h> #include <assert.h>
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
Show All 31 Lines

compiler-rt/test/sanitizer_common/TestCases/Linux/clock_gettime.c

// RUN: %clang %s -Wl,-as-needed -o %t && %run %t // RUN: %clang %s -Wl,-as-needed -o %t && %run %t
// Regression test for PR15823 // Regression test for PR15823
// (http://llvm.org/bugs/show_bug.cgi?id=15823). // (https://llvm.org/bugs/show_bug.cgi?id=15823).
#include <stdio.h> #include <stdio.h>
#include <time.h> #include <time.h>
int main() { int main() {
struct timespec ts; struct timespec ts;
clock_gettime(CLOCK_REALTIME, &ts); clock_gettime(CLOCK_REALTIME, &ts);
return 0; return 0;
} }

compiler-rt/www/menu.html.incl

<div id="menu"> <div id="menu">
<div> <div>
<a href="http://llvm.org/">LLVM Home</a> <a href="https://llvm.org/">LLVM Home</a>
</div> </div>
<div class="submenu"> <div class="submenu">
<label>compiler-rt Info</label> <label>compiler-rt Info</label>
<a href="/index.html">About</a> <a href="/index.html">About</a>
</div> </div>
<div class="submenu"> <div class="submenu">
<label>Quick Links</label> <label>Quick Links</label>
<a href="https://discourse.llvm.org">LLVM Forum</a> <a href="https://discourse.llvm.org">LLVM Forum</a>
<a href="http://lists.llvm.org/mailman/listinfo/llvm-commits">llvm-commits</a> <a href="https://lists.llvm.org/mailman/listinfo/llvm-commits">llvm-commits</a>
<a href="http://llvm.org/bugs/">Bug Reports</a> <a href="https://llvm.org/bugs/">Bug Reports</a>
<a href="https://github.com/llvm/llvm-project/tree/main/compiler-rt/">Browse Sources</a> <a href="https://github.com/llvm/llvm-project/tree/main/compiler-rt/">Browse Sources</a>
</div> </div>
</div> </div>

flang/docs/GettingInvolved.md

Show All 17 Lines
## Forum and Mailing Lists ## Forum and Mailing Lists
[Forum](https://discourse.llvm.org/c/subprojects/flang) [Forum](https://discourse.llvm.org/c/subprojects/flang)
Flang forums are for technical discussions, questions about writing code for, or using Flang tools. Flang forums are for technical discussions, questions about writing code for, or using Flang tools.
[Commits Archive (flang-commits)](http://lists.llvm.org/pipermail/flang-commits) [Commits Archive (flang-commits)](https://lists.llvm.org/pipermail/flang-commits)
This list contains all commit messages that are made when Flang developers This list contains all commit messages that are made when Flang developers
commit code changes to the repository. It also serves as a forum for commit code changes to the repository. It also serves as a forum for
patch review (i.e. send patches here). It is useful for those who want to patch review (i.e. send patches here). It is useful for those who want to
stay on the bleeding edge of Flang development. This list is high stay on the bleeding edge of Flang development. This list is high
volume. volume.
## Chat ## Chat
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

libclc/generic/lib/integer/rotate.inc

/** /**
* Not necessarily optimal... but it produces correct results (at least for int) * Not necessarily optimal... but it produces correct results (at least for int)
* If we're lucky, LLVM will recognize the pattern and produce rotate * If we're lucky, LLVM will recognize the pattern and produce rotate
* instructions: * instructions:
* http://llvm.1065342.n5.nabble.com/rotate-td47679.html * https://llvm.1065342.n5.nabble.com/rotate-td47679.html
* *
* Eventually, someone should feel free to implement an llvm-specific version * Eventually, someone should feel free to implement an llvm-specific version
*/ */
_CLC_OVERLOAD _CLC_DEF __CLC_GENTYPE rotate(__CLC_GENTYPE x, __CLC_GENTYPE n){ _CLC_OVERLOAD _CLC_DEF __CLC_GENTYPE rotate(__CLC_GENTYPE x, __CLC_GENTYPE n){
//Try to avoid extra work if someone's spinning the value through multiple //Try to avoid extra work if someone's spinning the value through multiple
//full rotations //full rotations
n = n % (__CLC_GENTYPE)__CLC_GENSIZE; n = n % (__CLC_GENTYPE)__CLC_GENSIZE;
Show All 29 Lines

libcxx/appveyor-reqs-install.cmd

Show First 20 Lines • Show All 42 Lines • ▼ Show 20 Linesif NOT EXIST ninja (
rm ninja.zip rm ninja.zip
) )
@set PATH=C:\projects\deps\ninja;%PATH% @set PATH=C:\projects\deps\ninja;%PATH%
ninja --version ninja --version
::########################################################################### ::###########################################################################
:: Setup the cached copy of LLVM :: Setup the cached copy of LLVM
::########################################################################### ::###########################################################################
git clone --depth=1 http://llvm.org/git/llvm.git git clone --depth=1 https://llvm.org/git/llvm.git
@echo off @echo off

libcxx/docs/BuildingLibcxx.rst

Show First 20 Lines • Show All 166 Lines • ▼ Show 20 Lines
As this build configuration ends up depending on a couple other DLLs that As this build configuration ends up depending on a couple other DLLs that
aren't available in path while running tests, copy them into the same aren't available in path while running tests, copy them into the same
directory as the tested libc++ DLL. directory as the tested libc++ DLL.
(Building a libc++ that depends on libstdc++ isn't necessarily a config one (Building a libc++ that depends on libstdc++ isn't necessarily a config one
would want to deploy, but it simplifies the config for testing purposes.) would want to deploy, but it simplifies the config for testing purposes.)
.. _`libc++abi`: http://libcxxabi.llvm.org/ .. _`libc++abi`: https://libcxxabi.llvm.org/
.. _CMake Options: .. _CMake Options:
CMake Options CMake Options
============= =============
Here are some of the CMake variables that are used often, along with a Here are some of the CMake variables that are used often, along with a
▲ Show 20 Lines • Show All 397 Lines • Show Last 20 Lines

libcxx/docs/DesignDocs/VisibilityMacros.rst

Show First 20 Lines • Show All 207 Lines • ▼ Show 20 Lines**_LIBCPP_ALWAYS_INLINE**
this macro is used to make sure that an externally visible symbol is never this macro is used to make sure that an externally visible symbol is never
generated in an object file when the `internal_linkage` attribute is not generated in an object file when the `internal_linkage` attribute is not
available. This is an internal macro used by other visibility macros, and available. This is an internal macro used by other visibility macros, and
it should not be used directly. it should not be used directly.
Links Links
===== =====
* `[cfe-dev] Visibility in libc++ - 1 <http://lists.llvm.org/pipermail/cfe-dev/2013-July/030610.html>`_ * `[cfe-dev] Visibility in libc++ - 1 <https://lists.llvm.org/pipermail/cfe-dev/2013-July/030610.html>`_
* `[cfe-dev] Visibility in libc++ - 2 <http://lists.llvm.org/pipermail/cfe-dev/2013-August/031195.html>`_ * `[cfe-dev] Visibility in libc++ - 2 <https://lists.llvm.org/pipermail/cfe-dev/2013-August/031195.html>`_
* `[libcxx] Visibility fixes for Windows <http://lists.llvm.org/pipermail/cfe-commits/Week-of-Mon-20130805/085461.html>`_ * `[libcxx] Visibility fixes for Windows <https://lists.llvm.org/pipermail/cfe-commits/Week-of-Mon-20130805/085461.html>`_

libcxx/docs/index.rst

Show First 20 Lines • Show All 180 Lines • ▼ Show 20 Lines.. toctree::
DesignDocs/UnspecifiedBehaviorRandomization DesignDocs/UnspecifiedBehaviorRandomization
DesignDocs/VisibilityMacros DesignDocs/VisibilityMacros
Build Bots and Test Coverage Build Bots and Test Coverage
============================ ============================
* `Buildkite CI pipeline <https://buildkite.com/llvm-project/libcxx-ci>`_ * `Buildkite CI pipeline <https://buildkite.com/llvm-project/libcxx-ci>`_
* `LLVM Buildbot Builders <http://lab.llvm.org:8011>`_ * `LLVM Buildbot Builders <https://lab.llvm.org:8011>`_
* :ref:`Adding New CI Jobs <AddingNewCIJobs>` * :ref:`Adding New CI Jobs <AddingNewCIJobs>`
Getting Involved Getting Involved
================ ================
First please review our `Developer's Policy <https://llvm.org/docs/DeveloperPolicy.html>`__ First please review our `Developer's Policy <https://llvm.org/docs/DeveloperPolicy.html>`__
and `Getting started with LLVM <https://llvm.org/docs/GettingStarted.html>`__. and `Getting started with LLVM <https://llvm.org/docs/GettingStarted.html>`__.
Show All 13 Lines
**Discussion and Questions** **Discussion and Questions**
Send discussions and questions to the `libcxx forum`_. Send discussions and questions to the `libcxx forum`_.
Quick Links Quick Links
=========== ===========
* `LLVM Homepage <https://llvm.org/>`_ * `LLVM Homepage <https://llvm.org/>`_
* `libc++abi Homepage <http://libcxxabi.llvm.org/>`_ * `libc++abi Homepage <https://libcxxabi.llvm.org/>`_
* `LLVM Bug Tracker <https://github.com/llvm/llvm-project/labels/libc++/>`_ * `LLVM Bug Tracker <https://github.com/llvm/llvm-project/labels/libc++/>`_
* `libcxx-commits Mailing List <http://lists.llvm.org/mailman/listinfo/libcxx-commits>`_ * `libcxx-commits Mailing List <https://lists.llvm.org/mailman/listinfo/libcxx-commits>`_
* `libcxx Forum <https://discourse.llvm.org/c/runtimes/libcxx/>`_ * `libcxx Forum <https://discourse.llvm.org/c/runtimes/libcxx/>`_
* `Browse libc++ Sources <https://github.com/llvm/llvm-project/tree/main/libcxx/>`_ * `Browse libc++ Sources <https://github.com/llvm/llvm-project/tree/main/libcxx/>`_

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.create_directory/create_directory.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// This test requires the dylib support introduced in http://llvm.org/D92769. // This test requires the dylib support introduced in https://llvm.org/D92769.
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.15|11.0}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.15|11.0}}
// <filesystem> // <filesystem>
// bool create_directory(const path& p); // bool create_directory(const path& p);
// bool create_directory(const path& p, error_code& ec) noexcept; // bool create_directory(const path& p, error_code& ec) noexcept;
// bool create_directory(const path& p, const path& attr); // bool create_directory(const path& p, const path& attr);
// bool create_directory(const path& p, const path& attr, error_code& ec) noexcept; // bool create_directory(const path& p, const path& attr, error_code& ec) noexcept;
▲ Show 20 Lines • Show All 118 Lines • Show Last 20 Lines

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.create_directory/create_directory_with_attributes.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// This test requires the dylib support introduced in http://llvm.org/D92769. // This test requires the dylib support introduced in https://llvm.org/D92769.
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.15|11.0}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.15|11.0}}
// <filesystem> // <filesystem>
// bool create_directory(const path& p, const path& attr); // bool create_directory(const path& p, const path& attr);
// bool create_directory(const path& p, const path& attr, error_code& ec) noexcept; // bool create_directory(const path& p, const path& attr, error_code& ec) noexcept;
#include "filesystem_include.h" #include "filesystem_include.h"
▲ Show 20 Lines • Show All 155 Lines • Show Last 20 Lines

libcxx/test/std/strings/basic.string/string.capacity/over_max_size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: no-exceptions // UNSUPPORTED: no-exceptions
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}} // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
// Prior to http://llvm.org/D123580, there was a bug with how the max_size() // Prior to https://llvm.org/D123580, there was a bug with how the max_size()
// was calculated. That was inlined into some functions in the dylib, which leads // was calculated. That was inlined into some functions in the dylib, which leads
// to failures when running this test against an older system dylib. // to failures when running this test against an older system dylib.
// XFAIL: use_system_cxx_lib && target=arm64-apple-macosx{{11.0|12.0}} // XFAIL: use_system_cxx_lib && target=arm64-apple-macosx{{11.0|12.0}}
// <string> // <string>
// size_type max_size() const; // constexpr since C++20 // size_type max_size() const; // constexpr since C++20
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

libcxxabi/fuzz/CMakeLists.txt

# See http://llvm.org/docs/LibFuzzer.html # See https://llvm.org/docs/LibFuzzer.html
if( LLVM_USE_SANITIZE_COVERAGE ) if( LLVM_USE_SANITIZE_COVERAGE )
add_executable(cxa_demangle_fuzzer add_executable(cxa_demangle_fuzzer
cxa_demangle_fuzzer.cpp cxa_demangle_fuzzer.cpp
../src/cxa_demangle.cpp ../src/cxa_demangle.cpp
) )
target_link_libraries(cxa_demangle_fuzzer target_link_libraries(cxa_demangle_fuzzer
LLVMFuzzer LLVMFuzzer
) )
endif() endif()

libunwind/docs/index.rst

Show First 20 Lines • Show All 90 Lines • ▼ Show 20 Lines
Send discussions and questions to the `Runtimes forum`_. Please add the tag "libunwind" to your post. Send discussions and questions to the `Runtimes forum`_. Please add the tag "libunwind" to your post.
Quick Links Quick Links
=========== ===========
* `LLVM Homepage <https://llvm.org/>`_ * `LLVM Homepage <https://llvm.org/>`_
* `LLVM Bug Tracker <https://github.com/llvm/llvm-project/labels/libunwind/>`_ * `LLVM Bug Tracker <https://github.com/llvm/llvm-project/labels/libunwind/>`_
* `cfe-dev Mailing List <http://lists.llvm.org/mailman/listinfo/cfe-dev>`_ * `cfe-dev Mailing List <https://lists.llvm.org/mailman/listinfo/cfe-dev>`_
* `cfe-commits Mailing List <http://lists.llvm.org/mailman/listinfo/cfe-commits>`_ * `cfe-commits Mailing List <https://lists.llvm.org/mailman/listinfo/cfe-commits>`_
* `Runtimes Forum <https://discourse.llvm.org/tags/c/runtimes>`_ * `Runtimes Forum <https://discourse.llvm.org/tags/c/runtimes>`_
* `Browse libunwind Sources <https://github.com/llvm/llvm-project/blob/main/libunwind/>`_ * `Browse libunwind Sources <https://github.com/llvm/llvm-project/blob/main/libunwind/>`_

lldb/docs/index.rst

Show First 20 Lines • Show All 99 Lines • ▼ Show 20 Lines
* on NetBSD with GCC/Clang and libstdc++/libc++ * on NetBSD with GCC/Clang and libstdc++/libc++
* on Windows with a generated project for VS 2017 or higher * on Windows with a generated project for VS 2017 or higher
See the :doc:`LLDB Build Page <resources/build>` for build instructions. See the :doc:`LLDB Build Page <resources/build>` for build instructions.
Discussions about LLDB should go to the `LLDB forum Discussions about LLDB should go to the `LLDB forum
<https://discourse.llvm.org/c/subprojects/lldb>`__. Commit <https://discourse.llvm.org/c/subprojects/lldb>`__. Commit
messages are automatically sent to the `lldb-commits messages are automatically sent to the `lldb-commits
<http://lists.llvm.org/mailman/listinfo/lldb-commits>`__ mailing list, and <https://lists.llvm.org/mailman/listinfo/lldb-commits>`__ mailing list, and
this is also the preferred mailing list for patch submissions. this is also the preferred mailing list for patch submissions.
See the :doc:`Projects page <status/projects>` if you are looking for some See the :doc:`Projects page <status/projects>` if you are looking for some
interesting areas to contribute to lldb. interesting areas to contribute to lldb.
.. toctree:: .. toctree::
:hidden: :hidden:
:maxdepth: 1 :maxdepth: 1
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

lldb/docs/resources/bots.rst

Show All 14 Lines
An overview of all LLDB builders can be found here: An overview of all LLDB builders can be found here:
`https://lab.llvm.org/buildbot/#/builders?tags=lldb <https://lab.llvm.org/buildbot/#/builders?tags=lldb>`_ `https://lab.llvm.org/buildbot/#/builders?tags=lldb <https://lab.llvm.org/buildbot/#/builders?tags=lldb>`_
GreenDragon GreenDragon
----------- -----------
GreenDragon builds and tests LLDB on macOS. It has a `dedicated tab GreenDragon builds and tests LLDB on macOS. It has a `dedicated tab
<http://green.lab.llvm.org/green/view/LLDB/>`_ for LLDB. <https://green.lab.llvm.org/green/view/LLDB/>`_ for LLDB.
* `lldb-cmake <http://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/>`_ * `lldb-cmake <https://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/>`_
* `lldb-cmake-matrix <http://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake-matrix/>`_ * `lldb-cmake-matrix <https://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake-matrix/>`_
* `lldb-cmake-standalone <http://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake-standalone/>`_ * `lldb-cmake-standalone <https://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake-standalone/>`_
* `lldb-cmake-sanitized <http://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake-sanitized/>`_ * `lldb-cmake-sanitized <https://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake-sanitized/>`_
Documentation Documentation
------------- -------------
The documentation bot validates that the website builds correctly with Sphinx. The documentation bot validates that the website builds correctly with Sphinx.
It does not generate the website itself, which happens on a separate server. It does not generate the website itself, which happens on a separate server.
* `lldb-sphinx-docs <http://lab.llvm.org:8011/builders/lldb-sphinx-docs>`_ * `lldb-sphinx-docs <https://lab.llvm.org:8011/builders/lldb-sphinx-docs>`_

lldb/docs/resources/build.rst

Show All 17 Lines
------------- -------------
LLDB relies on many of the technologies developed by the larger LLVM project. LLDB relies on many of the technologies developed by the larger LLVM project.
In particular, it requires both Clang and LLVM itself in order to build. Due to In particular, it requires both Clang and LLVM itself in order to build. Due to
this tight integration the Getting Started guides for both of these projects this tight integration the Getting Started guides for both of these projects
come as prerequisite reading: come as prerequisite reading:
* `LLVM <https://llvm.org/docs/GettingStarted.html>`_ * `LLVM <https://llvm.org/docs/GettingStarted.html>`_
* `Clang <http://clang.llvm.org/get_started.html>`_ * `Clang <https://clang.llvm.org/get_started.html>`_
The following requirements are shared on all platforms. The following requirements are shared on all platforms.
* `CMake <https://cmake.org>`_ * `CMake <https://cmake.org>`_
* `Ninja <https://ninja-build.org>`_ (strongly recommended) * `Ninja <https://ninja-build.org>`_ (strongly recommended)
If you want to run the test suite, you'll need to build LLDB with Python If you want to run the test suite, you'll need to build LLDB with Python
scripting support. scripting support.
▲ Show 20 Lines • Show All 581 Lines • Show Last 20 Lines

lldb/docs/use/python.rst

Show First 20 Lines • Show All 508 Lines • ▼ Show 20 Lines::
tree_utils.py - A set of functions for examining binary tree_utils.py - A set of functions for examining binary
search trees, based on the example search tree defined in search trees, based on the example search tree defined in
dictionary.c. These functions contain calls to LLDB API dictionary.c. These functions contain calls to LLDB API
functions, and assume that the LLDB Python module has been functions, and assume that the LLDB Python module has been
imported. imported.
For a thorough explanation of how the DFS function works, and For a thorough explanation of how the DFS function works, and
for more information about dictionary.c go to for more information about dictionary.c go to
http://lldb.llvm.org/scripting.html https://lldb.llvm.org/scripting.html
""" """
def DFS(root, word, cur_path): def DFS(root, word, cur_path):
""" """
Recursively traverse a binary search tree containing Recursively traverse a binary search tree containing
words sorted alphabetically, searching for a particular words sorted alphabetically, searching for a particular
word in the tree. Also maintains a string representing word in the tree. Also maintains a string representing
▲ Show 20 Lines • Show All 265 Lines • ▼ Show 20 Lines::
fprintf(stdout, "\n"); fprintf(stdout, "\n");
return 0; return 0;
} }
The text for "Romeo and Juliet" can be obtained from the Gutenberg Project The text for "Romeo and Juliet" can be obtained from the Gutenberg Project
(http://www.gutenberg.org). (http://www.gutenberg.org).

lldb/examples/scripting/tree_utils.py

Show All 9 Lines
tree_utils.py - A set of functions for examining binary tree_utils.py - A set of functions for examining binary
search trees, based on the example search tree defined in search trees, based on the example search tree defined in
dictionary.c. These functions contain calls to LLDB API dictionary.c. These functions contain calls to LLDB API
functions, and assume that the LLDB Python module has been functions, and assume that the LLDB Python module has been
imported. imported.
For a thorough explanation of how the DFS function works, and For a thorough explanation of how the DFS function works, and
for more information about dictionary.c go to for more information about dictionary.c go to
http://lldb.llvm.org/scripting.html https://lldb.llvm.org/scripting.html
""" """
from __future__ import print_function from __future__ import print_function
def DFS(root, word, cur_path): def DFS(root, word, cur_path):
""" """
Recursively traverse a binary search tree containing Recursively traverse a binary search tree containing
▲ Show 20 Lines • Show All 93 Lines • Show Last 20 Lines

lldb/test/API/commands/command/script/TestCommandScript.py

Show First 20 Lines • Show All 153 Lines • ▼ Show 20 Lines# check that the execution context is passed in to commands that ask for it
self.expect('command script list', matching=False, self.expect('command script list', matching=False,
substrs=['targetname', substrs=['targetname',
'longwait']) 'longwait'])
self.expect('command script add -f foobar frame', error=True, self.expect('command script add -f foobar frame', error=True,
substrs=['cannot add command']) substrs=['cannot add command'])
# http://llvm.org/bugs/show_bug.cgi?id=11569 # https://llvm.org/bugs/show_bug.cgi?id=11569
# LLDBSwigPythonCallCommand crashes when a command script returns an # LLDBSwigPythonCallCommand crashes when a command script returns an
# object # object
self.runCmd('command script add -f bug11569 bug11569') self.runCmd('command script add -f bug11569 bug11569')
# This should not crash. # This should not crash.
self.runCmd('bug11569', check=False) self.runCmd('bug11569', check=False)
def test_persistence(self): def test_persistence(self):
""" """
Show All 13 Lines

lldb/test/API/commands/command/script/bug11569.py

def bug11569(debugger, args, result, dict): def bug11569(debugger, args, result, dict):
""" """
http://llvm.org/bugs/show_bug.cgi?id=11569 https://llvm.org/bugs/show_bug.cgi?id=11569
LLDBSwigPythonCallCommand crashes when a command script returns an object. LLDBSwigPythonCallCommand crashes when a command script returns an object.
""" """
return ["return", "a", "non-string", "should", "not", "crash", "LLDB"] return ["return", "a", "non-string", "should", "not", "crash", "LLDB"]

lldb/test/API/commands/expression/ir-interpreter/TestIRInterpreter.py

Show All 37 Lines def build_and_run(self):
self, "main.c", self.line, num_expected_locations=1, loc_exact=False) self, "main.c", self.line, num_expected_locations=1, loc_exact=False)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
# getpid() is POSIX, among other problems, see bug # getpid() is POSIX, among other problems, see bug
@expectedFailureAll( @expectedFailureAll(
oslist=['windows'], oslist=['windows'],
bugnumber="http://llvm.org/pr21765") bugnumber="https://llvm.org/pr21765")
def test_ir_interpreter(self): def test_ir_interpreter(self):
self.build_and_run() self.build_and_run()
options = lldb.SBExpressionOptions() options = lldb.SBExpressionOptions()
options.SetLanguage(lldb.eLanguageTypeC_plus_plus) options.SetLanguage(lldb.eLanguageTypeC_plus_plus)
set_up_expressions = ["int $i = 9", "int $j = 3", "int $k = 5", set_up_expressions = ["int $i = 9", "int $j = 3", "int $k = 5",
"unsigned long long $ull = -1", "unsigned $u = -1"] "unsigned long long $ull = -1", "unsigned $u = -1"]
Show All 36 Lines

lldb/test/API/functionalities/process_group/TestChangeProcessGroup.py

Show All 16 Linesclass ChangeProcessGroupTestCase(TestBase):
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# Find the line number to break for main.c. # Find the line number to break for main.c.
self.line = line_number('main.c', '// Set breakpoint here') self.line = line_number('main.c', '// Set breakpoint here')
@skipIfFreeBSD # Times out on FreeBSD llvm.org/pr23731 @skipIfFreeBSD # Times out on FreeBSD llvm.org/pr23731
@skipIfWindows # setpgid call does not exist on Windows @skipIfWindows # setpgid call does not exist on Windows
@expectedFailureAndroid("http://llvm.org/pr23762", api_levels=[16]) @expectedFailureAndroid("https://llvm.org/pr23762", api_levels=[16])
@expectedFailureNetBSD @expectedFailureNetBSD
@skipIftvOS # fork not available on tvOS. @skipIftvOS # fork not available on tvOS.
@skipIfwatchOS # fork not available on watchOS. @skipIfwatchOS # fork not available on watchOS.
def test_setpgid(self): def test_setpgid(self):
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getBuildArtifact("a.out")
# Use a file as a synchronization point between test and inferior. # Use a file as a synchronization point between test and inferior.
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

lldb/test/API/lang/c/bitfields/TestBitfields.py

Show All 11 Linesclass TestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
def run_to_main(self): def run_to_main(self):
self.build() self.build()
lldbutil.run_to_source_breakpoint(self, "// break here", lldb.SBFileSpec("main.c")) lldbutil.run_to_source_breakpoint(self, "// break here", lldb.SBFileSpec("main.c"))
# BitFields exhibit crashes in record layout on Windows # BitFields exhibit crashes in record layout on Windows
# (http://llvm.org/pr21800) # (https://llvm.org/pr21800)
@skipIfWindows @skipIfWindows
def test_bits(self): def test_bits(self):
self.run_to_main() self.run_to_main()
# Check each field of Bits. # Check each field of Bits.
bits_children = [ bits_children = [
ValueCheck(type="int:1"), # Unnamed and uninitialized ValueCheck(type="int:1"), # Unnamed and uninitialized
ValueCheck(type="uint32_t:1", name="b1", value="1"), ValueCheck(type="uint32_t:1", name="b1", value="1"),
▲ Show 20 Lines • Show All 78 Lines • ▼ Show 20 Lines def test_bits(self):
# Check reading a bitfield through a pointer in various ways (PR47743) # Check reading a bitfield through a pointer in various ways (PR47743)
self.expect("v/x large_packed_ptr->b", self.expect("v/x large_packed_ptr->b",
substrs=["large_packed_ptr->b = 0x0000000dffffeeee"]) substrs=["large_packed_ptr->b = 0x0000000dffffeeee"])
self.expect("v/x large_packed_ptr[0].b", self.expect("v/x large_packed_ptr[0].b",
substrs=["large_packed_ptr[0].b = 0x0000000dffffeeee"]) substrs=["large_packed_ptr[0].b = 0x0000000dffffeeee"])
# BitFields exhibit crashes in record layout on Windows # BitFields exhibit crashes in record layout on Windows
# (http://llvm.org/pr21800) # (https://llvm.org/pr21800)
@skipIfWindows @skipIfWindows
def test_expression_bug(self): def test_expression_bug(self):
# Ensure evaluating (emulating) an expression does not break bitfield # Ensure evaluating (emulating) an expression does not break bitfield
# values for already parsed variables. The expression is run twice # values for already parsed variables. The expression is run twice
# because the very first expression can resume a target (to allocate # because the very first expression can resume a target (to allocate
# memory, etc.) even if it is not being jitted. # memory, etc.) even if it is not being jitted.
self.run_to_main() self.run_to_main()
self.expect("v/x large_packed", VARIABLES_DISPLAYED_CORRECTLY, self.expect("v/x large_packed", VARIABLES_DISPLAYED_CORRECTLY,
substrs=["a = 0x0000000cbbbbaaaa", "b = 0x0000000dffffeee"]) substrs=["a = 0x0000000cbbbbaaaa", "b = 0x0000000dffffeee"])
self.expect("expr --allow-jit false -- more_bits.a", VARIABLES_DISPLAYED_CORRECTLY, self.expect("expr --allow-jit false -- more_bits.a", VARIABLES_DISPLAYED_CORRECTLY,
substrs=['uint32_t', '3']) substrs=['uint32_t', '3'])
self.expect("v/x large_packed", VARIABLES_DISPLAYED_CORRECTLY, self.expect("v/x large_packed", VARIABLES_DISPLAYED_CORRECTLY,
substrs=["a = 0x0000000cbbbbaaaa", "b = 0x0000000dffffeee"]) substrs=["a = 0x0000000cbbbbaaaa", "b = 0x0000000dffffeee"])
self.expect("expr --allow-jit false -- more_bits.a", VARIABLES_DISPLAYED_CORRECTLY, self.expect("expr --allow-jit false -- more_bits.a", VARIABLES_DISPLAYED_CORRECTLY,
substrs=['uint32_t', '3']) substrs=['uint32_t', '3'])
self.expect("v/x large_packed", VARIABLES_DISPLAYED_CORRECTLY, self.expect("v/x large_packed", VARIABLES_DISPLAYED_CORRECTLY,
substrs=["a = 0x0000000cbbbbaaaa", "b = 0x0000000dffffeee"]) substrs=["a = 0x0000000cbbbbaaaa", "b = 0x0000000dffffeee"])
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
# BitFields exhibit crashes in record layout on Windows # BitFields exhibit crashes in record layout on Windows
# (http://llvm.org/pr21800) # (https://llvm.org/pr21800)
@skipIfWindows @skipIfWindows
def test_and_python_api(self): def test_and_python_api(self):
"""Use Python APIs to inspect a bitfields variable.""" """Use Python APIs to inspect a bitfields variable."""
self.run_to_main() self.run_to_main()
# Lookup the "bits" variable which contains 8 bitfields. # Lookup the "bits" variable which contains 8 bitfields.
bits = self.frame().FindVariable("bits") bits = self.frame().FindVariable("bits")
self.DebugSBValue(bits) self.DebugSBValue(bits)
Show All 16 Lines def test_and_python_api(self):
self.assertEqual(b7.GetTypeName(), "uint32_t:7") self.assertEqual(b7.GetTypeName(), "uint32_t:7")
self.assertTrue(b7.IsInScope()) self.assertTrue(b7.IsInScope())
self.assertEqual(int(b7.GetValue(), 0), 127) self.assertEqual(int(b7.GetValue(), 0), 127)
four = bits.GetChildMemberWithName("four") four = bits.GetChildMemberWithName("four")
self.assertEqual(four.GetName(), "four") self.assertEqual(four.GetName(), "four")
self.assertEqual(four.GetTypeName(), "uint32_t:4") self.assertEqual(four.GetTypeName(), "uint32_t:4")
self.assertTrue(four.IsInScope()) self.assertTrue(four.IsInScope())
self.assertEqual(int(four.GetValue(), 0), 15) self.assertEqual(int(four.GetValue(), 0), 15)
No newline at end of file

lldb/test/API/lang/c/modules/TestCModules.py

Show All 10 Lines
class CModulesTestCase(TestBase): class CModulesTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@expectedFailureAll( @expectedFailureAll(
oslist=["freebsd", "linux"], oslist=["freebsd", "linux"],
bugnumber="http://llvm.org/pr23456 'fopen' has unknown return type") bugnumber="https://llvm.org/pr23456 'fopen' has unknown return type")
@expectedFailureAll( @expectedFailureAll(
oslist=["windows"], oslist=["windows"],
bugnumber="llvm.org/pr24489: Name lookup not working correctly on Windows") bugnumber="llvm.org/pr24489: Name lookup not working correctly on Windows")
@skipIf(macos_version=["<", "10.12"]) @skipIf(macos_version=["<", "10.12"])
@expectedFailureNetBSD @expectedFailureNetBSD
def test_expr(self): def test_expr(self):
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getBuildArtifact("a.out")
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

lldb/test/API/lang/cpp/class-template-parameter-pack/TestClassTemplateParameterPack.py

Show All 23 Lines def test(self):
self.expect_expr("myD", result_type="D<int, int, bool>", result_children=[ self.expect_expr("myD", result_type="D<int, int, bool>", result_children=[
ValueCheck(name="D<int, int>", children=[ ValueCheck(name="D<int, int>", children=[
ValueCheck(name="member", value="64") ValueCheck(name="member", value="64")
]) ])
]) ])
self.expect_expr("myLesserD.argsAre_Int_bool()", result_value="false") self.expect_expr("myLesserD.argsAre_Int_bool()", result_value="false")
self.expect_expr("myD.argsAre_Int_bool()", result_value="true") self.expect_expr("myD.argsAre_Int_bool()", result_value="true")
# Disabling until we do template lookup correctly: http://lists.llvm.org/pipermail/lldb-commits/Week-of-Mon-20180507/040689.html # Disabling until we do template lookup correctly: https://lists.llvm.org/pipermail/lldb-commits/Week-of-Mon-20180507/040689.html
# FIXME: Rewrite this with expect_expr # FIXME: Rewrite this with expect_expr
# self.expect("expression -- C<int, 16>().isSixteenThirtyTwo()", DATA_TYPES_DISPLAYED_CORRECTLY, substrs = ["false"]) # self.expect("expression -- C<int, 16>().isSixteenThirtyTwo()", DATA_TYPES_DISPLAYED_CORRECTLY, substrs = ["false"])
# self.expect("expression -- C<int, 16, 32>().isSixteenThirtyTwo()", DATA_TYPES_DISPLAYED_CORRECTLY, substrs = ["true"]) # self.expect("expression -- C<int, 16, 32>().isSixteenThirtyTwo()", DATA_TYPES_DISPLAYED_CORRECTLY, substrs = ["true"])
# self.expect("expression -- D<int, int>().isIntBool()", DATA_TYPES_DISPLAYED_CORRECTLY, substrs = ["false"]) # self.expect("expression -- D<int, int>().isIntBool()", DATA_TYPES_DISPLAYED_CORRECTLY, substrs = ["false"])
# self.expect("expression -- D<int, int, bool>().isIntBool()", DATA_TYPES_DISPLAYED_CORRECTLY, substrs = ["true"]) # self.expect("expression -- D<int, int, bool>().isIntBool()", DATA_TYPES_DISPLAYED_CORRECTLY, substrs = ["true"])

lldb/test/API/lang/objc/modules/TestObjCModules.py

Show First 20 Lines • Show All 58 Lines • ▼ Show 20 Lines def test_expr(self):
self.expect("expr string.length", VARIABLES_DISPLAYED_CORRECTLY, self.expect("expr string.length", VARIABLES_DISPLAYED_CORRECTLY,
substrs=["NSUInteger", "5"]) substrs=["NSUInteger", "5"])
self.expect("expr array.count", VARIABLES_DISPLAYED_CORRECTLY, self.expect("expr array.count", VARIABLES_DISPLAYED_CORRECTLY,
substrs=["NSUInteger", "3"]) substrs=["NSUInteger", "3"])
self.expect( self.expect(
"p *[NSURL URLWithString:@\"http://lldb.llvm.org\"]", "p *[NSURL URLWithString:@\"https://lldb.llvm.org\"]",
VARIABLES_DISPLAYED_CORRECTLY, VARIABLES_DISPLAYED_CORRECTLY,
substrs=[ substrs=[
"NSURL", "NSURL",
"isa", "isa",
"_urlString"]) "_urlString"])
self.expect( self.expect(
"p [NSURL URLWithString:@\"http://lldb.llvm.org\"].scheme", "p [NSURL URLWithString:@\"https://lldb.llvm.org\"].scheme",
VARIABLES_DISPLAYED_CORRECTLY, VARIABLES_DISPLAYED_CORRECTLY,
substrs=["http"]) substrs=["http"])
# Test that the NULL macro still works with a loaded module. # Test that the NULL macro still works with a loaded module.
self.expect_expr("int *i = NULL; i == NULL", result_value="true") self.expect_expr("int *i = NULL; i == NULL", result_value="true")

lldb/test/API/python_api/default-constructor/TestDefaultConstructorForAPIObjects.py

Show First 20 Lines • Show All 108 Lines • ▼ Show 20 Lines def test_SBDebugger(self):
if self.TraceOn(): if self.TraceOn():
print(obj) print(obj)
self.assertFalse(obj) self.assertFalse(obj)
# Do fuzz testing on the invalid obj, it should not crash lldb. # Do fuzz testing on the invalid obj, it should not crash lldb.
import sb_debugger import sb_debugger
sb_debugger.fuzz_obj(obj) sb_debugger.fuzz_obj(obj)
# darwin: This test passes with swig 3.0.2, fails w/3.0.5 other tests fail # darwin: This test passes with swig 3.0.2, fails w/3.0.5 other tests fail
# with 2.0.12 http://llvm.org/pr23488 # with 2.0.12 https://llvm.org/pr23488
def test_SBError(self): def test_SBError(self):
obj = lldb.SBError() obj = lldb.SBError()
if self.TraceOn(): if self.TraceOn():
print(obj) print(obj)
self.assertFalse(obj) self.assertFalse(obj)
# Do fuzz testing on the invalid obj, it should not crash lldb. # Do fuzz testing on the invalid obj, it should not crash lldb.
import sb_error import sb_error
sb_error.fuzz_obj(obj) sb_error.fuzz_obj(obj)
▲ Show 20 Lines • Show All 237 Lines • Show Last 20 Lines

lldb/test/API/python_api/sbdata/TestSBData.py

Show First 20 Lines • Show All 135 Lines • ▼ Show 20 Lines def test_with_run_command(self):
offset = 0 offset = 0
self.assert_data(data.GetUnsignedInt32, offset, 1) self.assert_data(data.GetUnsignedInt32, offset, 1)
offset += 4 offset += 4
self.assert_data(data.GetUnsignedInt32, offset, 9) self.assert_data(data.GetUnsignedInt32, offset, 9)
foobar_addr = star_foobar.GetLoadAddress() foobar_addr = star_foobar.GetLoadAddress()
foobar_addr += 12 foobar_addr += 12
# http://llvm.org/bugs/show_bug.cgi?id=11579 # https://llvm.org/bugs/show_bug.cgi?id=11579
# lldb::SBValue::CreateValueFromAddress does not verify SBType::GetPointerType succeeds # lldb::SBValue::CreateValueFromAddress does not verify SBType::GetPointerType succeeds
# This should not crash LLDB. # This should not crash LLDB.
nothing = foobar.CreateValueFromAddress( nothing = foobar.CreateValueFromAddress(
"nothing", foobar_addr, star_foobar.GetType().GetBasicType( "nothing", foobar_addr, star_foobar.GetType().GetBasicType(
lldb.eBasicTypeInvalid)) lldb.eBasicTypeInvalid))
new_foobar = foobar.CreateValueFromAddress( new_foobar = foobar.CreateValueFromAddress(
"f00", foobar_addr, star_foobar.GetType()) "f00", foobar_addr, star_foobar.GetType())
▲ Show 20 Lines • Show All 378 Lines • Show Last 20 Lines

lldb/test/API/test_runner/test/test_process_control.py

Show First 20 Lines • Show All 202 Lines • ▼ Show 20 Lines def test_hard_terminate_works(self):
driver.returncode, driver.returncode,
driver.output)) driver.output))
def test_inferior_exits_with_live_child_shared_handles(self): def test_inferior_exits_with_live_child_shared_handles(self):
"""inferior exit detected when inferior children are live with shared """inferior exit detected when inferior children are live with shared
stdout/stderr handles. stdout/stderr handles.
""" """
# Requires review D13362 or equivalent to be implemented. # Requires review D13362 or equivalent to be implemented.
self.skipTest("http://reviews.llvm.org/D13362") self.skipTest("https://reviews.llvm.org/D13362")
driver = TestInferiorDriver() driver = TestInferiorDriver()
# Create the inferior (I1), and instruct it to create a child (C1) # Create the inferior (I1), and instruct it to create a child (C1)
# that shares the stdout/stderr handles with the inferior. # that shares the stdout/stderr handles with the inferior.
# C1 will then loop forever. # C1 will then loop forever.
driver.run_command_with_timeout( driver.run_command_with_timeout(
self.inferior_command( self.inferior_command(
Show All 21 Lines

lldb/test/API/tools/lldb-vscode/attach/TestVSCode_attach.py

Show First 20 Lines • Show All 110 Lines • ▼ Show 20 Lines def test_by_name_waitFor(self):
args=(program, 1.0,)) args=(program, 1.0,))
self.spawn_thread.start() self.spawn_thread.start()
self.attach(program=program, waitFor=True) self.attach(program=program, waitFor=True)
self.set_and_hit_breakpoint(continueToExit=True) self.set_and_hit_breakpoint(continueToExit=True)
@skipIfWindows @skipIfWindows
@skipIfDarwin @skipIfDarwin
@skipIfNetBSD # Hangs on NetBSD as well @skipIfNetBSD # Hangs on NetBSD as well
@skipIf(archs=["arm", "aarch64"]) # Example of a flaky run http://lab.llvm.org:8011/builders/lldb-aarch64-ubuntu/builds/5527/steps/test/logs/stdio @skipIf(archs=["arm", "aarch64"]) # Example of a flaky run https://lab.llvm.org:8011/builders/lldb-aarch64-ubuntu/builds/5527/steps/test/logs/stdio
def test_commands(self): def test_commands(self):
''' '''
Tests the "initCommands", "preRunCommands", "stopCommands", Tests the "initCommands", "preRunCommands", "stopCommands",
"exitCommands", "terminateCommands" and "attachCommands" "exitCommands", "terminateCommands" and "attachCommands"
that can be passed during attach. that can be passed during attach.
"initCommands" are a list of LLDB commands that get executed "initCommands" are a list of LLDB commands that get executed
before the targt is created. before the targt is created.
▲ Show 20 Lines • Show All 68 Lines • ▼ Show 20 Lines def test_commands(self):
# and the "terminateCommands" due to the debugging session ending # and the "terminateCommands" due to the debugging session ending
output = self.collect_console(duration=1.0) output = self.collect_console(duration=1.0)
self.verify_commands('exitCommands', output, exitCommands) self.verify_commands('exitCommands', output, exitCommands)
self.verify_commands('terminateCommands', output, terminateCommands) self.verify_commands('terminateCommands', output, terminateCommands)
@skipIfWindows @skipIfWindows
@skipIfDarwin @skipIfDarwin
@skipIfNetBSD # Hangs on NetBSD as well @skipIfNetBSD # Hangs on NetBSD as well
@skipIf(archs=["arm", "aarch64"]) # Example of a flaky run http://lab.llvm.org:8011/builders/lldb-aarch64-ubuntu/builds/5517/steps/test/logs/stdio @skipIf(archs=["arm", "aarch64"]) # Example of a flaky run https://lab.llvm.org:8011/builders/lldb-aarch64-ubuntu/builds/5517/steps/test/logs/stdio
def test_terminate_commands(self): def test_terminate_commands(self):
''' '''
Tests that the "terminateCommands", that can be passed during Tests that the "terminateCommands", that can be passed during
attach, are run when the debugger is disconnected. attach, are run when the debugger is disconnected.
''' '''
self.build_and_create_debug_adaptor() self.build_and_create_debug_adaptor()
program = self.getBuildArtifact("a.out") program = self.getBuildArtifact("a.out")
# Here we just create a target and launch the process as a way to test # Here we just create a target and launch the process as a way to test
Show All 17 Lines

lldb/test/API/tools/lldb-vscode/launch/TestVSCode_launch.py

Show First 20 Lines • Show All 431 Lines • ▼ Show 20 Lines def test_extra_launch_commands(self):
# Get output from the console. This should contain both the # Get output from the console. This should contain both the
# "exitCommands" that were run after the second breakpoint was hit # "exitCommands" that were run after the second breakpoint was hit
output = self.get_console(timeout=1.0) output = self.get_console(timeout=1.0)
self.verify_commands('exitCommands', output, exitCommands) self.verify_commands('exitCommands', output, exitCommands)
@skipIfWindows @skipIfWindows
@skipIfNetBSD # Hangs on NetBSD as well @skipIfNetBSD # Hangs on NetBSD as well
@skipIfDarwin @skipIfDarwin
@skipIf(archs=["arm", "aarch64"]) # Example of a flaky run http://lab.llvm.org:8011/builders/lldb-aarch64-ubuntu/builds/5540/steps/test/logs/stdio @skipIf(archs=["arm", "aarch64"]) # Example of a flaky run https://lab.llvm.org:8011/builders/lldb-aarch64-ubuntu/builds/5540/steps/test/logs/stdio
def test_terminate_commands(self): def test_terminate_commands(self):
''' '''
Tests that the "terminateCommands", that can be passed during Tests that the "terminateCommands", that can be passed during
launch, are run when the debugger is disconnected. launch, are run when the debugger is disconnected.
''' '''
self.build_and_create_debug_adaptor() self.build_and_create_debug_adaptor()
program = self.getBuildArtifact("a.out") program = self.getBuildArtifact("a.out")
Show All 9 Lines

llvm/CREDITS.TXT

Show First 20 Lines • Show All 482 Lines • ▼ Show 20 Lines
N: Michael J. Spencer N: Michael J. Spencer
E: bigcheesegs@gmail.com E: bigcheesegs@gmail.com
D: Shepherding Windows COFF support into MC. D: Shepherding Windows COFF support into MC.
D: Lots of Windows stuff. D: Lots of Windows stuff.
N: Reid Spencer N: Reid Spencer
E: rspencer@reidspencer.com E: rspencer@reidspencer.com
W: http://reidspencer.com/ W: http://reidspencer.com/
D: Lots of stuff, see: http://wiki.llvm.org/index.php/User:Reid D: Lots of stuff, see: https://wiki.llvm.org/index.php/User:Reid
N: Abhina Sreeskantharajan N: Abhina Sreeskantharajan
E: Abhina.Sreeskantharajan@ibm.com E: Abhina.Sreeskantharajan@ibm.com
D: z/OS support D: z/OS support
N: Alp Toker N: Alp Toker
E: alp@nuanti.com E: alp@nuanti.com
W: http://atoker.com/ W: http://atoker.com/
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

llvm/configure

#! /bin/sh #! /bin/sh
echo "################################################################################" echo "################################################################################"
echo "################################################################################" echo "################################################################################"
echo "The LLVM project no longer supports building with configure & make." echo "The LLVM project no longer supports building with configure & make."
echo "" echo ""
echo "Please migrate to the CMake-based build system." echo "Please migrate to the CMake-based build system."
echo "For more information see: http://llvm.org/docs/CMake.html" echo "For more information see: https://llvm.org/docs/CMake.html"
echo "################################################################################" echo "################################################################################"
echo "################################################################################" echo "################################################################################"
exit 1 exit 1

llvm/docs/DeveloperPolicy.rst

Show All 24 Lines
#. Keep the top of tree as stable as possible. #. Keep the top of tree as stable as possible.
#. Establish awareness of the project's :ref:`copyright, license, and patent #. Establish awareness of the project's :ref:`copyright, license, and patent
policies <copyright-license-patents>` with contributors to the project. policies <copyright-license-patents>` with contributors to the project.
This policy is aimed at frequent contributors to LLVM. People interested in This policy is aimed at frequent contributors to LLVM. People interested in
contributing one-off patches can do so in an informal way by sending them to the contributing one-off patches can do so in an informal way by sending them to the
`llvm-commits mailing list `llvm-commits mailing list
<http://lists.llvm.org/mailman/listinfo/llvm-commits>`_ and engaging another <https://lists.llvm.org/mailman/listinfo/llvm-commits>`_ and engaging another
developer to see it through the process. developer to see it through the process.
Developer Policies Developer Policies
================== ==================
This section contains policies that pertain to frequent LLVM developers. We This section contains policies that pertain to frequent LLVM developers. We
always welcome `one-off patches`_ from people who do not routinely contribute to always welcome `one-off patches`_ from people who do not routinely contribute to
LLVM, but we expect more from frequent contributors to keep the system as LLVM, but we expect more from frequent contributors to keep the system as
efficient as possible for everyone. Frequent LLVM contributors are expected to efficient as possible for everyone. Frequent LLVM contributors are expected to
meet the following requirements in order for LLVM to maintain a high standard of meet the following requirements in order for LLVM to maintain a high standard of
quality. quality.
Stay Informed Stay Informed
------------- -------------
Developers should stay informed by reading the `LLVM Discourse forums`_. Developers should stay informed by reading the `LLVM Discourse forums`_.
If you are doing anything more than just casual work on LLVM, it is suggested that you also If you are doing anything more than just casual work on LLVM, it is suggested that you also
subscribe to the "commits" mailing list for the subproject you're interested in, subscribe to the "commits" mailing list for the subproject you're interested in,
such as `llvm-commits such as `llvm-commits
<http://lists.llvm.org/mailman/listinfo/llvm-commits>`_, `cfe-commits <https://lists.llvm.org/mailman/listinfo/llvm-commits>`_, `cfe-commits
<http://lists.llvm.org/mailman/listinfo/cfe-commits>`_, or `lldb-commits <https://lists.llvm.org/mailman/listinfo/cfe-commits>`_, or `lldb-commits
<http://lists.llvm.org/mailman/listinfo/lldb-commits>`_. Reading the <https://lists.llvm.org/mailman/listinfo/lldb-commits>`_. Reading the
"commits" list and paying attention to changes being made by others is a good "commits" list and paying attention to changes being made by others is a good
way to see what other people are interested in and watching the flow of the way to see what other people are interested in and watching the flow of the
project as a whole. project as a whole.
We recommend that active developers monitor incoming issues to our `GitHub issue tracker <https://github.com/llvm/llvm-project/issues>`_ and preferably subscribe to the `llvm-bugs We recommend that active developers monitor incoming issues to our `GitHub issue tracker <https://github.com/llvm/llvm-project/issues>`_ and preferably subscribe to the `llvm-bugs
<http://lists.llvm.org/mailman/listinfo/llvm-bugs>`_ email list to keep track <https://lists.llvm.org/mailman/listinfo/llvm-bugs>`_ email list to keep track
of bugs and enhancements occurring in LLVM. We really appreciate people who are of bugs and enhancements occurring in LLVM. We really appreciate people who are
proactive at catching incoming bugs in their components and dealing with them proactive at catching incoming bugs in their components and dealing with them
promptly. promptly.
Please be aware that all public LLVM mailing lists and discourse forums are public and archived, and Please be aware that all public LLVM mailing lists and discourse forums are public and archived, and
that notices of confidentiality or non-disclosure cannot be respected. that notices of confidentiality or non-disclosure cannot be respected.
.. _patch: .. _patch:
▲ Show 20 Lines • Show All 1,158 Lines • Show Last 20 Lines

llvm/docs/Frontend/PerformanceTips.rst

Show First 20 Lines • Show All 287 Lines • ▼ Show 20 Lines
increases the chances that a metadata extension would be well received by the increases the chances that a metadata extension would be well received by the
community as a whole. community as a whole.
Adding to this document Adding to this document
======================= =======================
If you run across a case that you feel deserves to be covered here, please send If you run across a case that you feel deserves to be covered here, please send
a patch to `llvm-commits a patch to `llvm-commits
<http://lists.llvm.org/mailman/listinfo/llvm-commits>`_ for review. <https://lists.llvm.org/mailman/listinfo/llvm-commits>`_ for review.
If you have questions on these items, please ask them on `Discourse If you have questions on these items, please ask them on `Discourse
<https://discourse.llvm.org>`_. The more relevant <https://discourse.llvm.org>`_. The more relevant
context you are able to give to your question, the more likely it is to be context you are able to give to your question, the more likely it is to be
answered. answered.

llvm/docs/FuzzingLLVM.rst

Show First 20 Lines • Show All 259 Lines • ▼ Show 20 Lines
list`_. list`_.
.. _OSS Fuzz: https://github.com/google/oss-fuzz .. _OSS Fuzz: https://github.com/google/oss-fuzz
.. _LLVM project issue list: .. _LLVM project issue list:
https://bugs.chromium.org/p/oss-fuzz/issues/list?q=Proj-llvm https://bugs.chromium.org/p/oss-fuzz/issues/list?q=Proj-llvm
.. _LLVM on OSS Fuzz: .. _LLVM on OSS Fuzz:
https://github.com/google/oss-fuzz/blob/master/projects/llvm https://github.com/google/oss-fuzz/blob/master/projects/llvm
.. _llvm-bugs mailing list: .. _llvm-bugs mailing list:
http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-bugs https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-bugs
Utilities for Writing Fuzzers Utilities for Writing Fuzzers
============================= =============================
There are some utilities available for writing fuzzers in LLVM. There are some utilities available for writing fuzzers in LLVM.
Some helpers for handling the command line interface are available in Some helpers for handling the command line interface are available in
Show All 9 Lines

llvm/docs/GettingInvolved.rst

Show All 34 Lines:doc:`SupportPolicy`
The LLVM support policy for core and non-core components. The LLVM support policy for core and non-core components.
:doc:`SphinxQuickstartTemplate` :doc:`SphinxQuickstartTemplate`
A template + tutorial for writing new Sphinx documentation. It is meant A template + tutorial for writing new Sphinx documentation. It is meant
to be read in source form. to be read in source form.
:doc:`Phabricator` :doc:`Phabricator`
Describes how to use the Phabricator code review tool hosted on Describes how to use the Phabricator code review tool hosted on
http://reviews.llvm.org/ and its command line interface, Arcanist. https://reviews.llvm.org/ and its command line interface, Arcanist.
:doc:`HowToSubmitABug` :doc:`HowToSubmitABug`
Instructions for properly submitting information about any bugs you run into Instructions for properly submitting information about any bugs you run into
in the LLVM system. in the LLVM system.
:doc:`BugLifeCycle` :doc:`BugLifeCycle`
Describes how bugs are reported, triaged and closed. Describes how bugs are reported, triaged and closed.
▲ Show 20 Lines • Show All 63 Lines • ▼ Show 20 Lines
`Commits Archive (llvm-commits)`__ `Commits Archive (llvm-commits)`__
This list contains all commit messages that are made when LLVM developers This list contains all commit messages that are made when LLVM developers
commit code changes to the repository. It also serves as a forum for commit code changes to the repository. It also serves as a forum for
patch review (i.e. send patches here). It is useful for those who want to patch review (i.e. send patches here). It is useful for those who want to
stay on the bleeding edge of LLVM development. This list is very high stay on the bleeding edge of LLVM development. This list is very high
volume. volume.
.. __: http://lists.llvm.org/pipermail/llvm-commits/ .. __: https://lists.llvm.org/pipermail/llvm-commits/
`Bugs & Patches Archive (llvm-bugs)`__ `Bugs & Patches Archive (llvm-bugs)`__
This list gets emailed every time a bug is opened and closed. It is This list gets emailed every time a bug is opened and closed. It is
higher volume than the LLVM-dev list. higher volume than the LLVM-dev list.
.. __: http://lists.llvm.org/pipermail/llvm-bugs/ .. __: https://lists.llvm.org/pipermail/llvm-bugs/
`LLVM Announcements`__ `LLVM Announcements`__
If you just want project wide announcements such as releases, developers meetings, or blog posts, then you should check out the Announcement category on LLVM Discourse. If you just want project wide announcements such as releases, developers meetings, or blog posts, then you should check out the Announcement category on LLVM Discourse.
.. __: https://discourse.llvm.org/c/announce/46 .. __: https://discourse.llvm.org/c/announce/46
.. _online-sync-ups: .. _online-sync-ups:
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Lines * - flang
- -
- -
* - OpenMP * - OpenMP
- Multiple meeting series, `documented here <https://openmp.llvm.org/docs/SupportAndFAQ.html>`__ - Multiple meeting series, `documented here <https://openmp.llvm.org/docs/SupportAndFAQ.html>`__
- -
- -
* - LLVM Alias Analysis * - LLVM Alias Analysis
- Every 4 weeks on Tuesdays - Every 4 weeks on Tuesdays
- `ics <http://lists.llvm.org/pipermail/llvm-dev/attachments/20201103/a3499a67/attachment-0001.ics>`__ - `ics <https://lists.llvm.org/pipermail/llvm-dev/attachments/20201103/a3499a67/attachment-0001.ics>`__
- `Minutes/docs <https://docs.google.com/document/d/17U-WvX8qyKc3S36YUKr3xfF-GHunWyYowXbxEdpHscw>`__ - `Minutes/docs <https://docs.google.com/document/d/17U-WvX8qyKc3S36YUKr3xfF-GHunWyYowXbxEdpHscw>`__
* - Windows/COFF related developments * - Windows/COFF related developments
- Every 2 months on Thursday - Every 2 months on Thursday
- -
- `Minutes/docs <https://docs.google.com/document/d/1A-W0Sas_oHWTEl_x_djZYoRtzAdTONMW_6l1BH9G6Bo/edit?usp=sharing>`__ - `Minutes/docs <https://docs.google.com/document/d/1A-W0Sas_oHWTEl_x_djZYoRtzAdTONMW_6l1BH9G6Bo/edit?usp=sharing>`__
* - Vector Predication * - Vector Predication
- Every 2 weeks on Tuesdays, 3pm UTC - Every 2 weeks on Tuesdays, 3pm UTC
- -
▲ Show 20 Lines • Show All 110 Lines • ▼ Show 20 Lines
Users and developers of the LLVM project (including subprojects such as Clang) Users and developers of the LLVM project (including subprojects such as Clang)
can be found in #llvm on `irc.oftc.net <irc://irc.oftc.net/llvm>`_. can be found in #llvm on `irc.oftc.net <irc://irc.oftc.net/llvm>`_.
This channel has several bots. This channel has several bots.
* Buildbot reporters * Buildbot reporters
* llvmbb - Bot for the main LLVM buildbot master. * llvmbb - Bot for the main LLVM buildbot master.
http://lab.llvm.org/buildbot/#/console https://lab.llvm.org/buildbot/#/console
* robot - Bugzilla linker. %bug <number> * robot - Bugzilla linker. %bug <number>
* clang-bot - A `geordi <http://www.eelis.net/geordi/>`_ instance running * clang-bot - A `geordi <http://www.eelis.net/geordi/>`_ instance running
near-trunk clang instead of gcc. near-trunk clang instead of gcc.
In addition to the traditional IRC there is a In addition to the traditional IRC there is a
`Discord <https://discord.com/channels/636084430946959380/636725486533345280>`_ `Discord <https://discord.com/channels/636084430946959380/636725486533345280>`_
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

llvm/docs/HowToAddABuilder.rst

Show First 20 Lines • Show All 137 Lines • ▼ Show 20 Lines#. Send a patch which adds your build worker and your builder to
otherwise. otherwise.
#. Send the buildbot-worker access name and the access password directly to #. Send the buildbot-worker access name and the access password directly to
`Galina Kistanova <mailto:gkistanova@gmail.com>`_, and wait till she `Galina Kistanova <mailto:gkistanova@gmail.com>`_, and wait till she
will let you know that your changes are applied and buildmaster is will let you know that your changes are applied and buildmaster is
reconfigured. reconfigured.
#. Check the status of your buildbot-worker on the `Waterfall Display (Staging) #. Check the status of your buildbot-worker on the `Waterfall Display (Staging)
<http://lab.llvm.org/staging/#/waterfall>`_ to make sure it is <https://lab.llvm.org/staging/#/waterfall>`_ to make sure it is
connected, and the `Workers Display (Staging) connected, and the `Workers Display (Staging)
<http://lab.llvm.org/staging/#/workers>`_ to see if administrator <https://lab.llvm.org/staging/#/workers>`_ to see if administrator
contact and worker information are correct. contact and worker information are correct.
#. At this point, you have a working builder connected to the staging #. At this point, you have a working builder connected to the staging
buildmaster. You can now make sure it is reliably green and keeps buildmaster. You can now make sure it is reliably green and keeps
up with the build queue. No notifications will be sent, so you can up with the build queue. No notifications will be sent, so you can
keep an unstable builder connected to staging indefinitely. keep an unstable builder connected to staging indefinitely.
#. (Optional) Once the builder is stable on the staging buildmaster with #. (Optional) Once the builder is stable on the staging buildmaster with
▲ Show 20 Lines • Show All 106 Lines • Show Last 20 Lines

llvm/docs/LibFuzzer.rst

Show First 20 Lines • Show All 791 Lines • ▼ Show 20 Lines
* file:`[1] <http://bugs.gw.com/view.php?id=550>`__ `[2] <http://bugs.gw.com/view.php?id=551>`__ `[3] <http://bugs.gw.com/view.php?id=553>`__ `[4] <http://bugs.gw.com/view.php?id=554>`__ * file:`[1] <http://bugs.gw.com/view.php?id=550>`__ `[2] <http://bugs.gw.com/view.php?id=551>`__ `[3] <http://bugs.gw.com/view.php?id=553>`__ `[4] <http://bugs.gw.com/view.php?id=554>`__
* Radare2: `[1] <https://github.com/revskills?tab=contributions&from=2016-04-09>`__ * Radare2: `[1] <https://github.com/revskills?tab=contributions&from=2016-04-09>`__
* gRPC: `[1] <https://github.com/grpc/grpc/pull/6071/commits/df04c1f7f6aec6e95722ec0b023a6b29b6ea871c>`__ `[2] <https://github.com/grpc/grpc/pull/6071/commits/22a3dfd95468daa0db7245a4e8e6679a52847579>`__ `[3] <https://github.com/grpc/grpc/pull/6071/commits/9cac2a12d9e181d130841092e9d40fa3309d7aa7>`__ `[4] <https://github.com/grpc/grpc/pull/6012/commits/82a91c91d01ce9b999c8821ed13515883468e203>`__ `[5] <https://github.com/grpc/grpc/pull/6202/commits/2e3e0039b30edaf89fb93bfb2c1d0909098519fa>`__ `[6] <https://github.com/grpc/grpc/pull/6106/files>`__ * gRPC: `[1] <https://github.com/grpc/grpc/pull/6071/commits/df04c1f7f6aec6e95722ec0b023a6b29b6ea871c>`__ `[2] <https://github.com/grpc/grpc/pull/6071/commits/22a3dfd95468daa0db7245a4e8e6679a52847579>`__ `[3] <https://github.com/grpc/grpc/pull/6071/commits/9cac2a12d9e181d130841092e9d40fa3309d7aa7>`__ `[4] <https://github.com/grpc/grpc/pull/6012/commits/82a91c91d01ce9b999c8821ed13515883468e203>`__ `[5] <https://github.com/grpc/grpc/pull/6202/commits/2e3e0039b30edaf89fb93bfb2c1d0909098519fa>`__ `[6] <https://github.com/grpc/grpc/pull/6106/files>`__
* WOFF2: `[1] <https://github.com/google/woff2/commit/a15a8ab>`__ * WOFF2: `[1] <https://github.com/google/woff2/commit/a15a8ab>`__
* LLVM: `Clang <https://bugs.llvm.org/show_bug.cgi?id=23057>`_, `Clang-format <https://bugs.llvm.org/show_bug.cgi?id=23052>`_, `libc++ <https://bugs.llvm.org/show_bug.cgi?id=24411>`_, `llvm-as <https://bugs.llvm.org/show_bug.cgi?id=24639>`_, `Demangler <https://bugs.chromium.org/p/chromium/issues/detail?id=606626>`_, Disassembler: http://reviews.llvm.org/rL247405, http://reviews.llvm.org/rL247414, http://reviews.llvm.org/rL247416, http://reviews.llvm.org/rL247417, http://reviews.llvm.org/rL247420, http://reviews.llvm.org/rL247422. * LLVM: `Clang <https://bugs.llvm.org/show_bug.cgi?id=23057>`_, `Clang-format <https://bugs.llvm.org/show_bug.cgi?id=23052>`_, `libc++ <https://bugs.llvm.org/show_bug.cgi?id=24411>`_, `llvm-as <https://bugs.llvm.org/show_bug.cgi?id=24639>`_, `Demangler <https://bugs.chromium.org/p/chromium/issues/detail?id=606626>`_, Disassembler: https://reviews.llvm.org/rL247405, https://reviews.llvm.org/rL247414, https://reviews.llvm.org/rL247416, https://reviews.llvm.org/rL247417, https://reviews.llvm.org/rL247420, https://reviews.llvm.org/rL247422.
* Tensorflow: `[1] <https://da-data.blogspot.com/2017/01/finding-bugs-in-tensorflow-with.html>`__ * Tensorflow: `[1] <https://da-data.blogspot.com/2017/01/finding-bugs-in-tensorflow-with.html>`__
* Ffmpeg: `[1] <https://github.com/FFmpeg/FFmpeg/commit/c92f55847a3d9cd12db60bfcd0831ff7f089c37c>`__ `[2] <https://github.com/FFmpeg/FFmpeg/commit/25ab1a65f3acb5ec67b53fb7a2463a7368f1ad16>`__ `[3] <https://github.com/FFmpeg/FFmpeg/commit/85d23e5cbc9ad6835eef870a5b4247de78febe56>`__ `[4] <https://github.com/FFmpeg/FFmpeg/commit/04bd1b38ee6b8df410d0ab8d4949546b6c4af26a>`__ * Ffmpeg: `[1] <https://github.com/FFmpeg/FFmpeg/commit/c92f55847a3d9cd12db60bfcd0831ff7f089c37c>`__ `[2] <https://github.com/FFmpeg/FFmpeg/commit/25ab1a65f3acb5ec67b53fb7a2463a7368f1ad16>`__ `[3] <https://github.com/FFmpeg/FFmpeg/commit/85d23e5cbc9ad6835eef870a5b4247de78febe56>`__ `[4] <https://github.com/FFmpeg/FFmpeg/commit/04bd1b38ee6b8df410d0ab8d4949546b6c4af26a>`__
* `Wireshark <https://bugs.wireshark.org/bugzilla/buglist.cgi?bug_status=UNCONFIRMED&bug_status=CONFIRMED&bug_status=IN_PROGRESS&bug_status=INCOMPLETE&bug_status=RESOLVED&bug_status=VERIFIED&f0=OP&f1=OP&f2=product&f3=component&f4=alias&f5=short_desc&f7=content&f8=CP&f9=CP&j1=OR&o2=substring&o3=substring&o4=substring&o5=substring&o6=substring&o7=matches&order=bug_id%20DESC&query_format=advanced&v2=libfuzzer&v3=libfuzzer&v4=libfuzzer&v5=libfuzzer&v6=libfuzzer&v7=%22libfuzzer%22>`_ * `Wireshark <https://bugs.wireshark.org/bugzilla/buglist.cgi?bug_status=UNCONFIRMED&bug_status=CONFIRMED&bug_status=IN_PROGRESS&bug_status=INCOMPLETE&bug_status=RESOLVED&bug_status=VERIFIED&f0=OP&f1=OP&f2=product&f3=component&f4=alias&f5=short_desc&f7=content&f8=CP&f9=CP&j1=OR&o2=substring&o3=substring&o4=substring&o5=substring&o6=substring&o7=matches&order=bug_id%20DESC&query_format=advanced&v2=libfuzzer&v3=libfuzzer&v4=libfuzzer&v5=libfuzzer&v6=libfuzzer&v7=%22libfuzzer%22>`_
* `QEMU <https://researchcenter.paloaltonetworks.com/2017/09/unit42-palo-alto-networks-discovers-new-qemu-vulnerability/>`_ * `QEMU <https://researchcenter.paloaltonetworks.com/2017/09/unit42-palo-alto-networks-discovers-new-qemu-vulnerability/>`_
Show All 10 Lines
.. _3.7.0: https://llvm.org/releases/3.7.0/docs/LibFuzzer.html .. _3.7.0: https://llvm.org/releases/3.7.0/docs/LibFuzzer.html
.. _building Clang from trunk: https://clang.llvm.org/get_started.html .. _building Clang from trunk: https://clang.llvm.org/get_started.html
.. _MemorySanitizer: https://clang.llvm.org/docs/MemorySanitizer.html .. _MemorySanitizer: https://clang.llvm.org/docs/MemorySanitizer.html
.. _UndefinedBehaviorSanitizer: https://clang.llvm.org/docs/UndefinedBehaviorSanitizer.html .. _UndefinedBehaviorSanitizer: https://clang.llvm.org/docs/UndefinedBehaviorSanitizer.html
.. _`coverage counters`: https://clang.llvm.org/docs/SanitizerCoverage.html#coverage-counters .. _`coverage counters`: https://clang.llvm.org/docs/SanitizerCoverage.html#coverage-counters
.. _`value profile`: #value-profile .. _`value profile`: #value-profile
.. _`caller-callee pairs`: https://clang.llvm.org/docs/SanitizerCoverage.html#caller-callee-coverage .. _`caller-callee pairs`: https://clang.llvm.org/docs/SanitizerCoverage.html#caller-callee-coverage
.. _BoringSSL: https://boringssl.googlesource.com/boringssl/ .. _BoringSSL: https://boringssl.googlesource.com/boringssl/

llvm/docs/MeetupGuidelines.rst

Show All 21 Lines
* Beware of cultural differences: what works well in one region may not work in * Beware of cultural differences: what works well in one region may not work in
other part of the world. other part of the world.
* Do not be alone to organize the meetup. Try to work with a couple other * Do not be alone to organize the meetup. Try to work with a couple other
organizers. This is more motivating as an organizer, and this makes the organizers. This is more motivating as an organizer, and this makes the
meetup more resilient over time. meetup more resilient over time.
* Each event can have a different form such as a social event, or * Each event can have a different form such as a social event, or
a hackathon/workshop, or a 'mini-conference' with one or more talks. You do a hackathon/workshop, or a 'mini-conference' with one or more talks. You do
not have to stick to one format forever. not have to stick to one format forever.
* Whatever format you choose, `LLVM Weekly <http://llvmweekly.org/>`_ is an * Whatever format you choose, `LLVM Weekly <https://llvmweekly.org/>`_ is an
excellent topic starter: go through the 3-4 recent LLVM Weekly posts and excellent topic starter: go through the 3-4 recent LLVM Weekly posts and
prepare a list of the most interesting/notable news and discuss them with the prepare a list of the most interesting/notable news and discuss them with the
group. group.
Advertisement Advertisement
------------- -------------
* Try to advertise via similar meetups/user groups * Try to advertise via similar meetups/user groups
Show All 35 Lines* Make sure you do not clash with the similar meetups in the city (e.g.,
C++ user groups). C++ user groups).
* Prefer not to have a meetup the same week when the other similar meetups * Prefer not to have a meetup the same week when the other similar meetups
happen (e.g., it’s not a good idea to have LLVM meetup on Thursday after happen (e.g., it’s not a good idea to have LLVM meetup on Thursday after
C++ meetup on Wednesday). C++ meetup on Wednesday).
* Meetups on weekends may attract people who live far away from the city, * Meetups on weekends may attract people who live far away from the city,
but the people who live in the city may not attend. but the people who live in the city may not attend.
* Make a poll, but beware that not every responder will join (we had ~20 votes * Make a poll, but beware that not every responder will join (we had ~20 votes
on the poll, while only ~8 people attended). on the poll, while only ~8 people attended).

llvm/docs/MyFirstTypoFix.rst

Show First 20 Lines • Show All 333 Lines • ▼ Show 20 Lines
access.For larger and more complicated changes, it's important that the access.For larger and more complicated changes, it's important that the
reviewer has experience with the area of LLVM and knows the design goals reviewer has experience with the area of LLVM and knows the design goals
well. The author of a change will often assign a specific reviewer (git well. The author of a change will often assign a specific reviewer (git
blame and git log can be useful to find one). blame and git log can be useful to find one).
As our change is fairly simple, we'll add the cfe-commits mailing list As our change is fairly simple, we'll add the cfe-commits mailing list
as a subscriber; anyone who works on clang can likely pick up the as a subscriber; anyone who works on clang can likely pick up the
review. (For changes outside clang, llvm-commits is the usual list. See review. (For changes outside clang, llvm-commits is the usual list. See
`http://lists.llvm.org/ <http://lists.llvm.org/mailman/listinfo>`__ for `https://lists.llvm.org/ <https://lists.llvm.org/mailman/listinfo>`__ for
all the \*-commits mailing lists). all the \*-commits mailing lists).
Uploading a change for review Uploading a change for review
----------------------------- -----------------------------
LLVM code reviews happen at https://reviews.llvm.org. The web interface LLVM code reviews happen at https://reviews.llvm.org. The web interface
is called Phabricator, and the code review part is Differential. You is called Phabricator, and the code review part is Differential. You
▲ Show 20 Lines • Show All 170 Lines • ▼ Show 20 Lines
Post-commit errors Post-commit errors
------------------ ------------------
Once your change is submitted it will be picked up by automated build Once your change is submitted it will be picked up by automated build
bots that will build and test your patch in a variety of configurations. bots that will build and test your patch in a variety of configurations.
You can see all configurations and their current state in a waterfall You can see all configurations and their current state in a waterfall
view at http://lab.llvm.org/buildbot/#/waterfall. The waterfall view is good view at https://lab.llvm.org/buildbot/#/waterfall. The waterfall view is good
to get a general overview over the tested configurations and to see to get a general overview over the tested configurations and to see
which configuration have been broken for a while. which configuration have been broken for a while.
The console view at http://lab.llvm.org/buildbot/#/console helps to get a The console view at https://lab.llvm.org/buildbot/#/console helps to get a
better understanding of the build results of a specific patch. If you better understanding of the build results of a specific patch. If you
want to follow along how your change is affecting the build bots, **this want to follow along how your change is affecting the build bots, **this
should be the first place to look at** - the colored bubbles correspond should be the first place to look at** - the colored bubbles correspond
to projects in the waterfall. to projects in the waterfall.
If you see a broken build, do not despair - some build bots are If you see a broken build, do not despair - some build bots are
continuously broken; if your change broke the build, you will see a red continuously broken; if your change broke the build, you will see a red
bubble in the console view, while an already broken build will show an bubble in the console view, while an already broken build will show an
Show All 22 Lines

llvm/docs/Projects.rst

Show First 20 Lines • Show All 248 Lines • ▼ Show 20 LinesExecutables
profiled build, respectively. profiled build, respectively.
Further Help Further Help
============ ============
If you have any questions or need any help creating an LLVM project, the LLVM If you have any questions or need any help creating an LLVM project, the LLVM
team would be more than happy to help. You can always post your questions to team would be more than happy to help. You can always post your questions to
the `LLVM Developers Mailing List the `LLVM Developers Mailing List
<http://lists.llvm.org/pipermail/llvm-dev/>`_. <https://lists.llvm.org/pipermail/llvm-dev/>`_.

llvm/docs/Proposals/GitHubMove.rst

Show First 20 Lines • Show All 1,073 Lines • ▼ Show 20 Linesas possible. Here is one way to do it::
git -C my-monorepo prune git -C my-monorepo prune
You should now have a trim monorepo. Upload it to your git server and You should now have a trim monorepo. Upload it to your git server and
happy hacking! happy hacking!
References References
========== ==========
.. [LattnerRevNum] Chris Lattner, http://lists.llvm.org/pipermail/llvm-dev/2011-July/041739.html .. [LattnerRevNum] Chris Lattner, https://lists.llvm.org/pipermail/llvm-dev/2011-July/041739.html
.. [TrickRevNum] Andrew Trick, http://lists.llvm.org/pipermail/llvm-dev/2011-July/041721.html .. [TrickRevNum] Andrew Trick, https://lists.llvm.org/pipermail/llvm-dev/2011-July/041721.html
.. [JSonnRevNum] Joerg Sonnenberger, http://lists.llvm.org/pipermail/llvm-dev/2011-July/041688.html .. [JSonnRevNum] Joerg Sonnenberger, https://lists.llvm.org/pipermail/llvm-dev/2011-July/041688.html
.. [MatthewsRevNum] Chris Matthews, http://lists.llvm.org/pipermail/cfe-dev/2016-July/049886.html .. [MatthewsRevNum] Chris Matthews, https://lists.llvm.org/pipermail/cfe-dev/2016-July/049886.html
.. [statuschecks] GitHub status-checks, https://help.github.com/articles/about-required-status-checks/ .. [statuschecks] GitHub status-checks, https://help.github.com/articles/about-required-status-checks/

llvm/docs/Proposals/VariableNames.rst

=================== ===================
Variable Names Plan Variable Names Plan
=================== ===================
.. contents:: .. contents::
:local: :local:
This plan is *provisional*. It is not agreed upon. It is written with the This plan is *provisional*. It is not agreed upon. It is written with the
intention of capturing the desires and concerns of the LLVM community, and intention of capturing the desires and concerns of the LLVM community, and
forming them into a plan that can be agreed upon. forming them into a plan that can be agreed upon.
The original author is somewhat naïve in the ways of LLVM so there will The original author is somewhat naïve in the ways of LLVM so there will
inevitably be some details that are flawed. You can help - you can edit this inevitably be some details that are flawed. You can help - you can edit this
page (preferably with a Phabricator review for larger changes) or reply to the page (preferably with a Phabricator review for larger changes) or reply to the
`Request For Comments thread `Request For Comments thread
<http://lists.llvm.org/pipermail/llvm-dev/2019-February/130083.html>`_. <https://lists.llvm.org/pipermail/llvm-dev/2019-February/130083.html>`_.
Too Long; Didn't Read Too Long; Didn't Read
===================== =====================
Improve the readability of LLVM code. Improve the readability of LLVM code.
Introduction Introduction
============ ============
▲ Show 20 Lines • Show All 329 Lines • ▼ Show 20 Lines
.. [Google] Google C++ Style Guide https://google.github.io/styleguide/cppguide.html#Variable_Names .. [Google] Google C++ Style Guide https://google.github.io/styleguide/cppguide.html#Variable_Names
.. [WebKit] WebKit Code Style Guidelines https://webkit.org/code-style-guidelines/#names .. [WebKit] WebKit Code Style Guidelines https://webkit.org/code-style-guidelines/#names
.. [Qt] Qt Coding Style https://wiki.qt.io/Qt_Coding_Style#Declaring_variables .. [Qt] Qt Coding Style https://wiki.qt.io/Qt_Coding_Style#Declaring_variables
.. [Rust] Rust naming conventions https://doc.rust-lang.org/1.0.0/style/style/naming/README.html .. [Rust] Rust naming conventions https://doc.rust-lang.org/1.0.0/style/style/naming/README.html
.. [Swift] Swift API Design Guidelines https://swift.org/documentation/api-design-guidelines/#general-conventions .. [Swift] Swift API Design Guidelines https://swift.org/documentation/api-design-guidelines/#general-conventions
.. [Python] Style Guide for Python Code https://www.python.org/dev/peps/pep-0008/#function-and-variable-names .. [Python] Style Guide for Python Code https://www.python.org/dev/peps/pep-0008/#function-and-variable-names
.. [Mozilla] Mozilla Coding style: Prefixes https://firefox-source-docs.mozilla.org/tools/lint/coding-style/coding_style_cpp.html#prefixes .. [Mozilla] Mozilla Coding style: Prefixes https://firefox-source-docs.mozilla.org/tools/lint/coding-style/coding_style_cpp.html#prefixes
.. [SVE] LLVM with support for SVE https://github.com/ARM-software/LLVM-SVE .. [SVE] LLVM with support for SVE https://github.com/ARM-software/LLVM-SVE
.. [AminiInconsistent] Mehdi Amini, http://lists.llvm.org/pipermail/llvm-dev/2019-February/130329.html .. [AminiInconsistent] Mehdi Amini, https://lists.llvm.org/pipermail/llvm-dev/2019-February/130329.html
.. [ArsenaultAgree] Matt Arsenault, http://lists.llvm.org/pipermail/llvm-dev/2019-February/129934.html .. [ArsenaultAgree] Matt Arsenault, https://lists.llvm.org/pipermail/llvm-dev/2019-February/129934.html
.. [BeylsDistinguish] Kristof Beyls, http://lists.llvm.org/pipermail/llvm-dev/2019-February/130292.html .. [BeylsDistinguish] Kristof Beyls, https://lists.llvm.org/pipermail/llvm-dev/2019-February/130292.html
.. [BradburyConcern] Alex Bradbury, http://lists.llvm.org/pipermail/llvm-dev/2019-February/130266.html .. [BradburyConcern] Alex Bradbury, https://lists.llvm.org/pipermail/llvm-dev/2019-February/130266.html
.. [BradburyTransition] Alex Bradbury, http://lists.llvm.org/pipermail/llvm-dev/2019-February/130388.html .. [BradburyTransition] Alex Bradbury, https://lists.llvm.org/pipermail/llvm-dev/2019-February/130388.html
.. [CarruthAcronym] Chandler Carruth, http://lists.llvm.org/pipermail/llvm-dev/2019-February/130313.html .. [CarruthAcronym] Chandler Carruth, https://lists.llvm.org/pipermail/llvm-dev/2019-February/130313.html
.. [CarruthCamelBack] Chandler Carruth, http://lists.llvm.org/pipermail/llvm-dev/2019-February/130214.html .. [CarruthCamelBack] Chandler Carruth, https://lists.llvm.org/pipermail/llvm-dev/2019-February/130214.html
.. [CarruthDistinguish] Chandler Carruth, http://lists.llvm.org/pipermail/llvm-dev/2019-February/130310.html .. [CarruthDistinguish] Chandler Carruth, https://lists.llvm.org/pipermail/llvm-dev/2019-February/130310.html
.. [CarruthFunction] Chandler Carruth, http://lists.llvm.org/pipermail/llvm-dev/2019-February/130309.html .. [CarruthFunction] Chandler Carruth, https://lists.llvm.org/pipermail/llvm-dev/2019-February/130309.html
.. [CarruthInconsistent] Chandler Carruth, http://lists.llvm.org/pipermail/llvm-dev/2019-February/130312.html .. [CarruthInconsistent] Chandler Carruth, https://lists.llvm.org/pipermail/llvm-dev/2019-February/130312.html
.. [CarruthLower] Chandler Carruth, http://lists.llvm.org/pipermail/llvm-dev/2019-February/130430.html .. [CarruthLower] Chandler Carruth, https://lists.llvm.org/pipermail/llvm-dev/2019-February/130430.html
.. [DasInconsistent] Sanjoy Das, http://lists.llvm.org/pipermail/llvm-dev/2019-February/130304.html .. [DasInconsistent] Sanjoy Das, https://lists.llvm.org/pipermail/llvm-dev/2019-February/130304.html
.. [DenisovCamelBack] Alex Denisov, http://lists.llvm.org/pipermail/llvm-dev/2019-February/130179.html .. [DenisovCamelBack] Alex Denisov, https://lists.llvm.org/pipermail/llvm-dev/2019-February/130179.html
.. [EmersonConcern] Amara Emerson, http://lists.llvm.org/pipermail/llvm-dev/2019-February/129894.html .. [EmersonConcern] Amara Emerson, https://lists.llvm.org/pipermail/llvm-dev/2019-February/129894.html
.. [GreeneDistinguish] David Greene, http://lists.llvm.org/pipermail/llvm-dev/2019-February/130425.html .. [GreeneDistinguish] David Greene, https://lists.llvm.org/pipermail/llvm-dev/2019-February/130425.html
.. [GreeneGitBlame] David Greene, http://lists.llvm.org/pipermail/llvm-dev/2019-February/130228.html .. [GreeneGitBlame] David Greene, https://lists.llvm.org/pipermail/llvm-dev/2019-February/130228.html
.. [HendersonPrefix] James Henderson, http://lists.llvm.org/pipermail/llvm-dev/2019-February/130465.html .. [HendersonPrefix] James Henderson, https://lists.llvm.org/pipermail/llvm-dev/2019-February/130465.html
.. [HähnleDistinguish] Nicolai Hähnle, http://lists.llvm.org/pipermail/llvm-dev/2019-February/129923.html .. [HähnleDistinguish] Nicolai Hähnle, https://lists.llvm.org/pipermail/llvm-dev/2019-February/129923.html
.. [IvanovicDistinguish] Nemanja Ivanovic, http://lists.llvm.org/pipermail/llvm-dev/2019-February/130249.html .. [IvanovicDistinguish] Nemanja Ivanovic, https://lists.llvm.org/pipermail/llvm-dev/2019-February/130249.html
.. [JonesDistinguish] JD Jones, http://lists.llvm.org/pipermail/llvm-dev/2019-February/129926.html .. [JonesDistinguish] JD Jones, https://lists.llvm.org/pipermail/llvm-dev/2019-February/129926.html
.. [LattnerAcronym] Chris Lattner, http://lists.llvm.org/pipermail/llvm-dev/2019-February/130353.html .. [LattnerAcronym] Chris Lattner, https://lists.llvm.org/pipermail/llvm-dev/2019-February/130353.html
.. [LattnerAgree] Chris Latter, http://lists.llvm.org/pipermail/llvm-dev/2019-February/129907.html .. [LattnerAgree] Chris Latter, https://lists.llvm.org/pipermail/llvm-dev/2019-February/129907.html
.. [LattnerFunction] Chris Lattner, http://lists.llvm.org/pipermail/llvm-dev/2019-February/130630.html .. [LattnerFunction] Chris Lattner, https://lists.llvm.org/pipermail/llvm-dev/2019-February/130630.html
.. [LattnerLower] Chris Lattner, http://lists.llvm.org/pipermail/llvm-dev/2019-February/130629.html .. [LattnerLower] Chris Lattner, https://lists.llvm.org/pipermail/llvm-dev/2019-February/130629.html
.. [LattnerTransition] Chris Lattner, http://lists.llvm.org/pipermail/llvm-dev/2019-February/130355.html .. [LattnerTransition] Chris Lattner, https://lists.llvm.org/pipermail/llvm-dev/2019-February/130355.html
.. [MalyutinDistinguish] Danila Malyutin, http://lists.llvm.org/pipermail/llvm-dev/2019-February/130320.html .. [MalyutinDistinguish] Danila Malyutin, https://lists.llvm.org/pipermail/llvm-dev/2019-February/130320.html
.. [ParzyszekAcronym] Krzysztof Parzyszek, http://lists.llvm.org/pipermail/llvm-dev/2019-February/130306.html .. [ParzyszekAcronym] Krzysztof Parzyszek, https://lists.llvm.org/pipermail/llvm-dev/2019-February/130306.html
.. [ParzyszekAcronym2] Krzysztof Parzyszek, http://lists.llvm.org/pipermail/llvm-dev/2019-February/130323.html .. [ParzyszekAcronym2] Krzysztof Parzyszek, https://lists.llvm.org/pipermail/llvm-dev/2019-February/130323.html
.. [ParzyszekDistinguish] Krzysztof Parzyszek, http://lists.llvm.org/pipermail/llvm-dev/2019-February/129941.html .. [ParzyszekDistinguish] Krzysztof Parzyszek, https://lists.llvm.org/pipermail/llvm-dev/2019-February/129941.html
.. [PicusAcronym] Diana Picus, http://lists.llvm.org/pipermail/llvm-dev/2019-February/130318.html .. [PicusAcronym] Diana Picus, https://lists.llvm.org/pipermail/llvm-dev/2019-February/130318.html
.. [ReamesConcern] Philip Reames, http://lists.llvm.org/pipermail/llvm-dev/2019-February/130181.html .. [ReamesConcern] Philip Reames, https://lists.llvm.org/pipermail/llvm-dev/2019-February/130181.html
.. [RicciAcronyms] Bruno Ricci, http://lists.llvm.org/pipermail/llvm-dev/2019-February/130328.html .. [RicciAcronyms] Bruno Ricci, https://lists.llvm.org/pipermail/llvm-dev/2019-February/130328.html
.. [RobinsonAgree] Paul Robinson, http://lists.llvm.org/pipermail/llvm-dev/2019-February/130111.html .. [RobinsonAgree] Paul Robinson, https://lists.llvm.org/pipermail/llvm-dev/2019-February/130111.html
.. [RobinsonDistinguish] Paul Robinson, http://lists.llvm.org/pipermail/llvm-dev/2019-February/129920.html .. [RobinsonDistinguish] Paul Robinson, https://lists.llvm.org/pipermail/llvm-dev/2019-February/129920.html
.. [RobinsonDistinguish2] Paul Robinson, http://lists.llvm.org/pipermail/llvm-dev/2019-February/130229.html .. [RobinsonDistinguish2] Paul Robinson, https://lists.llvm.org/pipermail/llvm-dev/2019-February/130229.html
.. [RobinsonTransition] Paul Robinson, http://lists.llvm.org/pipermail/llvm-dev/2019-February/130415.html .. [RobinsonTransition] Paul Robinson, https://lists.llvm.org/pipermail/llvm-dev/2019-February/130415.html
.. [TurnerCamelBack] Zachary Turner, https://reviews.llvm.org/D57896#1402264 .. [TurnerCamelBack] Zachary Turner, https://reviews.llvm.org/D57896#1402264
.. [TurnerLLDB] Zachary Turner, http://lists.llvm.org/pipermail/llvm-dev/2019-February/130213.html .. [TurnerLLDB] Zachary Turner, https://lists.llvm.org/pipermail/llvm-dev/2019-February/130213.html
.. [Ueyama] Rui Ueyama, http://lists.llvm.org/pipermail/llvm-dev/2019-February/130435.html .. [Ueyama] Rui Ueyama, https://lists.llvm.org/pipermail/llvm-dev/2019-February/130435.html

llvm/docs/Proposals/VectorizationPlan.rst

Show First 20 Lines • Show All 218 Lines • ▼ Show 20 Lines
References References
---------- ----------
.. [1] "Outer-loop vectorization: revisited for short SIMD architectures", Dorit .. [1] "Outer-loop vectorization: revisited for short SIMD architectures", Dorit
Nuzman and Ayal Zaks, PACT 2008. Nuzman and Ayal Zaks, PACT 2008.
.. [2] "Proposal for function vectorization and loop vectorization with function .. [2] "Proposal for function vectorization and loop vectorization with function
calls", Xinmin Tian, [`cfe-dev calls", Xinmin Tian, [`cfe-dev
<http://lists.llvm.org/pipermail/cfe-dev/2016-March/047732.html>`_]., <https://lists.llvm.org/pipermail/cfe-dev/2016-March/047732.html>`_].,
March 2, 2016. March 2, 2016.
See also `review <https://reviews.llvm.org/D22792>`_. See also `review <https://reviews.llvm.org/D22792>`_.
.. [3] "Throttling Automatic Vectorization: When Less is More", Vasileios .. [3] "Throttling Automatic Vectorization: When Less is More", Vasileios
Porpodas and Tim Jones, PACT 2015 and LLVM Developers' Meeting 2015. Porpodas and Tim Jones, PACT 2015 and LLVM Developers' Meeting 2015.
.. [4] "Exploiting mixed SIMD parallelism by reducing data reorganization .. [4] "Exploiting mixed SIMD parallelism by reducing data reorganization
overhead", Hao Zhou and Jingling Xue, CGO 2016. overhead", Hao Zhou and Jingling Xue, CGO 2016.
Show All 15 Lines

llvm/docs/Statepoints.rst

Show First 20 Lines • Show All 799 Lines • ▼ Show 20 Lines
Currently known bugs and enhancements under consideration can be Currently known bugs and enhancements under consideration can be
tracked by performing a `bugzilla search tracked by performing a `bugzilla search
<https://bugs.llvm.org/buglist.cgi?cmdtype=runnamed&namedcmd=Statepoint%20Bugs&list_id=64342>`_ <https://bugs.llvm.org/buglist.cgi?cmdtype=runnamed&namedcmd=Statepoint%20Bugs&list_id=64342>`_
for [Statepoint] in the summary field. When filing new bugs, please for [Statepoint] in the summary field. When filing new bugs, please
use this tag so that interested parties see the newly filed bug. As use this tag so that interested parties see the newly filed bug. As
with most LLVM features, design discussions take place on the `Discourse forums <https://discourse.llvm.org>`_ and patches with most LLVM features, design discussions take place on the `Discourse forums <https://discourse.llvm.org>`_ and patches
should be sent to `llvm-commits should be sent to `llvm-commits
<http://lists.llvm.org/mailman/listinfo/llvm-commits>`_ for review. <https://lists.llvm.org/mailman/listinfo/llvm-commits>`_ for review.

llvm/docs/TestSuiteGuide.md

Show First 20 Lines • Show All 288 Lines • ▼ Show 20 Lines- Merge multiple baseline and experiment result files by taking the minimum
% test-suite/utils/compare.py base0.json base1.json base2.json vs exp0.json exp1.json exp2.json % test-suite/utils/compare.py base0.json base1.json base2.json vs exp0.json exp1.json exp2.json
``` ```
### Continuous Tracking with LNT ### Continuous Tracking with LNT
LNT is a set of client and server tools for continuously monitoring LNT is a set of client and server tools for continuously monitoring
performance. You can find more information at performance. You can find more information at
[https://llvm.org/docs/lnt](https://llvm.org/docs/lnt). The official LNT instance [https://llvm.org/docs/lnt](https://llvm.org/docs/lnt). The official LNT instance
of the LLVM project is hosted at [http://lnt.llvm.org](http://lnt.llvm.org). of the LLVM project is hosted at [https://lnt.llvm.org](https://lnt.llvm.org).
External Suites External Suites
--------------- ---------------
External suites such as SPEC can be enabled by either External suites such as SPEC can be enabled by either
- placing (or linking) them into the `test-suite/test-suite-externals/xxx` directory (example: `test-suite/test-suite-externals/speccpu2000`) - placing (or linking) them into the `test-suite/test-suite-externals/xxx` directory (example: `test-suite/test-suite-externals/speccpu2000`)
▲ Show 20 Lines • Show All 113 Lines • Show Last 20 Lines

llvm/include/llvm-c/Core.h

Show First 20 Lines • Show All 580 Lines • ▼ Show 20 Lines
unsigned LLVMGetMDKindIDInContext(LLVMContextRef C, const char *Name, unsigned LLVMGetMDKindIDInContext(LLVMContextRef C, const char *Name,
unsigned SLen); unsigned SLen);
unsigned LLVMGetMDKindID(const char *Name, unsigned SLen); unsigned LLVMGetMDKindID(const char *Name, unsigned SLen);
/** /**
* Return an unique id given the name of a enum attribute, * Return an unique id given the name of a enum attribute,
* or 0 if no attribute by that name exists. * or 0 if no attribute by that name exists.
* *
* See http://llvm.org/docs/LangRef.html#parameter-attributes * See https://llvm.org/docs/LangRef.html#parameter-attributes
* and http://llvm.org/docs/LangRef.html#function-attributes * and https://llvm.org/docs/LangRef.html#function-attributes
* for the list of available attributes. * for the list of available attributes.
* *
* NB: Attribute names and/or id are subject to change without * NB: Attribute names and/or id are subject to change without
* going through the C API deprecation cycle. * going through the C API deprecation cycle.
*/ */
unsigned LLVMGetEnumAttributeKindForName(const char *Name, size_t SLen); unsigned LLVMGetEnumAttributeKindForName(const char *Name, size_t SLen);
unsigned LLVMGetLastEnumAttributeKind(void); unsigned LLVMGetLastEnumAttributeKind(void);
▲ Show 20 Lines • Show All 3,655 Lines • Show Last 20 Lines

llvm/include/llvm/Analysis/AliasAnalysis.h

Show First 20 Lines • Show All 835 Lines • ▼ Show 20 Linespublic:
} }
/// Return information about whether a call and an instruction may refer to /// Return information about whether a call and an instruction may refer to
/// the same memory locations. /// the same memory locations.
ModRefInfo getModRefInfo(Instruction *I, const CallBase *Call); ModRefInfo getModRefInfo(Instruction *I, const CallBase *Call);
/// Return information about whether two call sites may refer to the same set /// Return information about whether two call sites may refer to the same set
/// of memory locations. See the AA documentation for details: /// of memory locations. See the AA documentation for details:
/// http://llvm.org/docs/AliasAnalysis.html#ModRefInfo /// https://llvm.org/docs/AliasAnalysis.html#ModRefInfo
ModRefInfo getModRefInfo(const CallBase *Call1, const CallBase *Call2); ModRefInfo getModRefInfo(const CallBase *Call1, const CallBase *Call2);
/// Return information about whether a particular call site modifies /// Return information about whether a particular call site modifies
/// or reads the specified memory location \p MemLoc before instruction \p I /// or reads the specified memory location \p MemLoc before instruction \p I
/// in a BasicBlock. /// in a BasicBlock.
/// Early exits in callCapturesBefore may lead to ModRefInfo::Must not being /// Early exits in callCapturesBefore may lead to ModRefInfo::Must not being
/// set. /// set.
ModRefInfo callCapturesBefore(const Instruction *I, ModRefInfo callCapturesBefore(const Instruction *I,
▲ Show 20 Lines • Show All 203 Lines • ▼ Show 20 Linespublic:
/// getModRefInfo (for call sites) - Return information about whether /// getModRefInfo (for call sites) - Return information about whether
/// a particular call site modifies or reads the specified memory location. /// a particular call site modifies or reads the specified memory location.
virtual ModRefInfo getModRefInfo(const CallBase *Call, virtual ModRefInfo getModRefInfo(const CallBase *Call,
const MemoryLocation &Loc, const MemoryLocation &Loc,
AAQueryInfo &AAQI) = 0; AAQueryInfo &AAQI) = 0;
/// Return information about whether two call sites may refer to the same set /// Return information about whether two call sites may refer to the same set
/// of memory locations. See the AA documentation for details: /// of memory locations. See the AA documentation for details:
/// http://llvm.org/docs/AliasAnalysis.html#ModRefInfo /// https://llvm.org/docs/AliasAnalysis.html#ModRefInfo
virtual ModRefInfo getModRefInfo(const CallBase *Call1, const CallBase *Call2, virtual ModRefInfo getModRefInfo(const CallBase *Call1, const CallBase *Call2,
AAQueryInfo &AAQI) = 0; AAQueryInfo &AAQI) = 0;
/// @} /// @}
}; };
/// A private class template which derives from \c Concept and wraps some other /// A private class template which derives from \c Concept and wraps some other
/// type. /// type.
▲ Show 20 Lines • Show All 336 Lines • Show Last 20 Lines

llvm/include/llvm/Analysis/MemoryLocation.h

Show First 20 Lines • Show All 217 Lines • ▼ Show 20 Linespublic:
const Value *Ptr; const Value *Ptr;
/// The maximum size of the location, in address-units, or /// The maximum size of the location, in address-units, or
/// UnknownSize if the size is not known. /// UnknownSize if the size is not known.
/// ///
/// Note that an unknown size does not mean the pointer aliases the entire /// Note that an unknown size does not mean the pointer aliases the entire
/// virtual address space, because there are restrictions on stepping out of /// virtual address space, because there are restrictions on stepping out of
/// one object and into another. See /// one object and into another. See
/// http://llvm.org/docs/LangRef.html#pointeraliasing /// https://llvm.org/docs/LangRef.html#pointeraliasing
LocationSize Size; LocationSize Size;
/// The metadata nodes which describes the aliasing of the location (each /// The metadata nodes which describes the aliasing of the location (each
/// member is null if that kind of information is unavailable). /// member is null if that kind of information is unavailable).
AAMDNodes AATags; AAMDNodes AATags;
void print(raw_ostream &OS) const { OS << *Ptr << " " << Size << "\n"; } void print(raw_ostream &OS) const { OS << *Ptr << " " << Size << "\n"; }
▲ Show 20 Lines • Show All 119 Lines • Show Last 20 Lines

llvm/include/llvm/Bitcode/BitcodeConvenience.h

Show All 17 Lines
/// BCFixed<16>, // Module format minor version /// BCFixed<16>, // Module format minor version
/// BCBlob // misc. version information /// BCBlob // misc. version information
/// >; /// >;
/// Metadata metadata(Out); /// Metadata metadata(Out);
/// metadata.emit(ScratchRecord, VERSION_MAJOR, VERSION_MINOR, Data); /// metadata.emit(ScratchRecord, VERSION_MAJOR, VERSION_MINOR, Data);
/// \endcode /// \endcode
/// ///
/// For details on the bitcode format, see /// For details on the bitcode format, see
/// http://llvm.org/docs/BitCodeFormat.html /// https://llvm.org/docs/BitCodeFormat.html
/// ///
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_BITCODE_BITCODECONVENIENCE_H #ifndef LLVM_BITCODE_BITCODECONVENIENCE_H
#define LLVM_BITCODE_BITCODECONVENIENCE_H #define LLVM_BITCODE_BITCODECONVENIENCE_H
#include "llvm/Bitstream/BitCodes.h" #include "llvm/Bitstream/BitCodes.h"
#include "llvm/Bitstream/BitstreamWriter.h" #include "llvm/Bitstream/BitstreamWriter.h"
▲ Show 20 Lines • Show All 77 Lines • ▼ Show 20 Linespublic:
} }
}; };
/// Represents a character encoded in LLVM's Char6 encoding. /// Represents a character encoded in LLVM's Char6 encoding.
/// ///
/// This format is suitable for encoding decimal numbers (without signs or /// This format is suitable for encoding decimal numbers (without signs or
/// exponents) and C identifiers (without dollar signs), but not much else. /// exponents) and C identifiers (without dollar signs), but not much else.
/// ///
/// \sa http://llvm.org/docs/BitCodeFormat.html#char6-encoded-value /// \sa https://llvm.org/docs/BitCodeFormat.html#char6-encoded-value
class BCChar6 : public detail::BCField<> { class BCChar6 : public detail::BCField<> {
public: public:
static void emitOp(llvm::BitCodeAbbrev &abbrev) { static void emitOp(llvm::BitCodeAbbrev &abbrev) {
abbrev.Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Char6)); abbrev.Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Char6));
} }
template <typename T> static void assertValid(const T &data) { template <typename T> static void assertValid(const T &data) {
assert(llvm::BitCodeAbbrevOp::isChar6(data) && "invalid Char6 data"); assert(llvm::BitCodeAbbrevOp::isChar6(data) && "invalid Char6 data");
▲ Show 20 Lines • Show All 358 Lines • Show Last 20 Lines

llvm/include/llvm/ExecutionEngine/ExecutionEngine.h

Show First 20 Lines • Show All 448 Lines • ▼ Show 20 Linespublic:
/// first called. If lazy compilation is turned off again while some lazy /// first called. If lazy compilation is turned off again while some lazy
/// stubs are still around, and one of those stubs is called, the program will /// stubs are still around, and one of those stubs is called, the program will
/// abort. /// abort.
/// ///
/// In order to safely compile lazily in a threaded program, the user must /// In order to safely compile lazily in a threaded program, the user must
/// ensure that 1) only one thread at a time can call any particular lazy /// ensure that 1) only one thread at a time can call any particular lazy
/// stub, and 2) any thread modifying LLVM IR must hold the JIT's lock /// stub, and 2) any thread modifying LLVM IR must hold the JIT's lock
/// (ExecutionEngine::lock) or otherwise ensure that no other thread calls a /// (ExecutionEngine::lock) or otherwise ensure that no other thread calls a
/// lazy stub. See http://llvm.org/PR5184 for details. /// lazy stub. See https://llvm.org/PR5184 for details.
void DisableLazyCompilation(bool Disabled = true) { void DisableLazyCompilation(bool Disabled = true) {
CompilingLazily = !Disabled; CompilingLazily = !Disabled;
} }
bool isCompilingLazily() const { bool isCompilingLazily() const {
return CompilingLazily; return CompilingLazily;
} }
/// DisableGVCompilation - If called, the JIT will abort if it's asked to /// DisableGVCompilation - If called, the JIT will abort if it's asked to
▲ Show 20 Lines • Show All 204 Lines • Show Last 20 Lines

llvm/include/llvm/IR/ModuleSummaryIndex.h

Show First 20 Lines • Show All 958 Lines • ▼ Show 20 Lines ArrayRef<VirtFuncOffset> vTableFuncs() const {
if (VTableFuncs) if (VTableFuncs)
return *VTableFuncs; return *VTableFuncs;
return {}; return {};
} }
}; };
struct TypeTestResolution { struct TypeTestResolution {
/// Specifies which kind of type check we should emit for this byte array. /// Specifies which kind of type check we should emit for this byte array.
/// See http://clang.llvm.org/docs/ControlFlowIntegrityDesign.html for full /// See https://clang.llvm.org/docs/ControlFlowIntegrityDesign.html for full
/// details on each kind of check; the enumerators are described with /// details on each kind of check; the enumerators are described with
/// reference to that document. /// reference to that document.
enum Kind { enum Kind {
Unsat, ///< Unsatisfiable type (i.e. no global has this type metadata) Unsat, ///< Unsatisfiable type (i.e. no global has this type metadata)
ByteArray, ///< Test a byte array (first example) ByteArray, ///< Test a byte array (first example)
Inline, ///< Inlined bit vector ("Short Inline Bit Vectors") Inline, ///< Inlined bit vector ("Short Inline Bit Vectors")
Single, ///< Single element (last example in "Short Inline Bit Vectors") Single, ///< Single element (last example in "Short Inline Bit Vectors")
AllOnes, ///< All-ones bit vector ("Eliminating Bit Vector Checks for AllOnes, ///< All-ones bit vector ("Eliminating Bit Vector Checks for
▲ Show 20 Lines • Show All 689 Lines • Show Last 20 Lines

llvm/include/llvm/IR/Use.h

Show All 11 Lines
/// class keeps the "use list" of the referenced value up to date. /// class keeps the "use list" of the referenced value up to date.
/// ///
/// Pointer tagging is used to efficiently find the User corresponding to a Use /// Pointer tagging is used to efficiently find the User corresponding to a Use
/// without having to store a User pointer in every Use. A User is preceded in /// without having to store a User pointer in every Use. A User is preceded in
/// memory by all the Uses corresponding to its operands, and the low bits of /// memory by all the Uses corresponding to its operands, and the low bits of
/// one of the fields (Prev) of the Use class are used to encode offsets to be /// one of the fields (Prev) of the Use class are used to encode offsets to be
/// able to find that User given a pointer to any Use. For details, see: /// able to find that User given a pointer to any Use. For details, see:
/// ///
/// http://www.llvm.org/docs/ProgrammersManual.html#UserLayout /// https://www.llvm.org/docs/ProgrammersManual.html#UserLayout
/// ///
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_IR_USE_H #ifndef LLVM_IR_USE_H
#define LLVM_IR_USE_H #define LLVM_IR_USE_H
#include "llvm-c/Types.h" #include "llvm-c/Types.h"
#include "llvm/Support/CBindingWrapping.h" #include "llvm/Support/CBindingWrapping.h"
▲ Show 20 Lines • Show All 103 Lines • Show Last 20 Lines

llvm/include/llvm/Support/ManagedStatic.h

Show All 34 Lines
// ManagedStatic must be initialized to zero, and it must *not* have a dynamic // ManagedStatic must be initialized to zero, and it must *not* have a dynamic
// initializer because managed statics are often created while running other // initializer because managed statics are often created while running other
// dynamic initializers. In standard C++11, the best way to accomplish this is // dynamic initializers. In standard C++11, the best way to accomplish this is
// with a constexpr default constructor. However, different versions of the // with a constexpr default constructor. However, different versions of the
// Visual C++ compiler have had bugs where, even though the constructor may be // Visual C++ compiler have had bugs where, even though the constructor may be
// constexpr, a dynamic initializer may be emitted depending on optimization // constexpr, a dynamic initializer may be emitted depending on optimization
// settings. For the affected versions of MSVC, use the old linker // settings. For the affected versions of MSVC, use the old linker
// initialization pattern of not providing a constructor and leaving the fields // initialization pattern of not providing a constructor and leaving the fields
// uninitialized. See http://llvm.org/PR41367 for details. // uninitialized. See https://llvm.org/PR41367 for details.
#if !defined(_MSC_VER) || (_MSC_VER >= 1925) || defined(__clang__) #if !defined(_MSC_VER) || (_MSC_VER >= 1925) || defined(__clang__)
#define LLVM_USE_CONSTEXPR_CTOR #define LLVM_USE_CONSTEXPR_CTOR
#endif #endif
/// ManagedStaticBase - Common base class for ManagedStatic instances. /// ManagedStaticBase - Common base class for ManagedStatic instances.
class ManagedStaticBase { class ManagedStaticBase {
protected: protected:
#ifdef LLVM_USE_CONSTEXPR_CTOR #ifdef LLVM_USE_CONSTEXPR_CTOR
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

llvm/include/llvm/Transforms/IPO/Attributor.h

Show First 20 Lines • Show All 2,815 Lines • ▼ Show 20 Lines if (isa<UndefValue>(IRP.getAssociatedValue()) ||
return; return;
} }
bool IsFnInterface = IRP.isFnInterfaceKind(); bool IsFnInterface = IRP.isFnInterfaceKind();
const Function *FnScope = IRP.getAnchorScope(); const Function *FnScope = IRP.getAnchorScope();
// TODO: Not all attributes require an exact definition. Find a way to // TODO: Not all attributes require an exact definition. Find a way to
// enable deduction for some but not all attributes in case the // enable deduction for some but not all attributes in case the
// definition might be changed at runtime, see also // definition might be changed at runtime, see also
// http://lists.llvm.org/pipermail/llvm-dev/2018-February/121275.html. // https://lists.llvm.org/pipermail/llvm-dev/2018-February/121275.html.
// TODO: We could always determine abstract attributes and if sufficient // TODO: We could always determine abstract attributes and if sufficient
// information was found we could duplicate the functions that do not // information was found we could duplicate the functions that do not
// have an exact definition. // have an exact definition.
if (IsFnInterface && (!FnScope || !A.isFunctionIPOAmendable(*FnScope))) if (IsFnInterface && (!FnScope || !A.isFunctionIPOAmendable(*FnScope)))
this->getState().indicatePessimisticFixpoint(); this->getState().indicatePessimisticFixpoint();
} }
/// See AbstractAttribute::manifest(...). /// See AbstractAttribute::manifest(...).
▲ Show 20 Lines • Show All 2,209 Lines • Show Last 20 Lines

llvm/include/llvm/Transforms/Utils/ModuleUtils.h

Show All 27 Lines
class GlobalValue; class GlobalValue;
class Constant; class Constant;
class Value; class Value;
class Type; class Type;
/// Append F to the list of global ctors of module M with the given Priority. /// Append F to the list of global ctors of module M with the given Priority.
/// This wraps the function in the appropriate structure and stores it along /// This wraps the function in the appropriate structure and stores it along
/// side other global constructors. For details see /// side other global constructors. For details see
/// http://llvm.org/docs/LangRef.html#intg_global_ctors /// https://llvm.org/docs/LangRef.html#intg_global_ctors
void appendToGlobalCtors(Module &M, Function *F, int Priority, void appendToGlobalCtors(Module &M, Function *F, int Priority,
Constant *Data = nullptr); Constant *Data = nullptr);
/// Same as appendToGlobalCtors(), but for global dtors. /// Same as appendToGlobalCtors(), but for global dtors.
void appendToGlobalDtors(Module &M, Function *F, int Priority, void appendToGlobalDtors(Module &M, Function *F, int Priority,
Constant *Data = nullptr); Constant *Data = nullptr);
FunctionCallee declareSanitizerInitFunction(Module &M, StringRef InitName, FunctionCallee declareSanitizerInitFunction(Module &M, StringRef InitName,
▲ Show 20 Lines • Show All 80 Lines • Show Last 20 Lines

llvm/include/llvm/Transforms/Vectorize/LoopVectorize.h

//===- LoopVectorize.h ------------------------------------------*- C++ -*-===// //===- LoopVectorize.h ------------------------------------------*- C++ -*-===//
Lint: Lint
Inline Actions

clang-format suggested style edits found:

Lint: Lint: clang-format suggested style edits found:
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This is the LLVM loop vectorizer. This pass modifies 'vectorizable' loops // This is the LLVM loop vectorizer. This pass modifies 'vectorizable' loops
Show All 13 Lines
// widening of instructions. // widening of instructions.
// 4. LoopVectorizationCostModel - A unit that checks for the profitability // 4. LoopVectorizationCostModel - A unit that checks for the profitability
// of vectorization. It decides on the optimal vector width, which // of vectorization. It decides on the optimal vector width, which
// can be one, if vectorization is not profitable. // can be one, if vectorization is not profitable.
// //
// There is a development effort going on to migrate loop vectorizer to the // There is a development effort going on to migrate loop vectorizer to the
// VPlan infrastructure and to introduce outer loop vectorization support (see // VPlan infrastructure and to introduce outer loop vectorization support (see
// docs/Proposal/VectorizationPlan.rst and // docs/Proposal/VectorizationPlan.rst and
// http://lists.llvm.org/pipermail/llvm-dev/2017-December/119523.html). For this // https://lists.llvm.org/pipermail/llvm-dev/2017-December/119523.html). For this
// purpose, we temporarily introduced the VPlan-native vectorization path: an // purpose, we temporarily introduced the VPlan-native vectorization path: an
// alternative vectorization path that is natively implemented on top of the // alternative vectorization path that is natively implemented on top of the
// VPlan infrastructure. See EnableVPlanNativePath for enabling. // VPlan infrastructure. See EnableVPlanNativePath for enabling.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The reduction-variable vectorization is based on the paper: // The reduction-variable vectorization is based on the paper:
// D. Nuzman and R. Henderson. Multi-platform Auto-vectorization. // D. Nuzman and R. Henderson. Multi-platform Auto-vectorization.
▲ Show 20 Lines • Show All 181 Lines • Show Last 20 Lines

llvm/lib/Analysis/TypeBasedAliasAnalysis.cpp

Show All 36 Lines
// is null or omitted for a root node. A type is considered to alias // is null or omitted for a root node. A type is considered to alias
// all of its descendants and all of its ancestors in the tree. Also, // all of its descendants and all of its ancestors in the tree. Also,
// a type is considered to alias all types in other trees, so that // a type is considered to alias all types in other trees, so that
// bitcode produced from multiple front-ends is handled conservatively. // bitcode produced from multiple front-ends is handled conservatively.
// //
// If the third field is present, it's an integer which if equal to 1 // If the third field is present, it's an integer which if equal to 1
// indicates that the type is "constant" (meaning pointsToConstantMemory // indicates that the type is "constant" (meaning pointsToConstantMemory
// should return true; see // should return true; see
// http://llvm.org/docs/AliasAnalysis.html#OtherItfs). // https://llvm.org/docs/AliasAnalysis.html#OtherItfs).
// //
// With struct-path aware TBAA, the MDNodes attached to an instruction using // With struct-path aware TBAA, the MDNodes attached to an instruction using
// "!tbaa" are called path tag nodes. // "!tbaa" are called path tag nodes.
// //
// The path tag node has 4 fields with the last field being optional. // The path tag node has 4 fields with the last field being optional.
// //
// The first field is the base type node, it can be a struct type node // The first field is the base type node, it can be a struct type node
// or a scalar type node. The second field is the access type node, it // or a scalar type node. The second field is the access type node, it
▲ Show 20 Lines • Show All 767 Lines • Show Last 20 Lines

llvm/lib/CodeGen/LiveVariables.cpp

Show First 20 Lines • Show All 519 Lines • ▼ Show 20 Lines for (unsigned i = 0; i != NumOperandsToProcess; ++i) {
if (MO.isUse()) { if (MO.isUse()) {
if (!(Register::isPhysicalRegister(MOReg) && MRI->isReserved(MOReg))) if (!(Register::isPhysicalRegister(MOReg) && MRI->isReserved(MOReg)))
MO.setIsKill(false); MO.setIsKill(false);
if (MO.readsReg()) if (MO.readsReg())
UseRegs.push_back(MOReg); UseRegs.push_back(MOReg);
} else { } else {
assert(MO.isDef()); assert(MO.isDef());
// FIXME: We should not remove any dead flags. However the MIPS RDDSP // FIXME: We should not remove any dead flags. However the MIPS RDDSP
// instruction needs it at the moment: http://llvm.org/PR27116. // instruction needs it at the moment: https://llvm.org/PR27116.
if (Register::isPhysicalRegister(MOReg) && !MRI->isReserved(MOReg)) if (Register::isPhysicalRegister(MOReg) && !MRI->isReserved(MOReg))
MO.setIsDead(false); MO.setIsDead(false);
DefRegs.push_back(MOReg); DefRegs.push_back(MOReg);
} }
} }
MachineBasicBlock *MBB = MI.getParent(); MachineBasicBlock *MBB = MI.getParent();
// Process all uses. // Process all uses.
▲ Show 20 Lines • Show All 369 Lines • Show Last 20 Lines

llvm/lib/CodeGen/MachineOutliner.cpp

Show All 32 Lines
/// This was originally presented at the 2016 LLVM Developers' Meeting in the /// This was originally presented at the 2016 LLVM Developers' Meeting in the
/// talk "Reducing Code Size Using Outlining". For a high-level overview of /// talk "Reducing Code Size Using Outlining". For a high-level overview of
/// how this pass works, the talk is available on YouTube at /// how this pass works, the talk is available on YouTube at
/// ///
/// https://www.youtube.com/watch?v=yorld-WSOeU /// https://www.youtube.com/watch?v=yorld-WSOeU
/// ///
/// The slides for the talk are available at /// The slides for the talk are available at
/// ///
/// http://www.llvm.org/devmtg/2016-11/Slides/Paquette-Outliner.pdf /// https://www.llvm.org/devmtg/2016-11/Slides/Paquette-Outliner.pdf
/// ///
/// The talk provides an overview of how the outliner finds candidates and /// The talk provides an overview of how the outliner finds candidates and
/// ultimately outlines them. It describes how the main data structure for this /// ultimately outlines them. It describes how the main data structure for this
/// pass, the suffix tree, is queried and purged for candidates. It also gives /// pass, the suffix tree, is queried and purged for candidates. It also gives
/// a simplified suffix tree construction algorithm for suffix trees based off /// a simplified suffix tree construction algorithm for suffix trees based off
/// of the algorithm actually used here, Ukkonen's algorithm. /// of the algorithm actually used here, Ukkonen's algorithm.
/// ///
/// For the original RFC for this pass, please see /// For the original RFC for this pass, please see
/// ///
/// http://lists.llvm.org/pipermail/llvm-dev/2016-August/104170.html /// https://lists.llvm.org/pipermail/llvm-dev/2016-August/104170.html
/// ///
/// For more information on the suffix tree data structure, please see /// For more information on the suffix tree data structure, please see
/// https://www.cs.helsinki.fi/u/ukkonen/SuffixT1withFigs.pdf /// https://www.cs.helsinki.fi/u/ukkonen/SuffixT1withFigs.pdf
/// ///
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "llvm/CodeGen/MachineOutliner.h" #include "llvm/CodeGen/MachineOutliner.h"
#include "llvm/ADT/DenseMap.h" #include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/SmallSet.h" #include "llvm/ADT/SmallSet.h"
▲ Show 20 Lines • Show All 1,030 Lines • Show Last 20 Lines

llvm/lib/CodeGen/SafeStack.cpp

//===- SafeStack.cpp - Safe Stack Insertion -------------------------------===// //===- SafeStack.cpp - Safe Stack Insertion -------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This pass splits the stack into the safe stack (kept as-is for LLVM backend) // This pass splits the stack into the safe stack (kept as-is for LLVM backend)
// and the unsafe stack (explicitly allocated and managed through the runtime // and the unsafe stack (explicitly allocated and managed through the runtime
// support library). // support library).
// //
// http://clang.llvm.org/docs/SafeStack.html // https://clang.llvm.org/docs/SafeStack.html
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "SafeStackLayout.h" #include "SafeStackLayout.h"
#include "llvm/ADT/APInt.h" #include "llvm/ADT/APInt.h"
#include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/SmallPtrSet.h" #include "llvm/ADT/SmallPtrSet.h"
#include "llvm/ADT/SmallVector.h" #include "llvm/ADT/SmallVector.h"
▲ Show 20 Lines • Show All 918 Lines • Show Last 20 Lines

llvm/lib/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.cpp

Show First 20 Lines • Show All 187 Lines • ▼ Show 20 LinesError RTDyldObjectLinkingLayer::onObjLoad(
RuntimeDyld::MemoryManager &MemMgr, RuntimeDyld::MemoryManager &MemMgr,
RuntimeDyld::LoadedObjectInfo &LoadedObjInfo, RuntimeDyld::LoadedObjectInfo &LoadedObjInfo,
std::map<StringRef, JITEvaluatedSymbol> Resolved, std::map<StringRef, JITEvaluatedSymbol> Resolved,
std::set<StringRef> &InternalSymbols) { std::set<StringRef> &InternalSymbols) {
SymbolFlagsMap ExtraSymbolsToClaim; SymbolFlagsMap ExtraSymbolsToClaim;
SymbolMap Symbols; SymbolMap Symbols;
// Hack to support COFF constant pool comdats introduced during compilation: // Hack to support COFF constant pool comdats introduced during compilation:
// (See http://llvm.org/PR40074) // (See https://llvm.org/PR40074)
if (auto *COFFObj = dyn_cast<object::COFFObjectFile>(&Obj)) { if (auto *COFFObj = dyn_cast<object::COFFObjectFile>(&Obj)) {
auto &ES = getExecutionSession(); auto &ES = getExecutionSession();
// For all resolved symbols that are not already in the responsibilty set: // For all resolved symbols that are not already in the responsibilty set:
// check whether the symbol is in a comdat section and if so mark it as // check whether the symbol is in a comdat section and if so mark it as
// weak. // weak.
for (auto &Sym : COFFObj->symbols()) { for (auto &Sym : COFFObj->symbols()) {
// getFlags() on COFF symbols can't fail. // getFlags() on COFF symbols can't fail.
▲ Show 20 Lines • Show All 151 Lines • Show Last 20 Lines

llvm/lib/ExecutionEngine/RuntimeDyld/RTDyldMemoryManager.cpp

Show First 20 Lines • Show All 85 Lines • ▼ Show 20 Lines
} }
// This implementation handles frame registration for local targets. // This implementation handles frame registration for local targets.
// Memory managers for remote targets should re-implement this function // Memory managers for remote targets should re-implement this function
// and use the LoadAddr parameter. // and use the LoadAddr parameter.
void RTDyldMemoryManager::registerEHFramesInProcess(uint8_t *Addr, void RTDyldMemoryManager::registerEHFramesInProcess(uint8_t *Addr,
size_t Size) { size_t Size) {
// On OS X OS X __register_frame takes a single FDE as an argument. // On OS X OS X __register_frame takes a single FDE as an argument.
// See http://lists.llvm.org/pipermail/llvm-dev/2013-April/061737.html // See https://lists.llvm.org/pipermail/llvm-dev/2013-April/061737.html
// and projects/libunwind/src/UnwindLevel1-gcc-ext.c. // and projects/libunwind/src/UnwindLevel1-gcc-ext.c.
const char *P = (const char *)Addr; const char *P = (const char *)Addr;
const char *End = P + Size; const char *End = P + Size;
while (P != End) while (P != End)
P = processFDE(P, false); P = processFDE(P, false);
} }
void RTDyldMemoryManager::deregisterEHFramesInProcess(uint8_t *Addr, void RTDyldMemoryManager::deregisterEHFramesInProcess(uint8_t *Addr,
▲ Show 20 Lines • Show All 123 Lines • ▼ Show 20 Lines#if defined(__linux__) && defined(__GLIBC__)
//===--------------------------------------------------------------------===// //===--------------------------------------------------------------------===//
// Function stubs that are invoked instead of certain library calls // Function stubs that are invoked instead of certain library calls
// //
// Force the following functions to be linked in to anything that uses the // Force the following functions to be linked in to anything that uses the
// JIT. This is a hack designed to work around the all-too-clever Glibc // JIT. This is a hack designed to work around the all-too-clever Glibc
// strategy of making these functions work differently when inlined vs. when // strategy of making these functions work differently when inlined vs. when
// not inlined, and hiding their real definitions in a separate archive file // not inlined, and hiding their real definitions in a separate archive file
// that the dynamic linker can't see. For more info, search for // that the dynamic linker can't see. For more info, search for
// 'libc_nonshared.a' on Google, or read http://llvm.org/PR274. // 'libc_nonshared.a' on Google, or read https://llvm.org/PR274.
if (Name == "stat") return (uint64_t)&stat; if (Name == "stat") return (uint64_t)&stat;
if (Name == "fstat") return (uint64_t)&fstat; if (Name == "fstat") return (uint64_t)&fstat;
if (Name == "lstat") return (uint64_t)&lstat; if (Name == "lstat") return (uint64_t)&lstat;
if (Name == "stat64") return (uint64_t)&stat64; if (Name == "stat64") return (uint64_t)&stat64;
if (Name == "fstat64") return (uint64_t)&fstat64; if (Name == "fstat64") return (uint64_t)&fstat64;
if (Name == "lstat64") return (uint64_t)&lstat64; if (Name == "lstat64") return (uint64_t)&lstat64;
if (Name == "atexit") return (uint64_t)&atexit; if (Name == "atexit") return (uint64_t)&atexit;
if (Name == "mknod") return (uint64_t)&mknod; if (Name == "mknod") return (uint64_t)&mknod;
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

llvm/lib/ObjectYAML/WasmYAML.cpp

Show All 15 Lines
#include "llvm/Support/ErrorHandling.h" #include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/YAMLTraits.h" #include "llvm/Support/YAMLTraits.h"
namespace llvm { namespace llvm {
namespace WasmYAML { namespace WasmYAML {
// Declared here rather than in the header to comply with: // Declared here rather than in the header to comply with:
// http://llvm.org/docs/CodingStandards.html#provide-a-virtual-method-anchor-for-classes-in-headers // https://llvm.org/docs/CodingStandards.html#provide-a-virtual-method-anchor-for-classes-in-headers
Section::~Section() = default; Section::~Section() = default;
} // end namespace WasmYAML } // end namespace WasmYAML
namespace yaml { namespace yaml {
void MappingTraits<WasmYAML::FileHeader>::mapping( void MappingTraits<WasmYAML::FileHeader>::mapping(
IO &IO, WasmYAML::FileHeader &FileHdr) { IO &IO, WasmYAML::FileHeader &FileHdr) {
▲ Show 20 Lines • Show All 614 Lines • Show Last 20 Lines

llvm/lib/Support/CommandLine.cpp

Show First 20 Lines • Show All 2,460 Lines • ▼ Show 20 Lines
namespace { namespace {
class VersionPrinter { class VersionPrinter {
public: public:
void print() { void print() {
raw_ostream &OS = outs(); raw_ostream &OS = outs();
#ifdef PACKAGE_VENDOR #ifdef PACKAGE_VENDOR
OS << PACKAGE_VENDOR << " "; OS << PACKAGE_VENDOR << " ";
#else #else
OS << "LLVM (http://llvm.org/):\n "; OS << "LLVM (https://llvm.org/):\n ";
#endif #endif
OS << PACKAGE_NAME << " version " << PACKAGE_VERSION << "\n "; OS << PACKAGE_NAME << " version " << PACKAGE_VERSION << "\n ";
#if LLVM_IS_DEBUG_BUILD #if LLVM_IS_DEBUG_BUILD
OS << "DEBUG build"; OS << "DEBUG build";
#else #else
OS << "Optimized build"; OS << "Optimized build";
#endif #endif
#ifndef NDEBUG #ifndef NDEBUG
▲ Show 20 Lines • Show All 262 Lines • Show Last 20 Lines

llvm/lib/Target/AMDGPU/AMDGPUMachineModuleInfo.h

//===--- AMDGPUMachineModuleInfo.h ------------------------------*- C++ -*-===// //===--- AMDGPUMachineModuleInfo.h ------------------------------*- C++ -*-===//
Lint: Lint
Inline Actions

clang-format suggested style edits found:

Lint: Lint: clang-format suggested style edits found:
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
/// \file /// \file
/// AMDGPU Machine Module Info. /// AMDGPU Machine Module Info.
/// ///
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_LIB_TARGET_AMDGPU_AMDGPUMACHINEMODULEINFO_H #ifndef LLVM_LIB_TARGET_AMDGPU_AMDGPUMACHINEMODULEINFO_H
#define LLVM_LIB_TARGET_AMDGPU_AMDGPUMACHINEMODULEINFO_H #define LLVM_LIB_TARGET_AMDGPU_AMDGPUMACHINEMODULEINFO_H
#include "llvm/CodeGen/MachineModuleInfoImpls.h" #include "llvm/CodeGen/MachineModuleInfoImpls.h"
namespace llvm { namespace llvm {
class AMDGPUMachineModuleInfo final : public MachineModuleInfoELF { class AMDGPUMachineModuleInfo final : public MachineModuleInfoELF {
private: private:
// All supported memory/synchronization scopes can be found here: // All supported memory/synchronization scopes can be found here:
// http://llvm.org/docs/AMDGPUUsage.html#memory-scopes // https://llvm.org/docs/AMDGPUUsage.html#memory-scopes
/// Agent synchronization scope ID (cross address space). /// Agent synchronization scope ID (cross address space).
SyncScope::ID AgentSSID; SyncScope::ID AgentSSID;
/// Workgroup synchronization scope ID (cross address space). /// Workgroup synchronization scope ID (cross address space).
SyncScope::ID WorkgroupSSID; SyncScope::ID WorkgroupSSID;
/// Wavefront synchronization scope ID (cross address space). /// Wavefront synchronization scope ID (cross address space).
SyncScope::ID WavefrontSSID; SyncScope::ID WavefrontSSID;
/// System synchronization scope ID (single address space). /// System synchronization scope ID (single address space).
▲ Show 20 Lines • Show All 107 Lines • Show Last 20 Lines

llvm/lib/Target/AMDGPU/R600Instructions.td

Show First 20 Lines • Show All 724 Lines • ▼ Show 20 Lines
// Non-IEEE MUL: 0 * anything = 0 // Non-IEEE MUL: 0 * anything = 0
def MUL : R600_2OP_Helper <0x1, "MUL NON-IEEE">; def MUL : R600_2OP_Helper <0x1, "MUL NON-IEEE">;
def MUL_IEEE : R600_2OP_Helper <0x2, "MUL_IEEE", fmul>; def MUL_IEEE : R600_2OP_Helper <0x2, "MUL_IEEE", fmul>;
// TODO: Do these actually match the regular fmin/fmax behavior? // TODO: Do these actually match the regular fmin/fmax behavior?
def MAX : R600_2OP_Helper <0x3, "MAX", AMDGPUfmax_legacy>; def MAX : R600_2OP_Helper <0x3, "MAX", AMDGPUfmax_legacy>;
def MIN : R600_2OP_Helper <0x4, "MIN", AMDGPUfmin_legacy>; def MIN : R600_2OP_Helper <0x4, "MIN", AMDGPUfmin_legacy>;
// According to https://msdn.microsoft.com/en-us/library/windows/desktop/cc308050%28v=vs.85%29.aspx // According to https://msdn.microsoft.com/en-us/library/windows/desktop/cc308050%28v=vs.85%29.aspx
// DX10 min/max returns the other operand if one is NaN, // DX10 min/max returns the other operand if one is NaN,
// this matches http://llvm.org/docs/LangRef.html#llvm-minnum-intrinsic // this matches https://llvm.org/docs/LangRef.html#llvm-minnum-intrinsic
def MAX_DX10 : R600_2OP_Helper <0x5, "MAX_DX10", fmaxnum>; def MAX_DX10 : R600_2OP_Helper <0x5, "MAX_DX10", fmaxnum>;
def MIN_DX10 : R600_2OP_Helper <0x6, "MIN_DX10", fminnum>; def MIN_DX10 : R600_2OP_Helper <0x6, "MIN_DX10", fminnum>;
// For the SET* instructions there is a naming conflict in TargetSelectionDAG.td, // For the SET* instructions there is a naming conflict in TargetSelectionDAG.td,
// so some of the instruction names don't match the asm string. // so some of the instruction names don't match the asm string.
// XXX: Use the defs in TargetSelectionDAG.td instead of intrinsics. // XXX: Use the defs in TargetSelectionDAG.td instead of intrinsics.
def SETE : R600_2OP < def SETE : R600_2OP <
0x08, "SETE", 0x08, "SETE",
▲ Show 20 Lines • Show All 1,048 Lines • Show Last 20 Lines

llvm/lib/Target/AMDGPU/SIMemoryLegalizer.cpp

//===- SIMemoryLegalizer.cpp ----------------------------------------------===// //===- SIMemoryLegalizer.cpp ----------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
/// \file /// \file
/// Memory legalizer - implements memory model. More information can be /// Memory legalizer - implements memory model. More information can be
/// found here: /// found here:
/// http://llvm.org/docs/AMDGPUUsage.html#memory-model /// https://llvm.org/docs/AMDGPUUsage.html#memory-model
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "AMDGPU.h" #include "AMDGPU.h"
#include "AMDGPUMachineModuleInfo.h" #include "AMDGPUMachineModuleInfo.h"
#include "GCNSubtarget.h" #include "GCNSubtarget.h"
#include "MCTargetDesc/AMDGPUMCTargetDesc.h" #include "MCTargetDesc/AMDGPUMCTargetDesc.h"
#include "llvm/ADT/BitmaskEnum.h" #include "llvm/ADT/BitmaskEnum.h"
▲ Show 20 Lines • Show All 2,333 Lines • Show Last 20 Lines

llvm/lib/Target/ARM/README.txt

Show First 20 Lines • Show All 560 Lines • ▼ Show 20 Lines
with the same bottom half. with the same bottom half.
//===---------------------------------------------------------------------===// //===---------------------------------------------------------------------===//
Robert Muth started working on an alternate jump table implementation that Robert Muth started working on an alternate jump table implementation that
does not put the tables in-line in the text. This is more like the llvm does not put the tables in-line in the text. This is more like the llvm
default jump table implementation. This might be useful sometime. Several default jump table implementation. This might be useful sometime. Several
revisions of patches are on the mailing list, beginning at: revisions of patches are on the mailing list, beginning at:
http://lists.llvm.org/pipermail/llvm-dev/2009-June/022763.html https://lists.llvm.org/pipermail/llvm-dev/2009-June/022763.html
//===---------------------------------------------------------------------===// //===---------------------------------------------------------------------===//
Make use of the "rbit" instruction. Make use of the "rbit" instruction.
//===---------------------------------------------------------------------===// //===---------------------------------------------------------------------===//
Take a look at test/CodeGen/Thumb2/machine-licm.ll. ARM should be taught how Take a look at test/CodeGen/Thumb2/machine-licm.ll. ARM should be taught how
▲ Show 20 Lines • Show All 146 Lines • ▼ Show 20 Lines
Register operands should be distinct. That is, when the encoding does not Register operands should be distinct. That is, when the encoding does not
require two syntactical operands to refer to the same register, two different require two syntactical operands to refer to the same register, two different
registers should be used in the test so as to catch errors where the registers should be used in the test so as to catch errors where the
operands are swapped in the encoding. operands are swapped in the encoding.
e.g., e.g.,
subs.w r1, r1, r1 // bad subs.w r1, r1, r1 // bad
subs.w r1, r2, r3 // good subs.w r1, r2, r3 // good

llvm/lib/Target/PowerPC/PPCISelLowering.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 2,009 Lines • ▼ Show 20 Lines
* Targeting your applications - what little endian and big endian IBM XL C/C++ * Targeting your applications - what little endian and big endian IBM XL C/C++
* compiler differences mean to you * compiler differences mean to you
* *
* The mask to the shuffle vector instruction specifies the indices of the * The mask to the shuffle vector instruction specifies the indices of the
* elements from the two input vectors to place in the result. The elements are * elements from the two input vectors to place in the result. The elements are
* numbered in array-access order, starting with the first vector. These vectors * numbered in array-access order, starting with the first vector. These vectors
* are always of type v16i8, thus each vector will contain 16 elements of size * are always of type v16i8, thus each vector will contain 16 elements of size
* 8. More info on the shuffle vector can be found in the * 8. More info on the shuffle vector can be found in the
* http://llvm.org/docs/LangRef.html#shufflevector-instruction * https://llvm.org/docs/LangRef.html#shufflevector-instruction
* Language Reference. * Language Reference.
* *
* The RHSStartValue indicates whether the same input vectors are used (unary) * The RHSStartValue indicates whether the same input vectors are used (unary)
* or two different input vectors are used, based on the following: * or two different input vectors are used, based on the following:
* - If the instruction uses the same vector for both inputs, the range of the * - If the instruction uses the same vector for both inputs, the range of the
* indices will be 0 to 15. In this case, the RHSStart value passed should * indices will be 0 to 15. In this case, the RHSStart value passed should
* be 0. * be 0.
* - If the instruction has two different vectors then the range of the * - If the instruction has two different vectors then the range of the
▲ Show 20 Lines • Show All 16,144 Lines • Show Last 20 Lines

llvm/lib/Target/PowerPC/PPCVSXFMAMutate.cpp

Show All 35 Lines
#include "llvm/Support/Debug.h" #include "llvm/Support/Debug.h"
#include "llvm/Support/ErrorHandling.h" #include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/raw_ostream.h" #include "llvm/Support/raw_ostream.h"
using namespace llvm; using namespace llvm;
// Temporarily disable FMA mutation by default, since it doesn't handle // Temporarily disable FMA mutation by default, since it doesn't handle
// cross-basic-block intervals well. // cross-basic-block intervals well.
// See: http://lists.llvm.org/pipermail/llvm-dev/2016-February/095669.html // See: https://lists.llvm.org/pipermail/llvm-dev/2016-February/095669.html
// http://reviews.llvm.org/D17087 // https://reviews.llvm.org/D17087
static cl::opt<bool> DisableVSXFMAMutate( static cl::opt<bool> DisableVSXFMAMutate(
"disable-ppc-vsx-fma-mutation", "disable-ppc-vsx-fma-mutation",
cl::desc("Disable VSX FMA instruction mutation"), cl::init(true), cl::desc("Disable VSX FMA instruction mutation"), cl::init(true),
cl::Hidden); cl::Hidden);
#define DEBUG_TYPE "ppc-vsx-fma-mutate" #define DEBUG_TYPE "ppc-vsx-fma-mutate"
namespace llvm { namespace PPC { namespace llvm { namespace PPC {
▲ Show 20 Lines • Show All 341 Lines • Show Last 20 Lines

llvm/lib/Target/README.txt

Show First 20 Lines • Show All 100 Lines • ▼ Show 20 Lines
int h(int *j, int *l) { return *j - *l; } int h(int *j, int *l) { return *j - *l; }
this could be done in SelectionDAGISel.cpp, along with other special cases, this could be done in SelectionDAGISel.cpp, along with other special cases,
for 1,2,4,8 bytes. for 1,2,4,8 bytes.
//===---------------------------------------------------------------------===// //===---------------------------------------------------------------------===//
It would be nice to revert this patch: It would be nice to revert this patch:
http://lists.llvm.org/pipermail/llvm-commits/Week-of-Mon-20060213/031986.html https://lists.llvm.org/pipermail/llvm-commits/Week-of-Mon-20060213/031986.html
And teach the dag combiner enough to simplify the code expanded before And teach the dag combiner enough to simplify the code expanded before
legalize. It seems plausible that this knowledge would let it simplify other legalize. It seems plausible that this knowledge would let it simplify other
stuff too. stuff too.
//===---------------------------------------------------------------------===// //===---------------------------------------------------------------------===//
For vector types, DataLayout.cpp::getTypeInfo() returns alignment that is equal For vector types, DataLayout.cpp::getTypeInfo() returns alignment that is equal
▲ Show 20 Lines • Show All 404 Lines • ▼ Show 20 LinesWhich gets codegen'd into:
movq $1, -48(%rbp) movq $1, -48(%rbp)
movq $1, -32(%rbp) movq $1, -32(%rbp)
movq $1, -16(%rbp) movq $1, -16(%rbp)
It would be better to have 4 movq's of 0 instead of the movaps's. It would be better to have 4 movq's of 0 instead of the movaps's.
//===---------------------------------------------------------------------===// //===---------------------------------------------------------------------===//
http://llvm.org/PR717: https://llvm.org/PR717:
The following code should compile into "ret int undef". Instead, LLVM The following code should compile into "ret int undef". Instead, LLVM
produces "ret int 0": produces "ret int 0":
int f() { int f() {
int x = 4; int x = 4;
int y; int y;
if (x == 3) y = 0; if (x == 3) y = 0;
▲ Show 20 Lines • Show All 1,741 Lines • Show Last 20 Lines

llvm/lib/Transforms/IPO/LowerTypeTests.cpp

//===- LowerTypeTests.cpp - type metadata lowering pass -------------------===// //===- LowerTypeTests.cpp - type metadata lowering pass -------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This pass lowers type metadata and calls to the llvm.type.test intrinsic. // This pass lowers type metadata and calls to the llvm.type.test intrinsic.
// It also ensures that globals are properly laid out for the // It also ensures that globals are properly laid out for the
// llvm.icall.branch.funnel intrinsic. // llvm.icall.branch.funnel intrinsic.
// See http://llvm.org/docs/TypeMetadata.html for more information. // See https://llvm.org/docs/TypeMetadata.html for more information.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "llvm/Transforms/IPO/LowerTypeTests.h" #include "llvm/Transforms/IPO/LowerTypeTests.h"
#include "llvm/ADT/APInt.h" #include "llvm/ADT/APInt.h"
#include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/DenseMap.h" #include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/EquivalenceClasses.h" #include "llvm/ADT/EquivalenceClasses.h"
▲ Show 20 Lines • Show All 2,296 Lines • Show Last 20 Lines

llvm/lib/Transforms/Instrumentation/AddressSanitizer.cpp

Show First 20 Lines • Show All 241 Lines • ▼ Show 20 Lines
static cl::opt<bool> ClWithIfuncSuppressRemat( static cl::opt<bool> ClWithIfuncSuppressRemat(
"asan-with-ifunc-suppress-remat", "asan-with-ifunc-suppress-remat",
cl::desc("Suppress rematerialization of dynamic shadow address by passing " cl::desc("Suppress rematerialization of dynamic shadow address by passing "
"it through inline asm in prologue."), "it through inline asm in prologue."),
cl::Hidden, cl::init(true)); cl::Hidden, cl::init(true));
// This flag limits the number of instructions to be instrumented // This flag limits the number of instructions to be instrumented
// in any given BB. Normally, this should be set to unlimited (INT_MAX), // in any given BB. Normally, this should be set to unlimited (INT_MAX),
// but due to http://llvm.org/bugs/show_bug.cgi?id=12652 we temporary // but due to https://llvm.org/bugs/show_bug.cgi?id=12652 we temporary
// set it to 10000. // set it to 10000.
static cl::opt<int> ClMaxInsnsToInstrumentPerBB( static cl::opt<int> ClMaxInsnsToInstrumentPerBB(
"asan-max-ins-per-bb", cl::init(10000), "asan-max-ins-per-bb", cl::init(10000),
cl::desc("maximal number of instructions to instrument in any given BB"), cl::desc("maximal number of instructions to instrument in any given BB"),
cl::Hidden); cl::Hidden);
// This flag may need to be replaced with -f[no]asan-stack. // This flag may need to be replaced with -f[no]asan-stack.
static cl::opt<bool> ClStack("asan-stack", cl::desc("Handle stack memory"), static cl::opt<bool> ClStack("asan-stack", cl::desc("Handle stack memory"),
▲ Show 20 Lines • Show All 3,248 Lines • Show Last 20 Lines

llvm/lib/Transforms/Instrumentation/DataFlowSanitizer.cpp

Show First 20 Lines • Show All 49 Lines • ▼ Show 20 Lines
/// +--------------------+ 0x010000000000 /// +--------------------+ 0x010000000000
/// | application 1 | /// | application 1 |
/// +--------------------+ 0x000000000000 /// +--------------------+ 0x000000000000
/// ///
/// MEM_TO_SHADOW(mem) = mem ^ 0x500000000000 /// MEM_TO_SHADOW(mem) = mem ^ 0x500000000000
/// SHADOW_TO_ORIGIN(shadow) = shadow + 0x100000000000 /// SHADOW_TO_ORIGIN(shadow) = shadow + 0x100000000000
/// ///
/// For more information, please refer to the design document: /// For more information, please refer to the design document:
/// http://clang.llvm.org/docs/DataFlowSanitizerDesign.html /// https://clang.llvm.org/docs/DataFlowSanitizerDesign.html
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "llvm/Transforms/Instrumentation/DataFlowSanitizer.h" #include "llvm/Transforms/Instrumentation/DataFlowSanitizer.h"
#include "llvm/ADT/DenseMap.h" #include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/DenseSet.h" #include "llvm/ADT/DenseSet.h"
#include "llvm/ADT/DepthFirstIterator.h" #include "llvm/ADT/DepthFirstIterator.h"
#include "llvm/ADT/None.h" #include "llvm/ADT/None.h"
▲ Show 20 Lines • Show All 3,075 Lines • Show Last 20 Lines

llvm/lib/Transforms/Scalar/EarlyCSE.cpp

Show First 20 Lines • Show All 1,599 Lines • ▼ Show 20 Linesbool EarlyCSE::processNode(DomTreeNode *Node) {
return Changed; return Changed;
} }
bool EarlyCSE::run() { bool EarlyCSE::run() {
// Note, deque is being used here because there is significant performance // Note, deque is being used here because there is significant performance
// gains over vector when the container becomes very large due to the // gains over vector when the container becomes very large due to the
// specific access patterns. For more information see the mailing list // specific access patterns. For more information see the mailing list
// discussion on this: // discussion on this:
// http://lists.llvm.org/pipermail/llvm-commits/Week-of-Mon-20120116/135228.html // https://lists.llvm.org/pipermail/llvm-commits/Week-of-Mon-20120116/135228.html
std::deque<StackNode *> nodesToProcess; std::deque<StackNode *> nodesToProcess;
bool Changed = false; bool Changed = false;
// Process the root node. // Process the root node.
nodesToProcess.push_back(new StackNode( nodesToProcess.push_back(new StackNode(
AvailableValues, AvailableLoads, AvailableInvariants, AvailableCalls, AvailableValues, AvailableLoads, AvailableInvariants, AvailableCalls,
CurrentGeneration, DT.getRootNode(), CurrentGeneration, DT.getRootNode(),
▲ Show 20 Lines • Show All 159 Lines • Show Last 20 Lines

llvm/lib/Transforms/Scalar/SeparateConstOffsetFromGEP.cpp

Show First 20 Lines • Show All 414 Lines • ▼ Show 20 Linesprivate:
/// Canonicalize array indices to pointer-size integers. This helps to /// Canonicalize array indices to pointer-size integers. This helps to
/// simplify the logic of splitting a GEP. For example, if a + b is a /// simplify the logic of splitting a GEP. For example, if a + b is a
/// pointer-size integer, we have /// pointer-size integer, we have
/// gep base, a + b = gep (gep base, a), b /// gep base, a + b = gep (gep base, a), b
/// However, this equality may not hold if the size of a + b is smaller than /// However, this equality may not hold if the size of a + b is smaller than
/// the pointer size, because LLVM conceptually sign-extends GEP indices to /// the pointer size, because LLVM conceptually sign-extends GEP indices to
/// pointer size before computing the address /// pointer size before computing the address
/// (http://llvm.org/docs/LangRef.html#id181). /// (https://llvm.org/docs/LangRef.html#id181).
/// ///
/// This canonicalization is very likely already done in clang and /// This canonicalization is very likely already done in clang and
/// instcombine. Therefore, the program will probably remain the same. /// instcombine. Therefore, the program will probably remain the same.
/// ///
/// Returns true if the module changes. /// Returns true if the module changes.
/// ///
/// Verified in @i32_add in split-gep.ll /// Verified in @i32_add in split-gep.ll
bool canonicalizeArrayIndicesToPointerSize(GetElementPtrInst *GEP); bool canonicalizeArrayIndicesToPointerSize(GetElementPtrInst *GEP);
▲ Show 20 Lines • Show All 598 Lines • ▼ Show 20 Linesbool SeparateConstOffsetFromGEP::splitGEP(GetElementPtrInst *GEP) {
// addr = gep inbounds float, float* p, i64 b // addr = gep inbounds float, float* p, i64 b
// //
// is transformed to: // is transformed to:
// //
// addr2 = gep float, float* p, i64 a ; inbounds removed // addr2 = gep float, float* p, i64 a ; inbounds removed
// addr = gep inbounds float, float* addr2, i64 5 // addr = gep inbounds float, float* addr2, i64 5
// //
// If a is -4, although the old index b is in bounds, the new index a is // If a is -4, although the old index b is in bounds, the new index a is
// off-bound. http://llvm.org/docs/LangRef.html#id181 says "if the // off-bound. https://llvm.org/docs/LangRef.html#id181 says "if the
// inbounds keyword is not present, the offsets are added to the base // inbounds keyword is not present, the offsets are added to the base
// address with silently-wrapping two's complement arithmetic". // address with silently-wrapping two's complement arithmetic".
// Therefore, the final code will be a semantically equivalent. // Therefore, the final code will be a semantically equivalent.
// //
// TODO(jingyue): do some range analysis to keep as many inbounds as // TODO(jingyue): do some range analysis to keep as many inbounds as
// possible. GEPs with inbounds are more friendly to alias analysis. // possible. GEPs with inbounds are more friendly to alias analysis.
bool GEPWasInBounds = GEP->isInBounds(); bool GEPWasInBounds = GEP->isInBounds();
GEP->setIsInBounds(false); GEP->setIsInBounds(false);
Show All 27 Linesbool SeparateConstOffsetFromGEP::splitGEP(GetElementPtrInst *GEP) {
// //
// => replace all uses of %gep with %new.gep and remove %gep // => replace all uses of %gep with %new.gep and remove %gep
// //
// %gep2 ; clone of %gep // %gep2 ; clone of %gep
// %new.gep = gep %gep2, <offset / sizeof(*%gep)> // %new.gep = gep %gep2, <offset / sizeof(*%gep)>
// ... %new.gep ... // ... %new.gep ...
// //
// If AccumulativeByteOffset is not a multiple of sizeof(*%gep), we emit an // If AccumulativeByteOffset is not a multiple of sizeof(*%gep), we emit an
// uglygep (http://llvm.org/docs/GetElementPtr.html#what-s-an-uglygep): // uglygep (https://llvm.org/docs/GetElementPtr.html#what-s-an-uglygep):
// bitcast %gep2 to i8*, add the offset, and bitcast the result back to the // bitcast %gep2 to i8*, add the offset, and bitcast the result back to the
// type of %gep. // type of %gep.
// //
// %gep2 ; clone of %gep // %gep2 ; clone of %gep
// %0 = bitcast %gep2 to i8* // %0 = bitcast %gep2 to i8*
// %uglygep = gep %0, <offset> // %uglygep = gep %0, <offset>
// %new.gep = bitcast %uglygep to <type of %gep> // %new.gep = bitcast %uglygep to <type of %gep>
// ... %new.gep ... // ... %new.gep ...
▲ Show 20 Lines • Show All 297 Lines • Show Last 20 Lines

llvm/lib/Transforms/Utils/ScalarEvolutionExpander.cpp

Show First 20 Lines • Show All 417 Lines • ▼ Show 20 Lines if (!AddRecs.empty()) {
SimplifyAddOperands(Ops, Ty, SE); SimplifyAddOperands(Ops, Ty, SE);
} }
} }
/// expandAddToGEP - Expand an addition expression with a pointer type into /// expandAddToGEP - Expand an addition expression with a pointer type into
/// a GEP instead of using ptrtoint+arithmetic+inttoptr. This helps /// a GEP instead of using ptrtoint+arithmetic+inttoptr. This helps
/// BasicAliasAnalysis and other passes analyze the result. See the rules /// BasicAliasAnalysis and other passes analyze the result. See the rules
/// for getelementptr vs. inttoptr in /// for getelementptr vs. inttoptr in
/// http://llvm.org/docs/LangRef.html#pointeraliasing /// https://llvm.org/docs/LangRef.html#pointeraliasing
/// for details. /// for details.
/// ///
/// Design note: The correctness of using getelementptr here depends on /// Design note: The correctness of using getelementptr here depends on
/// ScalarEvolution not recognizing inttoptr and ptrtoint operators, as /// ScalarEvolution not recognizing inttoptr and ptrtoint operators, as
/// they may introduce pointer arithmetic which may not be safely converted /// they may introduce pointer arithmetic which may not be safely converted
/// into getelementptr. /// into getelementptr.
/// ///
/// Design note: It might seem desirable for this function to be more /// Design note: It might seem desirable for this function to be more
▲ Show 20 Lines • Show All 2,240 Lines • Show Last 20 Lines

llvm/lib/Transforms/Vectorize/LoopVectorize.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
//===- LoopVectorize.cpp - A Loop Vectorizer ------------------------------===// //===- LoopVectorize.cpp - A Loop Vectorizer ------------------------------===//
Lint: Lint
Inline Actions

clang-format suggested style edits found:

Lint: Lint: clang-format suggested style edits found:
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This is the LLVM loop vectorizer. This pass modifies 'vectorizable' loops // This is the LLVM loop vectorizer. This pass modifies 'vectorizable' loops
Show All 13 Lines
// widening of instructions. // widening of instructions.
// 4. LoopVectorizationCostModel - A unit that checks for the profitability // 4. LoopVectorizationCostModel - A unit that checks for the profitability
// of vectorization. It decides on the optimal vector width, which // of vectorization. It decides on the optimal vector width, which
// can be one, if vectorization is not profitable. // can be one, if vectorization is not profitable.
// //
// There is a development effort going on to migrate loop vectorizer to the // There is a development effort going on to migrate loop vectorizer to the
// VPlan infrastructure and to introduce outer loop vectorization support (see // VPlan infrastructure and to introduce outer loop vectorization support (see
// docs/Proposal/VectorizationPlan.rst and // docs/Proposal/VectorizationPlan.rst and
// http://lists.llvm.org/pipermail/llvm-dev/2017-December/119523.html). For this // https://lists.llvm.org/pipermail/llvm-dev/2017-December/119523.html). For this
// purpose, we temporarily introduced the VPlan-native vectorization path: an // purpose, we temporarily introduced the VPlan-native vectorization path: an
// alternative vectorization path that is natively implemented on top of the // alternative vectorization path that is natively implemented on top of the
// VPlan infrastructure. See EnableVPlanNativePath for enabling. // VPlan infrastructure. See EnableVPlanNativePath for enabling.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The reduction-variable vectorization is based on the paper: // The reduction-variable vectorization is based on the paper:
// D. Nuzman and R. Henderson. Multi-platform Auto-vectorization. // D. Nuzman and R. Henderson. Multi-platform Auto-vectorization.
▲ Show 20 Lines • Show All 10,755 Lines • Show Last 20 Lines

llvm/llvm.spec.in

Name: @PACKAGE_NAME@ Name: @PACKAGE_NAME@
Version: @PACKAGE_VERSION@ Version: @PACKAGE_VERSION@
Release: 0 Release: 0
Summary: LLVM (An Optimizing Compiler Infrastructure) Summary: LLVM (An Optimizing Compiler Infrastructure)
License: Apache-2.0 with LLVM exception License: Apache-2.0 with LLVM exception
Vendor: None (open source) Vendor: None (open source)
Group: Development/Compilers Group: Development/Compilers
URL: http://llvm..org/ URL: https://llvm..org/
Source: http://llvm.org/releases/@PACKAGE_VERSION@/@PACKAGE_NAME@-@PACKAGE_VERSION@.tar.gz Source: https://llvm.org/releases/@PACKAGE_VERSION@/@PACKAGE_NAME@-@PACKAGE_VERSION@.tar.gz
BuildRoot: %{_tmppath}/%{name}-root BuildRoot: %{_tmppath}/%{name}-root
Requires: /sbin/ldconfig Requires: /sbin/ldconfig
BuildRequires: gcc >= 3.4 BuildRequires: gcc >= 3.4
%description %description
LLVM is a compiler infrastructure designed for compile-time, link-time, runtime, LLVM is a compiler infrastructure designed for compile-time, link-time, runtime,
and idle-time optimization of programs from arbitrary programming languages. and idle-time optimization of programs from arbitrary programming languages.
LLVM is written in C++ and has been developed since 2000 at the University of LLVM is written in C++ and has been developed since 2000 at the University of
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
* Fri Aug 04 2006 Reid Spencer * Fri Aug 04 2006 Reid Spencer
- Updates for release 1.8 - Updates for release 1.8
* Fri Apr 07 2006 Reid Spencer * Fri Apr 07 2006 Reid Spencer
- Make the build be optimized+assertions - Make the build be optimized+assertions
* Fri May 13 2005 Reid Spencer * Fri May 13 2005 Reid Spencer
- Minor adjustments for the 1.5 release - Minor adjustments for the 1.5 release
* Mon Feb 09 2003 Brian R. Gaeke * Mon Feb 09 2003 Brian R. Gaeke
- Initial working version of RPM spec file. - Initial working version of RPM spec file.

llvm/test/Analysis/MemorySSA/pr39197.ll

Show First 20 Lines • Show All 133 Lines • ▼ Show 20 Lines
} }
attributes #0 = { nounwind "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "frame-pointer"="none" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="z13" "target-features"="+transactional-execution,+vector" "unsafe-fp-math"="false" "use-soft-float"="false" } attributes #0 = { nounwind "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "frame-pointer"="none" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="z13" "target-features"="+transactional-execution,+vector" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #1 = { argmemonly nounwind } attributes #1 = { argmemonly nounwind }
attributes #2 = { nounwind } attributes #2 = { nounwind }
!llvm.ident = !{!0} !llvm.ident = !{!0}
!0 = !{!"clang version 8.0.0 (http://llvm.org/git/clang.git 7cda4756fc9713d98fd3513b8df172700f267bad) (http://llvm.org/git/llvm.git 199c0d32e96b646bd8cf6beeaf0f99f8a434b56a)"} !0 = !{!"clang version 8.0.0 (https://llvm.org/git/clang.git 7cda4756fc9713d98fd3513b8df172700f267bad) (https://llvm.org/git/llvm.git 199c0d32e96b646bd8cf6beeaf0f99f8a434b56a)"}
!1 = !{!2, !2, i64 0} !1 = !{!2, !2, i64 0}
!2 = !{!"short", !3, i64 0} !2 = !{!"short", !3, i64 0}
!3 = !{!"omnipotent char", !4, i64 0} !3 = !{!"omnipotent char", !4, i64 0}
!4 = !{!"Simple C/C++ TBAA"} !4 = !{!"Simple C/C++ TBAA"}
!5 = !{!6, !6, i64 0} !5 = !{!6, !6, i64 0}
!6 = !{!"long", !3, i64 0} !6 = !{!"long", !3, i64 0}
!7 = !{!8, !8, i64 0} !7 = !{!8, !8, i64 0}
!8 = !{!"any pointer", !3, i64 0} !8 = !{!"any pointer", !3, i64 0}
!9 = !{!10, !10, i64 0} !9 = !{!10, !10, i64 0}
!10 = !{!"int", !3, i64 0} !10 = !{!"int", !3, i64 0}
!11 = !{!3, !3, i64 0} !11 = !{!3, !3, i64 0}

llvm/test/Analysis/MemorySSA/pr40038.ll

Show First 20 Lines • Show All 69 Lines • ▼ Show 20 Lines
; Function Attrs: cold noreturn nounwind ; Function Attrs: cold noreturn nounwind
declare void @llvm.trap() #1 declare void @llvm.trap() #1
attributes #0 = { nounwind "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "min-legal-vector-width"="0" "frame-pointer"="none" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="z13" "target-features"="+transactional-execution,+vector" "unsafe-fp-math"="false" "use-soft-float"="false" } attributes #0 = { nounwind "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "min-legal-vector-width"="0" "frame-pointer"="none" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="z13" "target-features"="+transactional-execution,+vector" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #1 = { cold noreturn nounwind } attributes #1 = { cold noreturn nounwind }
!llvm.ident = !{!0} !llvm.ident = !{!0}
!0 = !{!"clang version 8.0.0 (http://llvm.org/git/clang.git a674a04e68bcf09f9a0423f3f589589596bc01a6) (http://llvm.org/git/llvm.git 1fe1ffe00e034128d1c5504254fdd4742f48bb9a)"} !0 = !{!"clang version 8.0.0 (https://llvm.org/git/clang.git a674a04e68bcf09f9a0423f3f589589596bc01a6) (https://llvm.org/git/llvm.git 1fe1ffe00e034128d1c5504254fdd4742f48bb9a)"}
!1 = !{!2, !2, i64 0} !1 = !{!2, !2, i64 0}
!2 = !{!"int", !3, i64 0} !2 = !{!"int", !3, i64 0}
!3 = !{!"omnipotent char", !4, i64 0} !3 = !{!"omnipotent char", !4, i64 0}
!4 = !{!"Simple C/C++ TBAA"} !4 = !{!"Simple C/C++ TBAA"}
!5 = !{!3, !3, i64 0} !5 = !{!3, !3, i64 0}

llvm/test/Bitcode/compatibility.ll

; Bitcode compatibility test for llvm ; Bitcode compatibility test for llvm
; ;
; Please update this file when making any IR changes. Information on the ; Please update this file when making any IR changes. Information on the
; release process for this file is available here: ; release process for this file is available here:
; ;
; http://llvm.org/docs/DeveloperPolicy.html#ir-backwards-compatibility ; https://llvm.org/docs/DeveloperPolicy.html#ir-backwards-compatibility
; RUN: llvm-as < %s | llvm-dis | llvm-as | llvm-dis | FileCheck %s ; RUN: llvm-as < %s | llvm-dis | llvm-as | llvm-dis | FileCheck %s
; RUN: verify-uselistorder < %s ; RUN: verify-uselistorder < %s
target datalayout = "E" target datalayout = "E"
; CHECK: target datalayout = "E" ; CHECK: target datalayout = "E"
target triple = "x86_64-apple-macosx10.10.0" target triple = "x86_64-apple-macosx10.10.0"
▲ Show 20 Lines • Show All 2,028 Lines • Show Last 20 Lines

llvm/test/CodeGen/AArch64/arm64-ccmp.ll

Show First 20 Lines • Show All 1,200 Lines • ▼ Show 20 Lines
; GISEL-NEXT: ret ; GISEL-NEXT: ret
%c0 = fcmp olt fp128 %v0, %v1 %c0 = fcmp olt fp128 %v0, %v1
%c1 = fcmp oge fp128 %v2, %v3 %c1 = fcmp oge fp128 %v2, %v3
%cr = and i1 %c1, %c0 %cr = and i1 %c1, %c0
%sel = select i1 %cr, i32 %a, i32 %b %sel = select i1 %cr, i32 %a, i32 %b
ret i32 %sel ret i32 %sel
} }
; This testcase resembles the core problem of http://llvm.org/PR39550 ; This testcase resembles the core problem of https://llvm.org/PR39550
; (an OR operation is 2 levels deep but needs to be implemented first) ; (an OR operation is 2 levels deep but needs to be implemented first)
define i32 @deep_or(i32 %a0, i32 %a1, i32 %a2, i32 %a3, i32 %x, i32 %y) { define i32 @deep_or(i32 %a0, i32 %a1, i32 %a2, i32 %a3, i32 %x, i32 %y) {
; CHECK-LABEL: deep_or: ; CHECK-LABEL: deep_or:
; CHECK: ; %bb.0: ; CHECK: ; %bb.0:
; CHECK-NEXT: cmp w2, #20 ; CHECK-NEXT: cmp w2, #20
; CHECK-NEXT: ccmp w2, #15, #4, ne ; CHECK-NEXT: ccmp w2, #15, #4, ne
; CHECK-NEXT: ccmp w1, #0, #4, eq ; CHECK-NEXT: ccmp w1, #0, #4, eq
; CHECK-NEXT: ccmp w0, #0, #4, ne ; CHECK-NEXT: ccmp w0, #0, #4, ne
▲ Show 20 Lines • Show All 211 Lines • Show Last 20 Lines

llvm/test/CodeGen/AMDGPU/attr-amdgpu-num-sgpr.ll

Show First 20 Lines • Show All 80 Lines • ▼ Show 20 Lines
; ;
; store i32 %one, i32 addrspace(1)* %out1 ; store i32 %one, i32 addrspace(1)* %out1
; store i32 %two, i32 addrspace(1)* %out2 ; store i32 %two, i32 addrspace(1)* %out2
; store i32 %three, i32 addrspace(1)* %out3 ; store i32 %three, i32 addrspace(1)* %out3
; store i32 %four, i32 addrspace(1)* %out4 ; store i32 %four, i32 addrspace(1)* %out4
; ret void ; ret void
;} ;}
; The following test is commented out for now; http://llvm.org/PR31230 ; The following test is commented out for now; https://llvm.org/PR31230
; XALL-LABEL: max_12_sgprs_12_input_sgprs{{$}} ; XALL-LABEL: max_12_sgprs_12_input_sgprs{{$}}
; ; Make sure copies for input buffer are not clobbered. This requires ; ; Make sure copies for input buffer are not clobbered. This requires
; ; swapping the order the registers are copied from what normally ; ; swapping the order the registers are copied from what normally
; ; happens. ; ; happens.
; XALL: SGPRBlocks: 2 ; XALL: SGPRBlocks: 2
; XALL: NumSGPRsForWavesPerEU: 18 ; XALL: NumSGPRsForWavesPerEU: 18
;define amdgpu_kernel void @max_12_sgprs_12_input_sgprs(i32 addrspace(1)* %out1, ;define amdgpu_kernel void @max_12_sgprs_12_input_sgprs(i32 addrspace(1)* %out1,
Show All 34 Lines

llvm/test/CodeGen/AMDGPU/coalescer-subregjoin-fullcopy.mir

# RUN: llc -march=amdgcn -run-pass simple-register-coalescing -verify-machineinstrs -o - %s | FileCheck --check-prefix=GCN %s # RUN: llc -march=amdgcn -run-pass simple-register-coalescing -verify-machineinstrs -o - %s | FileCheck --check-prefix=GCN %s
# #
# See bug http://llvm.org/PR33152 for details of the bug this test is checking # See bug https://llvm.org/PR33152 for details of the bug this test is checking
# for. # for.
# This test will provoke a subrange join during simple register # This test will provoke a subrange join during simple register
# coalescing. Withough a fix for PR33152 this causes an unreachable in SubRange # coalescing. Withough a fix for PR33152 this causes an unreachable in SubRange
# Join # Join
# #
# The lines where the problem exhibits are the last 2 copy instructions in the # The lines where the problem exhibits are the last 2 copy instructions in the
# BB (bb.25) # BB (bb.25)
# #
▲ Show 20 Lines • Show All 166 Lines • Show Last 20 Lines

llvm/test/CodeGen/AMDGPU/regcoal-subrange-join-seg.mir

# RUN: llc -march=amdgcn -run-pass simple-register-coalescing -o - %s | FileCheck --check-prefix=GCN %s # RUN: llc -march=amdgcn -run-pass simple-register-coalescing -o - %s | FileCheck --check-prefix=GCN %s
# REQUIRES: asserts # REQUIRES: asserts
# #
# This test will provoke a Couldn't join subrange unreachable without the # This test will provoke a Couldn't join subrange unreachable without the
# fix for http://llvm.org/PR35373 # fix for https://llvm.org/PR35373
# #
# GCN: S_CBRANCH_SCC1 %bb.6, implicit undef $scc # GCN: S_CBRANCH_SCC1 %bb.6, implicit undef $scc
--- | --- |
define amdgpu_ps void @regcoal-subrange-join-seg() local_unnamed_addr #0 { define amdgpu_ps void @regcoal-subrange-join-seg() local_unnamed_addr #0 {
ret void ret void
} }
... ...
▲ Show 20 Lines • Show All 226 Lines • Show Last 20 Lines

llvm/test/CodeGen/AMDGPU/regcoal-subrange-join.mir

# RUN: llc -march=amdgcn -run-pass simple-register-coalescing -o - %s | FileCheck --check-prefix=GCN %s # RUN: llc -march=amdgcn -run-pass simple-register-coalescing -o - %s | FileCheck --check-prefix=GCN %s
# #
# See bug http://llvm.org/PR33524 for details of the problem being checked here # See bug https://llvm.org/PR33524 for details of the problem being checked here
# This test will provoke a subrange join (see annotations below) during simple register coalescing # This test will provoke a subrange join (see annotations below) during simple register coalescing
# Without a fix for PR33524 this causes an unreachable in SubRange Join # Without a fix for PR33524 this causes an unreachable in SubRange Join
# #
# GCN-DAG: undef %[[REG0:[0-9]+]].sub0:sgpr_64 = COPY $sgpr5 # GCN-DAG: undef %[[REG0:[0-9]+]].sub0:sgpr_64 = COPY $sgpr5
# GCN-DAG: undef %[[REG1:[0-9]+]].sub0:sgpr_64 = COPY $sgpr2 # GCN-DAG: undef %[[REG1:[0-9]+]].sub0:sgpr_64 = COPY $sgpr2
# GCN-DAG: %[[REG0]].sub1:sgpr_64 = S_MOV_B32 1 # GCN-DAG: %[[REG0]].sub1:sgpr_64 = S_MOV_B32 1
# GCN-DAG: %[[REG1]].sub1:sgpr_64 = S_MOV_B32 1 # GCN-DAG: %[[REG1]].sub1:sgpr_64 = S_MOV_B32 1
▲ Show 20 Lines • Show All 151 Lines • Show Last 20 Lines

llvm/test/CodeGen/ARM/2013-05-31-char-shift-crash.ll

; RUN: llc < %s -O0 -mtriple=armv4t--linux-eabi-android ; RUN: llc < %s -O0 -mtriple=armv4t--linux-eabi-android
; RUN: llc < %s -O0 -mtriple=armv4t-unknown-linux ; RUN: llc < %s -O0 -mtriple=armv4t-unknown-linux
; RUN: llc < %s -O0 -mtriple=armv5-unknown-linux ; RUN: llc < %s -O0 -mtriple=armv5-unknown-linux
; See http://llvm.org/bugs/show_bug.cgi?id=16178 ; See https://llvm.org/bugs/show_bug.cgi?id=16178
; ARMFastISel used to fail emitting sext/zext in pre-ARMv6. ; ARMFastISel used to fail emitting sext/zext in pre-ARMv6.
; Function Attrs: nounwind ; Function Attrs: nounwind
define arm_aapcscc void @f2(i8 signext %a) #0 { define arm_aapcscc void @f2(i8 signext %a) #0 {
entry: entry:
%a.addr = alloca i8, align 1 %a.addr = alloca i8, align 1
store i8 %a, i8* %a.addr, align 1 store i8 %a, i8* %a.addr, align 1
%0 = load i8, i8* %a.addr, align 1 %0 = load i8, i8* %a.addr, align 1
%conv = sext i8 %0 to i32 %conv = sext i8 %0 to i32
%shr = ashr i32 %conv, 56 %shr = ashr i32 %conv, 56
%conv1 = trunc i32 %shr to i8 %conv1 = trunc i32 %shr to i8
call arm_aapcscc void @f1(i8 signext %conv1) call arm_aapcscc void @f1(i8 signext %conv1)
ret void ret void
} }
declare arm_aapcscc void @f1(i8 signext) #1 declare arm_aapcscc void @f1(i8 signext) #1

llvm/test/CodeGen/AVR/pre-schedule.ll

; RUN: llc < %s -march=avr | FileCheck %s ; RUN: llc < %s -march=avr | FileCheck %s
target triple = "avr-unknown-unknown" target triple = "avr-unknown-unknown"
; The case illustrate DAG schedular may pre-schedule the node has ; The case illustrate DAG schedular may pre-schedule the node has
; ADJCALLSTACKDOWN parent, so ADJCALLSTACKUP may hold CallResource too long ; ADJCALLSTACKDOWN parent, so ADJCALLSTACKUP may hold CallResource too long
; and make other calls can't be scheduled. If there's no other available node ; and make other calls can't be scheduled. If there's no other available node
; to schedule, the scheduler will try to rename the register by creating the ; to schedule, the scheduler will try to rename the register by creating the
; copy to avoid the conflict which will fail because CallResource is not a real ; copy to avoid the conflict which will fail because CallResource is not a real
; physical register. ; physical register.
; ;
; The issue is found by Tim on https://github.com/avr-rust/rust/issues/111 and ; The issue is found by Tim on https://github.com/avr-rust/rust/issues/111 and
; discuss in http://lists.llvm.org/pipermail/llvm-dev/2018-October/127083.html. ; discuss in https://lists.llvm.org/pipermail/llvm-dev/2018-October/127083.html.
define void @"main"() addrspace(1) { define void @"main"() addrspace(1) {
start: start:
%0 = or i64 undef, undef %0 = or i64 undef, undef
br i1 undef, label %mul_and_call, label %fail br i1 undef, label %mul_and_call, label %fail
mul_and_call: mul_and_call:
%1 = mul i64 %0, %0 %1 = mul i64 %0, %0
Show All 12 Lines

llvm/test/CodeGen/Mips/fp16-promote.ll

Show First 20 Lines • Show All 52 Lines • ▼ Show 20 Lines
; CHECK-LIBCALL: %call16(__gnu_h2f_ieee) ; CHECK-LIBCALL: %call16(__gnu_h2f_ieee)
define <4 x float> @test_vec_fpext_float(<4 x half>* %p) #0 { define <4 x float> @test_vec_fpext_float(<4 x half>* %p) #0 {
%a = load <4 x half>, <4 x half>* %p, align 8 %a = load <4 x half>, <4 x half>* %p, align 8
%b = fpext <4 x half> %a to <4 x float> %b = fpext <4 x half> %a to <4 x float>
ret <4 x float> %b ret <4 x float> %b
} }
; This test is not robust against variations in instruction scheduling. ; This test is not robust against variations in instruction scheduling.
; See the discussion in http://reviews.llvm.org/D8804 ; See the discussion in https://reviews.llvm.org/D8804
; CHECK-LIBCALL-LABEL: test_vec_fpext_double: ; CHECK-LIBCALL-LABEL: test_vec_fpext_double:
; CHECK-LIBCALL: %call16(__gnu_h2f_ieee) ; CHECK-LIBCALL: %call16(__gnu_h2f_ieee)
; CHECK-LIBCALL: %call16(__gnu_h2f_ieee) ; CHECK-LIBCALL: %call16(__gnu_h2f_ieee)
; CHECK-LIBCALL: %call16(__gnu_h2f_ieee) ; CHECK-LIBCALL: %call16(__gnu_h2f_ieee)
; CHECK-LIBCALL: cvt.d.s ; CHECK-LIBCALL: cvt.d.s
; CHECK-LIBCALL: cvt.d.s ; CHECK-LIBCALL: cvt.d.s
; CHECK-LIBCALL: cvt.d.s ; CHECK-LIBCALL: cvt.d.s
; CHECK-LIBCALL: %call16(__gnu_h2f_ieee) ; CHECK-LIBCALL: %call16(__gnu_h2f_ieee)
Show All 20 Lines
; CHECK-LIBCALL: %call16(__truncdfhf2) ; CHECK-LIBCALL: %call16(__truncdfhf2)
; CHECK-LIBCALL: %call16(__truncdfhf2) ; CHECK-LIBCALL: %call16(__truncdfhf2)
; CHECK-LIBCALL: %call16(__truncdfhf2) ; CHECK-LIBCALL: %call16(__truncdfhf2)
define void @test_vec_fptrunc_double(<4 x double> %a, <4 x half>* %p) #0 { define void @test_vec_fptrunc_double(<4 x double> %a, <4 x half>* %p) #0 {
%b = fptrunc <4 x double> %a to <4 x half> %b = fptrunc <4 x double> %a to <4 x half>
store <4 x half> %b, <4 x half>* %p, align 8 store <4 x half> %b, <4 x half>* %p, align 8
ret void ret void
} }

llvm/test/CodeGen/SystemZ/load-and-test-RA-hints.mir

Show First 20 Lines • Show All 57 Lines • ▼ Show 20 Lines--- |
bb20: ; preds = %bb20, %bb20.preheader bb20: ; preds = %bb20, %bb20.preheader
br label %bb20 br label %bb20
} }
attributes #0 = { "target-cpu"="z13" "use-soft-float"="false" } attributes #0 = { "target-cpu"="z13" "use-soft-float"="false" }
!llvm.ident = !{!0} !llvm.ident = !{!0}
!0 = !{!"clang version 9.0.0 (http://llvm.org/git/clang.git 29e2813a2ab7d5569860bb07892dfef7b5374d96) (http://llvm.org/git/llvm.git 546f779cb9d4ac2ce9c9b9522019f500abca9522)"} !0 = !{!"clang version 9.0.0 (https://llvm.org/git/clang.git 29e2813a2ab7d5569860bb07892dfef7b5374d96) (https://llvm.org/git/llvm.git 546f779cb9d4ac2ce9c9b9522019f500abca9522)"}
!1 = !{!2, !2, i64 0} !1 = !{!2, !2, i64 0}
!2 = !{!"int", !3, i64 0} !2 = !{!"int", !3, i64 0}
!3 = !{!"omnipotent char", !4, i64 0} !3 = !{!"omnipotent char", !4, i64 0}
!4 = !{!"Simple C/C++ TBAA"} !4 = !{!"Simple C/C++ TBAA"}
... ...
# CHECK: ********** MACHINEINSTRS ********** # CHECK: ********** MACHINEINSTRS **********
▲ Show 20 Lines • Show All 92 Lines • Show Last 20 Lines

llvm/test/CodeGen/X86/2014-08-29-CompactUnwind.ll

; RUN: llc < %s -mtriple x86_64-apple-darwin11 -mcpu corei7 -filetype=obj -o - | llvm-objdump -d --unwind-info -s - | FileCheck %s ; RUN: llc < %s -mtriple x86_64-apple-darwin11 -mcpu corei7 -filetype=obj -o - | llvm-objdump -d --unwind-info -s - | FileCheck %s
; Regression test for http://llvm.org/bugs/show_bug.cgi?id=20800. ; Regression test for https://llvm.org/bugs/show_bug.cgi?id=20800.
; ModuleID = 'asan_report.ii' ; ModuleID = 'asan_report.ii'
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.9.0" target triple = "x86_64-apple-macosx10.9.0"
@.str = private unnamed_addr constant [3 x i8] c"=>\00", align 1 @.str = private unnamed_addr constant [3 x i8] c"=>\00", align 1
@.str1 = private unnamed_addr constant [3 x i8] c" \00", align 1 @.str1 = private unnamed_addr constant [3 x i8] c" \00", align 1
@.str2 = private unnamed_addr constant [6 x i8] c"%s%p:\00", align 1 @.str2 = private unnamed_addr constant [6 x i8] c"%s%p:\00", align 1
Show All 36 Lines

llvm/test/CodeGen/X86/MergeConsecutiveStores.ll

Show First 20 Lines • Show All 682 Lines • ▼ Show 20 Lines; <label>:1
%12 = add nsw i32 %.09, -1 %12 = add nsw i32 %.09, -1
%13 = icmp eq i32 %12, 0 %13 = icmp eq i32 %12, 0
br i1 %13, label %14, label %1 br i1 %13, label %14, label %1
; <label>:14 ; <label>:14
ret void ret void
} }
; PR21711 ( http://llvm.org/bugs/show_bug.cgi?id=21711 ) ; PR21711 ( https://llvm.org/bugs/show_bug.cgi?id=21711 )
define void @merge_vec_element_store(<8 x float> %v, float* %ptr) { define void @merge_vec_element_store(<8 x float> %v, float* %ptr) {
; CHECK-LABEL: merge_vec_element_store: ; CHECK-LABEL: merge_vec_element_store:
; CHECK: # %bb.0: ; CHECK: # %bb.0:
; CHECK-NEXT: vmovups %ymm0, (%rdi) ; CHECK-NEXT: vmovups %ymm0, (%rdi)
; CHECK-NEXT: vzeroupper ; CHECK-NEXT: vzeroupper
; CHECK-NEXT: retq ; CHECK-NEXT: retq
%vecext0 = extractelement <8 x float> %v, i32 0 %vecext0 = extractelement <8 x float> %v, i32 0
%vecext1 = extractelement <8 x float> %v, i32 1 %vecext1 = extractelement <8 x float> %v, i32 1
▲ Show 20 Lines • Show All 251 Lines • Show Last 20 Lines

llvm/test/CodeGen/X86/copy-propagation.ll

; RUN: llc %s -mattr=+avx -o - | FileCheck %s ; RUN: llc %s -mattr=+avx -o - | FileCheck %s
; Originally from http://llvm.org/PR21743. ; Originally from https://llvm.org/PR21743.
target triple = "x86_64-pc-win32-elf" target triple = "x86_64-pc-win32-elf"
; Copy propagation may remove COPYs if the result is only used by undef ; Copy propagation may remove COPYs if the result is only used by undef
; operands. ; operands.
; ;
; CHECK-LABEL: foo: ; CHECK-LABEL: foo:
; CHECK: movl $339752784, %e[[INDIRECT_CALL1:[a-z]+]] ; CHECK: movl $339752784, %e[[INDIRECT_CALL1:[a-z]+]]
Show All 22 Lines

llvm/test/CodeGen/X86/critical-anti-dep-breaker.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc < %s -mtriple=x86_64-unknown-linux-gnu -relocation-model=pic -post-RA-scheduler=1 -break-anti-dependencies=critical | FileCheck %s ; RUN: llc < %s -mtriple=x86_64-unknown-linux-gnu -relocation-model=pic -post-RA-scheduler=1 -break-anti-dependencies=critical | FileCheck %s
; PR20308 ( http://llvm.org/bugs/show_bug.cgi?id=20308 ). ; PR20308 ( https://llvm.org/bugs/show_bug.cgi?id=20308 ).
; The critical-anti-dependency-breaker must not use register def information from a kill inst. ; The critical-anti-dependency-breaker must not use register def information from a kill inst.
; This test case expects such an instruction to appear as a comment with def info for RDI. ; This test case expects such an instruction to appear as a comment with def info for RDI.
; There is an anti-dependency (WAR) hazard using RAX using default reg allocation and scheduling. ; There is an anti-dependency (WAR) hazard using RAX using default reg allocation and scheduling.
; The post-RA-scheduler and critical-anti-dependency breaker can eliminate that hazard using R10. ; The post-RA-scheduler and critical-anti-dependency breaker can eliminate that hazard using R10.
; That is the first free register that isn't used as a param in the call to "@Image". ; That is the first free register that isn't used as a param in the call to "@Image".
@PartClass = external global i32 @PartClass = external global i32
@NullToken = external global i64 @NullToken = external global i64
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

llvm/test/CodeGen/X86/dbg-changes-codegen-branch-folding.ll

; RUN: llc -mtriple=x86_64-linux < %s | FileCheck %s ; RUN: llc -mtriple=x86_64-linux < %s | FileCheck %s
; RUN: opt -strip-debug < %s | llc -mtriple=x86_64-linux | FileCheck %s ; RUN: opt -strip-debug < %s | llc -mtriple=x86_64-linux | FileCheck %s
; http://llvm.org/PR19051. Minor code-motion difference with -g. ; https://llvm.org/PR19051. Minor code-motion difference with -g.
; Presence of debug info shouldn't affect the codegen. Make sure that ; Presence of debug info shouldn't affect the codegen. Make sure that
; we generated the same code sequence with and without debug info. ; we generated the same code sequence with and without debug info.
; ;
; CHECK: callq _Z3fooPcjPKc ; CHECK: callq _Z3fooPcjPKc
; CHECK: callq _Z3fooPcjPKc ; CHECK: callq _Z3fooPcjPKc
; CHECK: movq %rsp, %rdi ; CHECK: movq %rsp, %rdi
; CHECK: testl {{%[a-z]+}}, {{%[a-z]+}} ; CHECK: testl {{%[a-z]+}}, {{%[a-z]+}}
; CHECK: je .LBB0_4 ; CHECK: je .LBB0_4
▲ Show 20 Lines • Show All 202 Lines • Show Last 20 Lines

llvm/test/CodeGen/X86/fmul-combines.ll

Show First 20 Lines • Show All 177 Lines • ▼ Show 20 Lines
; CHECK-NEXT: mulps {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm0 ; CHECK-NEXT: mulps {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm0
; CHECK-NEXT: retq ; CHECK-NEXT: retq
%y = fmul fast <4 x float> %x, <float 1.0, float 2.0, float 3.0, float 4.0> %y = fmul fast <4 x float> %x, <float 1.0, float 2.0, float 3.0, float 4.0>
%z = fmul fast <4 x float> %y, <float 5.0, float 6.0, float 7.0, float 8.0> %z = fmul fast <4 x float> %y, <float 5.0, float 6.0, float 7.0, float 8.0>
%a = fadd fast <4 x float> %y, %z %a = fadd fast <4 x float> %y, %z
ret <4 x float> %a ret <4 x float> %a
} }
; PR22698 - http://llvm.org/bugs/show_bug.cgi?id=22698 ; PR22698 - https://llvm.org/bugs/show_bug.cgi?id=22698
; Make sure that we don't infinite loop swapping constants back and forth. ; Make sure that we don't infinite loop swapping constants back and forth.
; CHECK: float 24 ; CHECK: float 24
; CHECK: float 24 ; CHECK: float 24
; CHECK: float 24 ; CHECK: float 24
; CHECK: float 24 ; CHECK: float 24
define <4 x float> @PR22698_splats(<4 x float> %a) { define <4 x float> @PR22698_splats(<4 x float> %a) {
▲ Show 20 Lines • Show All 88 Lines • Show Last 20 Lines

llvm/test/CodeGen/X86/fnabs.ll

; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mattr=avx| FileCheck %s ; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mattr=avx| FileCheck %s
; Verify that we generate a single OR instruction for a scalar, vec128, and vec256 ; Verify that we generate a single OR instruction for a scalar, vec128, and vec256
; FNABS(x) operation -> FNEG (FABS(x)). ; FNABS(x) operation -> FNEG (FABS(x)).
; If the FABS() result isn't used, the AND instruction should be eliminated. ; If the FABS() result isn't used, the AND instruction should be eliminated.
; PR20578: http://llvm.org/bugs/show_bug.cgi?id=20578 ; PR20578: https://llvm.org/bugs/show_bug.cgi?id=20578
define float @scalar_no_abs(float %a) { define float @scalar_no_abs(float %a) {
; CHECK-LABEL: scalar_no_abs: ; CHECK-LABEL: scalar_no_abs:
; CHECK: vorps ; CHECK: vorps
; CHECK-NEXT: retq ; CHECK-NEXT: retq
%fabs = tail call float @fabsf(float %a) #1 %fabs = tail call float @fabsf(float %a) #1
%fsub = fsub float -0.0, %fabs %fsub = fsub float -0.0, %fabs
ret float %fsub ret float %fsub
▲ Show 20 Lines • Show All 54 Lines • ▼ Show 20 Lines
} }
declare <4 x float> @llvm.fabs.v4f32(<4 x float> %p) declare <4 x float> @llvm.fabs.v4f32(<4 x float> %p)
declare <8 x float> @llvm.fabs.v8f32(<8 x float> %p) declare <8 x float> @llvm.fabs.v8f32(<8 x float> %p)
declare float @fabsf(float) declare float @fabsf(float)
attributes #1 = { readnone } attributes #1 = { readnone }

llvm/test/CodeGen/X86/fold-tied-op.ll

; RUN: llc -verify-machineinstrs -mtriple=i386--netbsd < %s | FileCheck %s ; RUN: llc -verify-machineinstrs -mtriple=i386--netbsd < %s | FileCheck %s
; Regression test for http://reviews.llvm.org/D5701 ; Regression test for https://reviews.llvm.org/D5701
; ModuleID = 'xxhash.i' ; ModuleID = 'xxhash.i'
target datalayout = "e-m:e-p:32:32-f64:32:64-f80:32-n8:16:32-S128" target datalayout = "e-m:e-p:32:32-f64:32:64-f80:32-n8:16:32-S128"
target triple = "i386--netbsd" target triple = "i386--netbsd"
; CHECK-LABEL: fn1 ; CHECK-LABEL: fn1
; CHECK: orl {{.*#+}} 4-byte Folded Reload ; CHECK: orl {{.*#+}} 4-byte Folded Reload
; CHECK: addl {{.*#+}} 4-byte Folded Reload ; CHECK: addl {{.*#+}} 4-byte Folded Reload
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

llvm/test/CodeGen/X86/lea-5.ll

; test for more complicated forms of lea operands which can be generated ; test for more complicated forms of lea operands which can be generated
; in loop optimized cases. ; in loop optimized cases.
; See also http://llvm.org/bugs/show_bug.cgi?id=20016 ; See also https://llvm.org/bugs/show_bug.cgi?id=20016
; RUN: llc < %s -mtriple=x86_64-linux -O2 | FileCheck %s ; RUN: llc < %s -mtriple=x86_64-linux -O2 | FileCheck %s
; RUN: llc < %s -mtriple=x86_64-linux-gnux32 -O2 | FileCheck %s -check-prefix=X32 ; RUN: llc < %s -mtriple=x86_64-linux-gnux32 -O2 | FileCheck %s -check-prefix=X32
; RUN: llc < %s -mtriple=x86_64-nacl -O2 | FileCheck %s -check-prefix=X32 ; RUN: llc < %s -mtriple=x86_64-nacl -O2 | FileCheck %s -check-prefix=X32
; Function Attrs: nounwind readnone uwtable ; Function Attrs: nounwind readnone uwtable
define void @foo(i32 %x, i32 %d) #0 { define void @foo(i32 %x, i32 %d) #0 {
entry: entry:
Show All 39 Lines
; CHECK: leaq 4(%r{{[^,]*}}), %r{{[^,]*}} ; CHECK: leaq 4(%r{{[^,]*}}), %r{{[^,]*}}
; X32: leal 4(%r{{[^,]*}}), %e{{[^,]*}} ; X32: leal 4(%r{{[^,]*}}), %e{{[^,]*}}
br i1 %cmp1, label %while.end, label %while.cond br i1 %cmp1, label %while.end, label %while.cond
while.end: ; preds = %while.cond while.end: ; preds = %while.cond
ret void ret void
} }

llvm/test/CodeGen/X86/logical-load-fold.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mattr=sse2,sse-unaligned-mem | FileCheck %s --check-prefix=SSE2 ; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mattr=sse2,sse-unaligned-mem | FileCheck %s --check-prefix=SSE2
; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mattr=avx | FileCheck %s --check-prefix=AVX ; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mattr=avx | FileCheck %s --check-prefix=AVX
; Although we have the ability to fold an unaligned load with AVX ; Although we have the ability to fold an unaligned load with AVX
; and under special conditions with some SSE implementations, we ; and under special conditions with some SSE implementations, we
; can not fold the load under any circumstances in these test ; can not fold the load under any circumstances in these test
; cases because they are not 16-byte loads. The load must be ; cases because they are not 16-byte loads. The load must be
; executed as a scalar ('movs*') with a zero extension to ; executed as a scalar ('movs*') with a zero extension to
; 128-bits and then used in the packed logical ('andp*') op. ; 128-bits and then used in the packed logical ('andp*') op.
; PR22371 - http://llvm.org/bugs/show_bug.cgi?id=22371 ; PR22371 - https://llvm.org/bugs/show_bug.cgi?id=22371
define double @load_double_no_fold(double %x, double %y) { define double @load_double_no_fold(double %x, double %y) {
; SSE2-LABEL: load_double_no_fold: ; SSE2-LABEL: load_double_no_fold:
; SSE2: # %bb.0: ; SSE2: # %bb.0:
; SSE2-NEXT: cmplesd %xmm0, %xmm1 ; SSE2-NEXT: cmplesd %xmm0, %xmm1
; SSE2-NEXT: movsd {{.*#+}} xmm0 = mem[0],zero ; SSE2-NEXT: movsd {{.*#+}} xmm0 = mem[0],zero
; SSE2-NEXT: andpd %xmm1, %xmm0 ; SSE2-NEXT: andpd %xmm1, %xmm0
; SSE2-NEXT: retq ; SSE2-NEXT: retq
Show All 26 Lines
; AVX-NEXT: vandps %xmm1, %xmm0, %xmm0 ; AVX-NEXT: vandps %xmm1, %xmm0, %xmm0
; AVX-NEXT: retq ; AVX-NEXT: retq
%cmp = fcmp oge float %x, %y %cmp = fcmp oge float %x, %y
%zext = zext i1 %cmp to i32 %zext = zext i1 %cmp to i32
%conv = sitofp i32 %zext to float %conv = sitofp i32 %zext to float
ret float %conv ret float %conv
} }

llvm/test/CodeGen/X86/recip-fastmath.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mattr=+sse2 | FileCheck %s --check-prefix=SSE ; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mattr=+sse2 | FileCheck %s --check-prefix=SSE
; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mattr=+avx | FileCheck %s --check-prefixes=AVX,AVX-RECIP ; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mattr=+avx | FileCheck %s --check-prefixes=AVX,AVX-RECIP
; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mattr=+avx,+fma | FileCheck %s --check-prefixes=AVX,FMA-RECIP ; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mattr=+avx,+fma | FileCheck %s --check-prefixes=AVX,FMA-RECIP
; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mcpu=bdver2 | FileCheck %s --check-prefixes=AVX,BDVER2 ; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mcpu=bdver2 | FileCheck %s --check-prefixes=AVX,BDVER2
; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mcpu=btver2 | FileCheck %s --check-prefixes=AVX,BTVER2 ; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mcpu=btver2 | FileCheck %s --check-prefixes=AVX,BTVER2
; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mcpu=sandybridge | FileCheck %s --check-prefixes=AVX,SANDY ; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mcpu=sandybridge | FileCheck %s --check-prefixes=AVX,SANDY
; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mcpu=haswell | FileCheck %s --check-prefixes=AVX,HASWELL ; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mcpu=haswell | FileCheck %s --check-prefixes=AVX,HASWELL
; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mcpu=haswell -mattr=-fma | FileCheck %s --check-prefixes=AVX,HASWELL-NO-FMA ; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mcpu=haswell -mattr=-fma | FileCheck %s --check-prefixes=AVX,HASWELL-NO-FMA
; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mcpu=knl | FileCheck %s --check-prefixes=AVX,AVX512,KNL ; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mcpu=knl | FileCheck %s --check-prefixes=AVX,AVX512,KNL
; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mcpu=skx | FileCheck %s --check-prefixes=AVX,AVX512,SKX ; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mcpu=skx | FileCheck %s --check-prefixes=AVX,AVX512,SKX
; If the target's divss/divps instructions are substantially ; If the target's divss/divps instructions are substantially
; slower than rcpss/rcpps with a Newton-Raphson refinement, ; slower than rcpss/rcpps with a Newton-Raphson refinement,
; we should generate the estimate sequence. ; we should generate the estimate sequence.
; See PR21385 ( http://llvm.org/bugs/show_bug.cgi?id=21385 ) ; See PR21385 ( https://llvm.org/bugs/show_bug.cgi?id=21385 )
; for details about the accuracy, speed, and implementation ; for details about the accuracy, speed, and implementation
; differences of x86 reciprocal estimates. ; differences of x86 reciprocal estimates.
define float @f32_no_estimate(float %x) #0 { define float @f32_no_estimate(float %x) #0 {
; SSE-LABEL: f32_no_estimate: ; SSE-LABEL: f32_no_estimate:
; SSE: # %bb.0: ; SSE: # %bb.0:
; SSE-NEXT: movss {{.*#+}} xmm1 = mem[0],zero,zero,zero ; SSE-NEXT: movss {{.*#+}} xmm1 = mem[0],zero,zero,zero
; SSE-NEXT: divss %xmm0, %xmm1 ; SSE-NEXT: divss %xmm0, %xmm1
▲ Show 20 Lines • Show All 1,372 Lines • ▼ Show 20 Lines
; AVX512-NEXT: retq ; AVX512-NEXT: retq
%div = fdiv fast <16 x float> <float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0>, %x %div = fdiv fast <16 x float> <float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0>, %x
ret <16 x float> %div ret <16 x float> %div
} }
attributes #0 = { "unsafe-fp-math"="true" "reciprocal-estimates"="!divf,!vec-divf" } attributes #0 = { "unsafe-fp-math"="true" "reciprocal-estimates"="!divf,!vec-divf" }
attributes #1 = { "unsafe-fp-math"="true" "reciprocal-estimates"="divf,vec-divf" } attributes #1 = { "unsafe-fp-math"="true" "reciprocal-estimates"="divf,vec-divf" }
attributes #2 = { "unsafe-fp-math"="true" "reciprocal-estimates"="divf:2,vec-divf:2" } attributes #2 = { "unsafe-fp-math"="true" "reciprocal-estimates"="divf:2,vec-divf:2" }

llvm/test/CodeGen/X86/stack-align.ll

; RUN: llc < %s -relocation-model=static -mcpu=yonah | FileCheck %s ; RUN: llc < %s -relocation-model=static -mcpu=yonah | FileCheck %s
; The double argument is at 4(esp) which is 16-byte aligned, but we ; The double argument is at 4(esp) which is 16-byte aligned, but we
; are required to read in extra bytes of memory in order to fold the ; are required to read in extra bytes of memory in order to fold the
; load. Bad Things may happen when reading/processing undefined bytes, ; load. Bad Things may happen when reading/processing undefined bytes,
; so don't fold the load. ; so don't fold the load.
; PR22371 / http://reviews.llvm.org/D7474 ; PR22371 / https://reviews.llvm.org/D7474
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128" target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
target triple = "i686-apple-darwin8" target triple = "i686-apple-darwin8"
@G = external global double @G = external global double
define void @test({ double, double }* byval({ double, double }) %z, double* %P) nounwind { define void @test({ double, double }* byval({ double, double }) %z, double* %P) nounwind {
entry: entry:
%tmp3 = load double, double* @G, align 16 ; <double> [#uses=1] %tmp3 = load double, double* @G, align 16 ; <double> [#uses=1]
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

llvm/test/CodeGen/X86/twoaddr-lea.ll

Show First 20 Lines • Show All 53 Lines • ▼ Show 20 Linesentry:
%0 = shl i64 %x, 1 %0 = shl i64 %x, 1
ret i64 %0 ret i64 %0
} }
@global = external global i32, align 4 @global = external global i32, align 4
@global2 = external global i64, align 8 @global2 = external global i64, align 8
; Test that liveness is properly updated and we do not encounter the ; Test that liveness is properly updated and we do not encounter the
; assert/crash from http://llvm.org/PR28301 ; assert/crash from https://llvm.org/PR28301
define void @ham() { define void @ham() {
; CHECK-LABEL: ham: ; CHECK-LABEL: ham:
; CHECK: ## %bb.0: ## %bb ; CHECK: ## %bb.0: ## %bb
; CHECK-NEXT: xorl %r8d, %r8d ; CHECK-NEXT: xorl %r8d, %r8d
; CHECK-NEXT: movq _global@GOTPCREL(%rip), %rdx ; CHECK-NEXT: movq _global@GOTPCREL(%rip), %rdx
; CHECK-NEXT: movq _global2@GOTPCREL(%rip), %rsi ; CHECK-NEXT: movq _global2@GOTPCREL(%rip), %rsi
; CHECK-NEXT: xorl %eax, %eax ; CHECK-NEXT: xorl %eax, %eax
; CHECK-NEXT: cmpl $10, %eax ; CHECK-NEXT: cmpl $10, %eax
▲ Show 20 Lines • Show All 93 Lines • Show Last 20 Lines

llvm/test/CodeGen/X86/vec_loadsingles.ll

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Lines; ALL-NEXT: retq
%c = load float, float* %idx3, align 8 %c = load float, float* %idx3, align 8
%vec4 = insertelement <4 x float> %vec2, float %c, i32 2 %vec4 = insertelement <4 x float> %vec2, float %c, i32 2
%idx5 = getelementptr inbounds float, float* %ptr, i64 3 %idx5 = getelementptr inbounds float, float* %ptr, i64 3
%d = load float, float* %idx5, align 8 %d = load float, float* %idx5, align 8
%vec6 = insertelement <4 x float> %vec4, float %d, i32 3 %vec6 = insertelement <4 x float> %vec4, float %d, i32 3
ret <4 x float> %vec6 ret <4 x float> %vec6
} }
; PR21710 ( http://llvm.org/bugs/show_bug.cgi?id=21710 ) ; PR21710 ( https://llvm.org/bugs/show_bug.cgi?id=21710 )
; Make sure that 32-byte vectors are handled efficiently. ; Make sure that 32-byte vectors are handled efficiently.
; If the target has slow 32-byte accesses, we should still generate ; If the target has slow 32-byte accesses, we should still generate
; 16-byte loads. ; 16-byte loads.
define <8 x float> @merge_8_floats(float* %ptr) { define <8 x float> @merge_8_floats(float* %ptr) {
; FAST32-LABEL: merge_8_floats: ; FAST32-LABEL: merge_8_floats:
; FAST32: # %bb.0: ; FAST32: # %bb.0:
; FAST32-NEXT: vmovups (%rdi), %ymm0 ; FAST32-NEXT: vmovups (%rdi), %ymm0
▲ Show 20 Lines • Show All 50 Lines • ▼ Show 20 Lines; SLOW32-NEXT: retq
%c = load double, double* %idx3, align 8 %c = load double, double* %idx3, align 8
%vec4 = insertelement <4 x double> %vec2, double %c, i32 2 %vec4 = insertelement <4 x double> %vec2, double %c, i32 2
%idx5 = getelementptr inbounds double, double* %ptr, i64 3 %idx5 = getelementptr inbounds double, double* %ptr, i64 3
%d = load double, double* %idx5, align 8 %d = load double, double* %idx5, align 8
%vec6 = insertelement <4 x double> %vec4, double %d, i32 3 %vec6 = insertelement <4 x double> %vec4, double %d, i32 3
ret <4 x double> %vec6 ret <4 x double> %vec6
} }
; PR21771 ( http://llvm.org/bugs/show_bug.cgi?id=21771 ) ; PR21771 ( https://llvm.org/bugs/show_bug.cgi?id=21771 )
; Recognize and combine consecutive loads even when the ; Recognize and combine consecutive loads even when the
; first of the combined loads is offset from the base address. ; first of the combined loads is offset from the base address.
define <4 x double> @merge_4_doubles_offset(double* %ptr) { define <4 x double> @merge_4_doubles_offset(double* %ptr) {
; FAST32-LABEL: merge_4_doubles_offset: ; FAST32-LABEL: merge_4_doubles_offset:
; FAST32: # %bb.0: ; FAST32: # %bb.0:
; FAST32-NEXT: vmovups 32(%rdi), %ymm0 ; FAST32-NEXT: vmovups 32(%rdi), %ymm0
; FAST32-NEXT: retq ; FAST32-NEXT: retq
; ;
Show All 11 Lines; SLOW32-NEXT: retq
%g = load double, double* %arrayidx6, align 8 %g = load double, double* %arrayidx6, align 8
%h = load double, double* %arrayidx7, align 8 %h = load double, double* %arrayidx7, align 8
%vecinit4 = insertelement <4 x double> undef, double %e, i32 0 %vecinit4 = insertelement <4 x double> undef, double %e, i32 0
%vecinit5 = insertelement <4 x double> %vecinit4, double %f, i32 1 %vecinit5 = insertelement <4 x double> %vecinit4, double %f, i32 1
%vecinit6 = insertelement <4 x double> %vecinit5, double %g, i32 2 %vecinit6 = insertelement <4 x double> %vecinit5, double %g, i32 2
%vecinit7 = insertelement <4 x double> %vecinit6, double %h, i32 3 %vecinit7 = insertelement <4 x double> %vecinit6, double %h, i32 3
ret <4 x double> %vecinit7 ret <4 x double> %vecinit7
} }

llvm/test/CodeGen/X86/vec_trunc_sext.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mattr=-sse4.1 | FileCheck %s --check-prefix=NO_SSE_41 ; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mattr=-sse4.1 | FileCheck %s --check-prefix=NO_SSE_41
; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mattr=+sse4.1 | FileCheck %s --check-prefix=SSE_41 ; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mattr=+sse4.1 | FileCheck %s --check-prefix=SSE_41
; PR20472 ( http://llvm.org/bugs/show_bug.cgi?id=20472 ) ; PR20472 ( https://llvm.org/bugs/show_bug.cgi?id=20472 )
; When sexting a trunc'd vector value, we can't eliminate the zext. ; When sexting a trunc'd vector value, we can't eliminate the zext.
; If we don't have SSE4.1, use punpck. ; If we don't have SSE4.1, use punpck.
; If we have SSE4.1, use pmovzx because it combines the load op. ; If we have SSE4.1, use pmovzx because it combines the load op.
; There may be a better way to do this using pshufb + pmovsx, ; There may be a better way to do this using pshufb + pmovsx,
; but that is beyond our current codegen capabilities. ; but that is beyond our current codegen capabilities.
define <4 x i32> @trunc_sext(<4 x i16>* %in) { define <4 x i32> @trunc_sext(<4 x i16>* %in) {
; NO_SSE_41-LABEL: trunc_sext: ; NO_SSE_41-LABEL: trunc_sext:
Show All 10 Lines
; SSE_41-NEXT: pslld $24, %xmm0 ; SSE_41-NEXT: pslld $24, %xmm0
; SSE_41-NEXT: psrad $24, %xmm0 ; SSE_41-NEXT: psrad $24, %xmm0
; SSE_41-NEXT: retq ; SSE_41-NEXT: retq
%load = load <4 x i16>, <4 x i16>* %in %load = load <4 x i16>, <4 x i16>* %in
%trunc = trunc <4 x i16> %load to <4 x i8> %trunc = trunc <4 x i16> %load to <4 x i8>
%sext = sext <4 x i8> %trunc to <4 x i32> %sext = sext <4 x i8> %trunc to <4 x i32>
ret <4 x i32> %sext ret <4 x i32> %sext
} }

llvm/test/CodeGen/X86/vector-trunc.ll

Show First 20 Lines • Show All 1,680 Lines • ▼ Show 20 Lines
; AVX512BWVL-NEXT: retq ; AVX512BWVL-NEXT: retq
entry: entry:
%0 = trunc <4 x i32> %a to <4 x i16> %0 = trunc <4 x i32> %a to <4 x i16>
%1 = trunc <4 x i32> %b to <4 x i16> %1 = trunc <4 x i32> %b to <4 x i16>
%2 = shufflevector <4 x i16> %0, <4 x i16> %1, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7> %2 = shufflevector <4 x i16> %0, <4 x i16> %1, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
ret <8 x i16> %2 ret <8 x i16> %2
} }
; PR15524 http://llvm.org/bugs/show_bug.cgi?id=15524 ; PR15524 https://llvm.org/bugs/show_bug.cgi?id=15524
define i64 @trunc4i32_i64(<4 x i32> %inval) { define i64 @trunc4i32_i64(<4 x i32> %inval) {
; SSE2-LABEL: trunc4i32_i64: ; SSE2-LABEL: trunc4i32_i64:
; SSE2: # %bb.0: # %entry ; SSE2: # %bb.0: # %entry
; SSE2-NEXT: pshuflw {{.*#+}} xmm0 = xmm0[0,2,2,3,4,5,6,7] ; SSE2-NEXT: pshuflw {{.*#+}} xmm0 = xmm0[0,2,2,3,4,5,6,7]
; SSE2-NEXT: pshufhw {{.*#+}} xmm0 = xmm0[0,1,2,3,4,6,6,7] ; SSE2-NEXT: pshufhw {{.*#+}} xmm0 = xmm0[0,1,2,3,4,6,6,7]
; SSE2-NEXT: pshufd {{.*#+}} xmm0 = xmm0[0,2,2,3] ; SSE2-NEXT: pshufd {{.*#+}} xmm0 = xmm0[0,2,2,3]
; SSE2-NEXT: movq %xmm0, %rax ; SSE2-NEXT: movq %xmm0, %rax
; SSE2-NEXT: retq ; SSE2-NEXT: retq
▲ Show 20 Lines • Show All 112 Lines • ▼ Show 20 Lines
; AVX512BWVL-NEXT: retq ; AVX512BWVL-NEXT: retq
entry: entry:
%0 = trunc <8 x i16> %a to <8 x i8> %0 = trunc <8 x i16> %a to <8 x i8>
%1 = trunc <8 x i16> %b to <8 x i8> %1 = trunc <8 x i16> %b to <8 x i8>
%2 = shufflevector <8 x i8> %0, <8 x i8> %1, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15> %2 = shufflevector <8 x i8> %0, <8 x i8> %1, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15>
ret <16 x i8> %2 ret <16 x i8> %2
} }
; PR15524 http://llvm.org/bugs/show_bug.cgi?id=15524 ; PR15524 https://llvm.org/bugs/show_bug.cgi?id=15524
define i64 @trunc8i16_i64(<8 x i16> %inval) { define i64 @trunc8i16_i64(<8 x i16> %inval) {
; SSE2-LABEL: trunc8i16_i64: ; SSE2-LABEL: trunc8i16_i64:
; SSE2: # %bb.0: # %entry ; SSE2: # %bb.0: # %entry
; SSE2-NEXT: pand {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm0 ; SSE2-NEXT: pand {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm0
; SSE2-NEXT: packuswb %xmm0, %xmm0 ; SSE2-NEXT: packuswb %xmm0, %xmm0
; SSE2-NEXT: movq %xmm0, %rax ; SSE2-NEXT: movq %xmm0, %rax
; SSE2-NEXT: retq ; SSE2-NEXT: retq
; ;
▲ Show 20 Lines • Show All 352 Lines • Show Last 20 Lines

llvm/test/DebugInfo/Generic/two-cus-from-same-file.ll

; For http://llvm.org/bugs/show_bug.cgi?id=12942 ; For https://llvm.org/bugs/show_bug.cgi?id=12942
; There are two CUs coming from /tmp/foo.c in this module. Make sure it doesn't ; There are two CUs coming from /tmp/foo.c in this module. Make sure it doesn't
; blow llc up and produces something reasonable. ; blow llc up and produces something reasonable.
; ;
; RUN: %llc_dwarf %s -o %t -filetype=obj -O0 ; RUN: %llc_dwarf %s -o %t -filetype=obj -O0
; RUN: llvm-dwarfdump -debug-info %t | FileCheck %s ; RUN: llvm-dwarfdump -debug-info %t | FileCheck %s
; ModuleID = 'test.bc' ; ModuleID = 'test.bc'
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

llvm/test/ExecutionEngine/MCJIT/remote/lit.local.cfg

if 'armv4' in config.root.target_triple or \ if 'armv4' in config.root.target_triple or \
'armv5' in config.root.target_triple: 'armv5' in config.root.target_triple:
config.unsupported = True config.unsupported = True
# This is temporary, until Remote MCJIT works on ARM # This is temporary, until Remote MCJIT works on ARM
# See http://llvm.org/bugs/show_bug.cgi?id=18057 # See https://llvm.org/bugs/show_bug.cgi?id=18057
#if 'armv7' in config.root.target_triple: #if 'armv7' in config.root.target_triple:
# config.unsupported = True # config.unsupported = True

llvm/test/MC/ARM/thumb2-ldrb-ldrh.s

@ RUN: not llvm-mc -triple thumbv7a-none-eabi -show-encoding < %s 2>&1 | FileCheck %s @ RUN: not llvm-mc -triple thumbv7a-none-eabi -show-encoding < %s 2>&1 | FileCheck %s
@ RUN: not llvm-mc -triple thumbv7m-none-eabi -show-encoding < %s 2>&1 | FileCheck %s @ RUN: not llvm-mc -triple thumbv7m-none-eabi -show-encoding < %s 2>&1 | FileCheck %s
@ Thumb2 LDRS?[BH] are not valid when Rt == PC (these encodings are used for @ Thumb2 LDRS?[BH] are not valid when Rt == PC (these encodings are used for
@ preload hints). @ preload hints).
@ We don't check the actual error messages here as they are currently not very @ We don't check the actual error messages here as they are currently not very
@ helpful, see http://llvm.org/bugs/show_bug.cgi?id=21066. @ helpful, see https://llvm.org/bugs/show_bug.cgi?id=21066.
@ CHECK: error: @ CHECK: error:
@ CHECK: error: @ CHECK: error:
@ CHECK: error: @ CHECK: error:
@ CHECK: error: @ CHECK: error:
@ CHECK: error: @ CHECK: error:
ldrb pc, [r0, #10] ldrb pc, [r0, #10]
ldrb.w pc, [r1, #10] ldrb.w pc, [r1, #10]
Show All 36 Lines

llvm/test/MC/ELF/x86_64-reloc-sizetest.s

// RUN: llvm-mc -triple x86_64-linux-gnu -filetype=obj %s | llvm-readobj -r - | FileCheck %s // RUN: llvm-mc -triple x86_64-linux-gnu -filetype=obj %s | llvm-readobj -r - | FileCheck %s
// Tests that relocation value fits in the provided size // Tests that relocation value fits in the provided size
// Original bug http://llvm.org/bugs/show_bug.cgi?id=10568 // Original bug https://llvm.org/bugs/show_bug.cgi?id=10568
L: movq $(L + 2147483648),%rax L: movq $(L + 2147483648),%rax
// CHECK: Relocations [ // CHECK: Relocations [
// CHECK-NEXT: Section ({{[0-9]+}}) .rela.text { // CHECK-NEXT: Section ({{[0-9]+}}) .rela.text {
// CHECK-NEXT: 0x3 R_X86_64_32S {{[^ ]+}} 0x80000000 // CHECK-NEXT: 0x3 R_X86_64_32S {{[^ ]+}} 0x80000000
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: ] // CHECK-NEXT: ]

llvm/test/Transforms/Attributor/ArgumentPromotion/fp80.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -attributor -enable-new-pm=0 -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_CGSCC_NPM,NOT_CGSCC_OPM,NOT_TUNIT_NPM,IS__TUNIT____,IS________OPM,IS__TUNIT_OPM ; RUN: opt -attributor -enable-new-pm=0 -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_CGSCC_NPM,NOT_CGSCC_OPM,NOT_TUNIT_NPM,IS__TUNIT____,IS________OPM,IS__TUNIT_OPM
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_CGSCC_OPM,NOT_CGSCC_NPM,NOT_TUNIT_OPM,IS__TUNIT____,IS________NPM,IS__TUNIT_NPM ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_CGSCC_OPM,NOT_CGSCC_NPM,NOT_TUNIT_OPM,IS__TUNIT____,IS________NPM,IS__TUNIT_NPM
; TODO: The old pass manager cgscc run is disabled as it causes a crash on windows which is under investigation: http://lab.llvm.org:8011/builders/llvm-clang-x86_64-expensive-checks-win/builds/23151 ; TODO: The old pass manager cgscc run is disabled as it causes a crash on windows which is under investigation: https://lab.llvm.org:8011/builders/llvm-clang-x86_64-expensive-checks-win/builds/23151
; opt -attributor-cgscc -enable-new-pm=0 -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_TUNIT_NPM,NOT_TUNIT_OPM,NOT_CGSCC_NPM,IS__CGSCC____,IS________OPM,IS__CGSCC_OPM ; opt -attributor-cgscc -enable-new-pm=0 -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_TUNIT_NPM,NOT_TUNIT_OPM,NOT_CGSCC_NPM,IS__CGSCC____,IS________OPM,IS__CGSCC_OPM
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_TUNIT_NPM,NOT_TUNIT_OPM,NOT_CGSCC_OPM,IS__CGSCC____,IS________NPM,IS__CGSCC_NPM ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_TUNIT_NPM,NOT_TUNIT_OPM,NOT_CGSCC_OPM,IS__CGSCC____,IS________NPM,IS__CGSCC_NPM
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
%union.u = type { x86_fp80 } %union.u = type { x86_fp80 }
%struct.s = type { double, i16, i8, [5 x i8] } %struct.s = type { double, i16, i8, [5 x i8] }
▲ Show 20 Lines • Show All 118 Lines • Show Last 20 Lines

llvm/test/Transforms/Attributor/liveness.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -attributor -enable-new-pm=0 -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=30 -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_CGSCC_NPM,NOT_CGSCC_OPM,NOT_TUNIT_NPM,IS__TUNIT____,IS________OPM,IS__TUNIT_OPM ; RUN: opt -attributor -enable-new-pm=0 -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=30 -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_CGSCC_NPM,NOT_CGSCC_OPM,NOT_TUNIT_NPM,IS__TUNIT____,IS________OPM,IS__TUNIT_OPM
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=30 -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_CGSCC_OPM,NOT_CGSCC_NPM,NOT_TUNIT_OPM,IS__TUNIT____,IS________NPM,IS__TUNIT_NPM ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=30 -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_CGSCC_OPM,NOT_CGSCC_NPM,NOT_TUNIT_OPM,IS__TUNIT____,IS________NPM,IS__TUNIT_NPM
; TODO: The old pass manager cgscc run is disabled as it causes a crash on windows which is under investigation: http://lab.llvm.org:8011/builders/llvm-clang-x86_64-expensive-checks-win/builds/23151 ; TODO: The old pass manager cgscc run is disabled as it causes a crash on windows which is under investigation: https://lab.llvm.org:8011/builders/llvm-clang-x86_64-expensive-checks-win/builds/23151
; opt -attributor-cgscc -enable-new-pm=0 -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_TUNIT_NPM,NOT_TUNIT_OPM,NOT_CGSCC_NPM,IS__CGSCC____,IS________OPM,IS__CGSCC_OPM ; opt -attributor-cgscc -enable-new-pm=0 -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_TUNIT_NPM,NOT_TUNIT_OPM,NOT_CGSCC_NPM,IS__CGSCC____,IS________OPM,IS__CGSCC_OPM
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_TUNIT_NPM,NOT_TUNIT_OPM,NOT_CGSCC_OPM,IS__CGSCC____,IS________NPM,IS__CGSCC_NPM ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_TUNIT_NPM,NOT_TUNIT_OPM,NOT_CGSCC_OPM,IS__CGSCC____,IS________NPM,IS__CGSCC_NPM
; NOT_CGSCC___: @dead_with_blockaddress_users.l = constant [2 x i8*] [i8* inttoptr (i32 1 to i8*), i8* inttoptr (i32 1 to i8*)] ; NOT_CGSCC___: @dead_with_blockaddress_users.l = constant [2 x i8*] [i8* inttoptr (i32 1 to i8*), i8* inttoptr (i32 1 to i8*)]
; IS__CGSCC___: @dead_with_blockaddress_users.l = constant [2 x i8*] [i8* blockaddress(@dead_with_blockaddress_users, %lab0), i8* blockaddress(@dead_with_blockaddress_users, %end)] ; IS__CGSCC___: @dead_with_blockaddress_users.l = constant [2 x i8*] [i8* blockaddress(@dead_with_blockaddress_users, %lab0), i8* blockaddress(@dead_with_blockaddress_users, %end)]
@dead_with_blockaddress_users.l = constant [2 x i8*] [i8* blockaddress(@dead_with_blockaddress_users, %lab0), i8* blockaddress(@dead_with_blockaddress_users, %end)] @dead_with_blockaddress_users.l = constant [2 x i8*] [i8* blockaddress(@dead_with_blockaddress_users, %lab0), i8* blockaddress(@dead_with_blockaddress_users, %end)]
declare void @no_return_call() nofree noreturn nounwind nosync declare void @no_return_call() nofree noreturn nounwind nosync
▲ Show 20 Lines • Show All 2,686 Lines • Show Last 20 Lines

llvm/test/Transforms/Attributor/noalias.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -attributor -enable-new-pm=0 -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_CGSCC_NPM,NOT_CGSCC_OPM,NOT_TUNIT_NPM,IS__TUNIT____,IS________OPM,IS__TUNIT_OPM ; RUN: opt -attributor -enable-new-pm=0 -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_CGSCC_NPM,NOT_CGSCC_OPM,NOT_TUNIT_NPM,IS__TUNIT____,IS________OPM,IS__TUNIT_OPM
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_CGSCC_OPM,NOT_CGSCC_NPM,NOT_TUNIT_OPM,IS__TUNIT____,IS________NPM,IS__TUNIT_NPM ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_CGSCC_OPM,NOT_CGSCC_NPM,NOT_TUNIT_OPM,IS__TUNIT____,IS________NPM,IS__TUNIT_NPM
; TODO: The old pass manager cgscc run is disabled as it causes a crash on windows which is under investigation: http://lab.llvm.org:8011/builders/llvm-clang-x86_64-expensive-checks-win/builds/25479/steps/test-check-all/logs/FAIL%3A%20LLVM%3A%3Anoalias.ll ; TODO: The old pass manager cgscc run is disabled as it causes a crash on windows which is under investigation: https://lab.llvm.org:8011/builders/llvm-clang-x86_64-expensive-checks-win/builds/25479/steps/test-check-all/logs/FAIL%3A%20LLVM%3A%3Anoalias.ll
; opt -attributor-cgscc -enable-new-pm=0 -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_TUNIT_NPM,NOT_TUNIT_OPM,NOT_CGSCC_NPM,IS__CGSCC____,IS________OPM,IS__CGSCC_OPM ; opt -attributor-cgscc -enable-new-pm=0 -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_TUNIT_NPM,NOT_TUNIT_OPM,NOT_CGSCC_NPM,IS__CGSCC____,IS________OPM,IS__CGSCC_OPM
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_TUNIT_NPM,NOT_TUNIT_OPM,NOT_CGSCC_OPM,IS__CGSCC____,IS________NPM,IS__CGSCC_NPM ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_TUNIT_NPM,NOT_TUNIT_OPM,NOT_CGSCC_OPM,IS__CGSCC____,IS________NPM,IS__CGSCC_NPM
; TEST 1 - negative. ; TEST 1 - negative.
; void *G; ; void *G;
; void *foo(){ ; void *foo(){
; void *V = malloc(4); ; void *V = malloc(4);
▲ Show 20 Lines • Show All 1,000 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/pr33549.ll

Show First 20 Lines • Show All 78 Lines • ▼ Show 20 Lines
attributes #0 = { norecurse nounwind "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="cortex-m7" "target-features"="+d16,+dsp,+fp-armv8,+hwdiv,+strict-align,+thumb-mode" "unsafe-fp-math"="false" "use-soft-float"="false" } attributes #0 = { norecurse nounwind "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="cortex-m7" "target-features"="+d16,+dsp,+fp-armv8,+hwdiv,+strict-align,+thumb-mode" "unsafe-fp-math"="false" "use-soft-float"="false" }
!llvm.module.flags = !{!0, !1} !llvm.module.flags = !{!0, !1}
!llvm.ident = !{!2} !llvm.ident = !{!2}
!0 = !{i32 1, !"wchar_size", i32 4} !0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 1, !"min_enum_size", i32 4} !1 = !{i32 1, !"min_enum_size", i32 4}
!2 = !{!"clang version 5.0.0 (http://llvm.org/git/clang.git 100ecde90ef26ee81763214d5fb335415ffc2b53) (http://llvm.org/git/llvm.git f2fe26d60eb81a699f2d565e8baabcaf32f9c5ea)"} !2 = !{!"clang version 5.0.0 (https://llvm.org/git/clang.git 100ecde90ef26ee81763214d5fb335415ffc2b53) (https://llvm.org/git/llvm.git f2fe26d60eb81a699f2d565e8baabcaf32f9c5ea)"}
!3 = !{!4, !4, i64 0} !3 = !{!4, !4, i64 0}
!4 = !{!"int", !5, i64 0} !4 = !{!"int", !5, i64 0}
!5 = !{!"omnipotent char", !6, i64 0} !5 = !{!"omnipotent char", !6, i64 0}
!6 = !{!"Simple C/C++ TBAA"} !6 = !{!"Simple C/C++ TBAA"}

llvm/test/Transforms/InstCombine/double-float-shrink-1.ll

; RUN: opt < %s -passes=instcombine -S -mtriple x86_64-unknown-linux-gnu | FileCheck %s --check-prefixes=CHECK,LINUX,ISC99 ; RUN: opt < %s -passes=instcombine -S -mtriple x86_64-unknown-linux-gnu | FileCheck %s --check-prefixes=CHECK,LINUX,ISC99
; RUN: opt < %s -passes=instcombine -S -mtriple x86_64-pc-win32 | FileCheck %s --check-prefixes=CHECK,ISC99 ; RUN: opt < %s -passes=instcombine -S -mtriple x86_64-pc-win32 | FileCheck %s --check-prefixes=CHECK,ISC99
; RUN: opt < %s -passes=instcombine -S -mtriple x86_64-pc-windows-msvc16 | FileCheck %s --check-prefixes=CHECK,MS64,ISC89 ; RUN: opt < %s -passes=instcombine -S -mtriple x86_64-pc-windows-msvc16 | FileCheck %s --check-prefixes=CHECK,MS64,ISC89
; RUN: opt < %s -passes=instcombine -S -mtriple i386-pc-windows-msvc | FileCheck %s --check-prefixes=CHECK,ISC99 ; RUN: opt < %s -passes=instcombine -S -mtriple i386-pc-windows-msvc | FileCheck %s --check-prefixes=CHECK,ISC99
; RUN: opt < %s -passes=instcombine -S -mtriple i686-pc-windows-msvc17 | FileCheck %s --check-prefixes=CHECK,MS32,ISC89 ; RUN: opt < %s -passes=instcombine -S -mtriple i686-pc-windows-msvc17 | FileCheck %s --check-prefixes=CHECK,MS32,ISC89
; Check for and against shrinkage when using the ; Check for and against shrinkage when using the
; unsafe-fp-math function attribute on a math lib ; unsafe-fp-math function attribute on a math lib
; function. This optimization may be overridden by ; function. This optimization may be overridden by
; the -enable-double-float-shrink option. ; the -enable-double-float-shrink option.
; PR17850: http://llvm.org/bugs/show_bug.cgi?id=17850 ; PR17850: https://llvm.org/bugs/show_bug.cgi?id=17850
define float @acos_test1(float %f) { define float @acos_test1(float %f) {
; CHECK-LABEL: @acos_test1( ; CHECK-LABEL: @acos_test1(
; LINUX-NEXT: [[ACOSF:%.*]] = call fast float @acosf(float [[F:%.*]]) ; LINUX-NEXT: [[ACOSF:%.*]] = call fast float @acosf(float [[F:%.*]])
; LINUX-NEXT: ret float [[ACOSF]] ; LINUX-NEXT: ret float [[ACOSF]]
; MS32: [[ACOSF:%.*]] = call fast double @acos(double [[F:%.*]]) ; MS32: [[ACOSF:%.*]] = call fast double @acos(double [[F:%.*]])
; MS64-NEXT: [[ACOSF:%.*]] = call fast float @acosf(float [[F:%.*]]) ; MS64-NEXT: [[ACOSF:%.*]] = call fast float @acosf(float [[F:%.*]])
; ;
▲ Show 20 Lines • Show All 549 Lines • ▼ Show 20 Lines
declare double @exp(double) declare double @exp(double)
declare double @cbrt(double) declare double @cbrt(double)
declare double @atanh(double) declare double @atanh(double)
declare double @atan(double) declare double @atan(double)
declare double @acos(double) declare double @acos(double)
declare double @acosh(double) declare double @acosh(double)
declare double @asin(double) declare double @asin(double)
declare double @asinh(double) declare double @asinh(double)

llvm/test/Transforms/InstCombine/inline-intrinsic-assert.ll

; RUN: opt < %s -inline -instcombine -S | FileCheck %s ; RUN: opt < %s -inline -instcombine -S | FileCheck %s
; PR22857: http://llvm.org/bugs/show_bug.cgi?id=22857 ; PR22857: https://llvm.org/bugs/show_bug.cgi?id=22857
; The inliner should not add an edge to an intrinsic and ; The inliner should not add an edge to an intrinsic and
; then assert that it did not add an edge to an intrinsic! ; then assert that it did not add an edge to an intrinsic!
define float @foo(float %f1) { define float @foo(float %f1) {
%call = call float @bar(float %f1) %call = call float @bar(float %f1)
ret float %call ret float %call
; CHECK-LABEL: @foo( ; CHECK-LABEL: @foo(
; CHECK-NEXT: call fast float @llvm.fabs.f32 ; CHECK-NEXT: call fast float @llvm.fabs.f32
; CHECK-NEXT: ret float ; CHECK-NEXT: ret float
} }
define float @bar(float %f1) { define float @bar(float %f1) {
%call = call float @sqr(float %f1) %call = call float @sqr(float %f1)
%call1 = call fast float @sqrtf(float %call) %call1 = call fast float @sqrtf(float %call)
ret float %call1 ret float %call1
} }
define float @sqr(float %f) { define float @sqr(float %f) {
%mul = fmul fast float %f, %f %mul = fmul fast float %f, %f
ret float %mul ret float %mul
} }
declare float @sqrtf(float) declare float @sqrtf(float)

llvm/test/Transforms/InstCombine/no_cgscc_assert.ll

; RUN: opt < %s -inline -instcombine -S | FileCheck %s ; RUN: opt < %s -inline -instcombine -S | FileCheck %s
; PR21403: http://llvm.org/bugs/show_bug.cgi?id=21403 ; PR21403: https://llvm.org/bugs/show_bug.cgi?id=21403
; When the call to sqrtf is replaced by an intrinsic call to fabs, ; When the call to sqrtf is replaced by an intrinsic call to fabs,
; it should not cause a problem in CGSCC. ; it should not cause a problem in CGSCC.
define float @bar(float %f) #0 { define float @bar(float %f) #0 {
%mul = fmul fast float %f, %f %mul = fmul fast float %f, %f
%call1 = call fast float @sqrtf(float %mul) %call1 = call fast float @sqrtf(float %mul)
ret float %call1 ret float %call1
; CHECK-LABEL: @bar( ; CHECK-LABEL: @bar(
; CHECK-NEXT: call fast float @llvm.fabs.f32 ; CHECK-NEXT: call fast float @llvm.fabs.f32
; CHECK-NEXT: ret float ; CHECK-NEXT: ret float
} }
declare float @sqrtf(float) declare float @sqrtf(float)

llvm/test/Transforms/InstCombine/vec_shuffle-inseltpoison.ll

Show First 20 Lines • Show All 753 Lines • ▼ Show 20 Lines
; ;
%shuffle.i = shufflevector <4 x i32> zeroinitializer, <4 x i32> %in0, <4 x i32> <i32 0, i32 4, i32 2, i32 6> %shuffle.i = shufflevector <4 x i32> zeroinitializer, <4 x i32> %in0, <4 x i32> <i32 0, i32 4, i32 2, i32 6>
%neg.i = xor <4 x i32> %shuffle.i, <i32 -1, i32 -1, i32 -1, i32 -1> %neg.i = xor <4 x i32> %shuffle.i, <i32 -1, i32 -1, i32 -1, i32 -1>
%and.i = and <4 x i32> %in0, %neg.i %and.i = and <4 x i32> %in0, %neg.i
%rv = extractelement <4 x i32> %and.i, i32 0 %rv = extractelement <4 x i32> %and.i, i32 0
ret i32 %rv ret i32 %rv
} }
; In PR20059 ( http://llvm.org/pr20059 ), shufflevector operations are reordered/removed ; In PR20059 ( https://llvm.org/pr20059 ), shufflevector operations are reordered/removed
; for an srem operation. This is not a valid optimization because it may cause a trap ; for an srem operation. This is not a valid optimization because it may cause a trap
; on div-by-zero. ; on div-by-zero.
define <4 x i32> @pr20059(<4 x i32> %p1, <4 x i32> %p2) { define <4 x i32> @pr20059(<4 x i32> %p1, <4 x i32> %p2) {
; CHECK-LABEL: @pr20059( ; CHECK-LABEL: @pr20059(
; CHECK-NEXT: [[SPLAT1:%.*]] = shufflevector <4 x i32> [[P1:%.*]], <4 x i32> poison, <4 x i32> zeroinitializer ; CHECK-NEXT: [[SPLAT1:%.*]] = shufflevector <4 x i32> [[P1:%.*]], <4 x i32> poison, <4 x i32> zeroinitializer
; CHECK-NEXT: [[SPLAT2:%.*]] = shufflevector <4 x i32> [[P2:%.*]], <4 x i32> poison, <4 x i32> zeroinitializer ; CHECK-NEXT: [[SPLAT2:%.*]] = shufflevector <4 x i32> [[P2:%.*]], <4 x i32> poison, <4 x i32> zeroinitializer
; CHECK-NEXT: [[RETVAL:%.*]] = srem <4 x i32> [[SPLAT1]], [[SPLAT2]] ; CHECK-NEXT: [[RETVAL:%.*]] = srem <4 x i32> [[SPLAT1]], [[SPLAT2]]
▲ Show 20 Lines • Show All 1,011 Lines • ▼ Show 20 Lines
; CHECK-NEXT: [[S:%.*]] = shufflevector <4 x i32> [[X:%.*]], <4 x i32> poison, <4 x i32> <i32 undef, i32 0, i32 1, i32 1> ; CHECK-NEXT: [[S:%.*]] = shufflevector <4 x i32> [[X:%.*]], <4 x i32> poison, <4 x i32> <i32 undef, i32 0, i32 1, i32 1>
; CHECK-NEXT: [[A:%.*]] = and <4 x i32> [[S]], bitcast (<2 x i64> <i64 ptrtoint (<4 x i32> (<4 x i32>)* @PR46872 to i64), i64 ptrtoint (<4 x i32> (<4 x i32>)* @PR46872 to i64)> to <4 x i32>) ; CHECK-NEXT: [[A:%.*]] = and <4 x i32> [[S]], bitcast (<2 x i64> <i64 ptrtoint (<4 x i32> (<4 x i32>)* @PR46872 to i64), i64 ptrtoint (<4 x i32> (<4 x i32>)* @PR46872 to i64)> to <4 x i32>)
; CHECK-NEXT: ret <4 x i32> [[A]] ; CHECK-NEXT: ret <4 x i32> [[A]]
; ;
%s = shufflevector <4 x i32> %x, <4 x i32> poison, <4 x i32> <i32 undef, i32 0, i32 1, i32 1> %s = shufflevector <4 x i32> %x, <4 x i32> poison, <4 x i32> <i32 undef, i32 0, i32 1, i32 1>
%a = and <4 x i32> %s, bitcast (<2 x i64> <i64 ptrtoint (<4 x i32> (<4 x i32>)* @PR46872 to i64), i64 ptrtoint (<4 x i32> (<4 x i32>)* @PR46872 to i64)> to <4 x i32>) %a = and <4 x i32> %s, bitcast (<2 x i64> <i64 ptrtoint (<4 x i32> (<4 x i32>)* @PR46872 to i64), i64 ptrtoint (<4 x i32> (<4 x i32>)* @PR46872 to i64)> to <4 x i32>)
ret <4 x i32> %a ret <4 x i32> %a
} }

llvm/test/Transforms/InstCombine/vec_shuffle.ll

Show First 20 Lines • Show All 754 Lines • ▼ Show 20 Lines
; ;
%shuffle.i = shufflevector <4 x i32> zeroinitializer, <4 x i32> %in0, <4 x i32> <i32 0, i32 4, i32 2, i32 6> %shuffle.i = shufflevector <4 x i32> zeroinitializer, <4 x i32> %in0, <4 x i32> <i32 0, i32 4, i32 2, i32 6>
%neg.i = xor <4 x i32> %shuffle.i, <i32 -1, i32 -1, i32 -1, i32 -1> %neg.i = xor <4 x i32> %shuffle.i, <i32 -1, i32 -1, i32 -1, i32 -1>
%and.i = and <4 x i32> %in0, %neg.i %and.i = and <4 x i32> %in0, %neg.i
%rv = extractelement <4 x i32> %and.i, i32 0 %rv = extractelement <4 x i32> %and.i, i32 0
ret i32 %rv ret i32 %rv
} }
; In PR20059 ( http://llvm.org/pr20059 ), shufflevector operations are reordered/removed ; In PR20059 ( https://llvm.org/pr20059 ), shufflevector operations are reordered/removed
; for an srem operation. This is not a valid optimization because it may cause a trap ; for an srem operation. This is not a valid optimization because it may cause a trap
; on div-by-zero. ; on div-by-zero.
define <4 x i32> @pr20059(<4 x i32> %p1, <4 x i32> %p2) { define <4 x i32> @pr20059(<4 x i32> %p1, <4 x i32> %p2) {
; CHECK-LABEL: @pr20059( ; CHECK-LABEL: @pr20059(
; CHECK-NEXT: [[SPLAT1:%.*]] = shufflevector <4 x i32> [[P1:%.*]], <4 x i32> undef, <4 x i32> zeroinitializer ; CHECK-NEXT: [[SPLAT1:%.*]] = shufflevector <4 x i32> [[P1:%.*]], <4 x i32> undef, <4 x i32> zeroinitializer
; CHECK-NEXT: [[SPLAT2:%.*]] = shufflevector <4 x i32> [[P2:%.*]], <4 x i32> undef, <4 x i32> zeroinitializer ; CHECK-NEXT: [[SPLAT2:%.*]] = shufflevector <4 x i32> [[P2:%.*]], <4 x i32> undef, <4 x i32> zeroinitializer
; CHECK-NEXT: [[RETVAL:%.*]] = srem <4 x i32> [[SPLAT1]], [[SPLAT2]] ; CHECK-NEXT: [[RETVAL:%.*]] = srem <4 x i32> [[SPLAT1]], [[SPLAT2]]
▲ Show 20 Lines • Show All 1,427 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/fast-math-strictfp.ll

Show First 20 Lines • Show All 498 Lines • ▼ Show 20 Lines
; CHECK-NEXT: [[DIV:%.*]] = call nnan <2 x float> @llvm.experimental.constrained.fdiv.v2f32(<2 x float> [[F]], <2 x float> [[NEG]], metadata !"round.tonearest", metadata !"fpexcept.ignore") #[[ATTR0]] ; CHECK-NEXT: [[DIV:%.*]] = call nnan <2 x float> @llvm.experimental.constrained.fdiv.v2f32(<2 x float> [[F]], <2 x float> [[NEG]], metadata !"round.tonearest", metadata !"fpexcept.ignore") #[[ATTR0]]
; CHECK-NEXT: ret <2 x float> [[DIV]] ; CHECK-NEXT: ret <2 x float> [[DIV]]
; ;
%neg = call <2 x float> @llvm.experimental.constrained.fsub.v2f32(<2 x float> <float 0.000000e+00, float undef>, <2 x float> %f, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0 %neg = call <2 x float> @llvm.experimental.constrained.fsub.v2f32(<2 x float> <float 0.000000e+00, float undef>, <2 x float> %f, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
%div = call nnan <2 x float> @llvm.experimental.constrained.fdiv.v2f32(<2 x float> %f, <2 x float> %neg, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0 %div = call nnan <2 x float> @llvm.experimental.constrained.fdiv.v2f32(<2 x float> %f, <2 x float> %neg, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
ret <2 x float> %div ret <2 x float> %div
} }
; PR21126: http://llvm.org/bugs/show_bug.cgi?id=21126 ; PR21126: https://llvm.org/bugs/show_bug.cgi?id=21126
; With loose math, sqrt(X) * sqrt(X) is just X. ; With loose math, sqrt(X) * sqrt(X) is just X.
declare double @llvm.sqrt.f64(double) declare double @llvm.sqrt.f64(double)
define double @sqrt_squared(double %f) #0 { define double @sqrt_squared(double %f) #0 {
; CHECK-LABEL: @sqrt_squared( ; CHECK-LABEL: @sqrt_squared(
; CHECK-NEXT: [[SQRT:%.*]] = call double @llvm.experimental.constrained.sqrt.f64(double [[F:%.*]], metadata !"round.tonearest", metadata !"fpexcept.ignore") ; CHECK-NEXT: [[SQRT:%.*]] = call double @llvm.experimental.constrained.sqrt.f64(double [[F:%.*]], metadata !"round.tonearest", metadata !"fpexcept.ignore")
; CHECK-NEXT: [[MUL:%.*]] = call reassoc nnan nsz double @llvm.experimental.constrained.fmul.f64(double [[SQRT]], double [[SQRT]], metadata !"round.tonearest", metadata !"fpexcept.ignore") #[[ATTR0]] ; CHECK-NEXT: [[MUL:%.*]] = call reassoc nnan nsz double @llvm.experimental.constrained.fmul.f64(double [[SQRT]], double [[SQRT]], metadata !"round.tonearest", metadata !"fpexcept.ignore") #[[ATTR0]]
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Lines
declare double @llvm.experimental.constrained.fdiv.f64(double, double, metadata, metadata) #0 declare double @llvm.experimental.constrained.fdiv.f64(double, double, metadata, metadata) #0
declare <2 x float> @llvm.experimental.constrained.fdiv.v2f32(<2 x float>, <2 x float>, metadata, metadata) #0 declare <2 x float> @llvm.experimental.constrained.fdiv.v2f32(<2 x float>, <2 x float>, metadata, metadata) #0
declare <2 x double> @llvm.experimental.constrained.fdiv.v2f64(<2 x double>, <2 x double>, metadata, metadata) #0 declare <2 x double> @llvm.experimental.constrained.fdiv.v2f64(<2 x double>, <2 x double>, metadata, metadata) #0
declare double @llvm.experimental.constrained.frem.f64(double, double, metadata, metadata) #0 declare double @llvm.experimental.constrained.frem.f64(double, double, metadata, metadata) #0
declare <2 x double> @llvm.experimental.constrained.frem.v2f64(<2 x double>, <2 x double>, metadata, metadata) #0 declare <2 x double> @llvm.experimental.constrained.frem.v2f64(<2 x double>, <2 x double>, metadata, metadata) #0
attributes #0 = { strictfp } attributes #0 = { strictfp }

llvm/test/Transforms/InstSimplify/fast-math.ll

Show First 20 Lines • Show All 470 Lines • ▼ Show 20 Lines
; CHECK-LABEL: @fdiv_neg_vec_undef_elt( ; CHECK-LABEL: @fdiv_neg_vec_undef_elt(
; CHECK-NEXT: ret <2 x float> <float -1.000000e+00, float -1.000000e+00> ; CHECK-NEXT: ret <2 x float> <float -1.000000e+00, float -1.000000e+00>
; ;
%neg = fsub <2 x float> <float 0.0, float undef>, %f %neg = fsub <2 x float> <float 0.0, float undef>, %f
%div = fdiv nnan <2 x float> %f, %neg %div = fdiv nnan <2 x float> %f, %neg
ret <2 x float> %div ret <2 x float> %div
} }
; PR21126: http://llvm.org/bugs/show_bug.cgi?id=21126 ; PR21126: https://llvm.org/bugs/show_bug.cgi?id=21126
; With loose math, sqrt(X) * sqrt(X) is just X. ; With loose math, sqrt(X) * sqrt(X) is just X.
declare double @llvm.sqrt.f64(double) declare double @llvm.sqrt.f64(double)
define double @sqrt_squared(double %f) { define double @sqrt_squared(double %f) {
; CHECK-LABEL: @sqrt_squared( ; CHECK-LABEL: @sqrt_squared(
; CHECK-NEXT: ret double [[F:%.*]] ; CHECK-NEXT: ret double [[F:%.*]]
; ;
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

llvm/test/Transforms/LICM/pr40317.ll

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
attributes #0 = { "use-soft-float"="false" } attributes #0 = { "use-soft-float"="false" }
attributes #1 = { argmemonly nounwind } attributes #1 = { argmemonly nounwind }
attributes #2 = { norecurse nounwind readnone "use-soft-float"="false" } attributes #2 = { norecurse nounwind readnone "use-soft-float"="false" }
attributes #3 = { noreturn nounwind "use-soft-float"="false" } attributes #3 = { noreturn nounwind "use-soft-float"="false" }
!llvm.ident = !{!0} !llvm.ident = !{!0}
!0 = !{!"clang version 8.0.0 (http://llvm.org/git/clang.git e593a791f2cf19db84237b0b9d632e9966a00a39) (http://llvm.org/git/llvm.git fe0523d1bd7def3ef62cfb3dd37a8b1941aafa81)"} !0 = !{!"clang version 8.0.0 (https://llvm.org/git/clang.git e593a791f2cf19db84237b0b9d632e9966a00a39) (https://llvm.org/git/llvm.git fe0523d1bd7def3ef62cfb3dd37a8b1941aafa81)"}
!1 = !{!2, !8, i64 46} !1 = !{!2, !8, i64 46}
!2 = !{!"S5", !3, i64 0, !3, i64 31, !4, i64 62, !9, i64 64} !2 = !{!"S5", !3, i64 0, !3, i64 31, !4, i64 62, !9, i64 64}
!3 = !{!"S2", !4, i64 0, !5, i64 2, !7, i64 3, !7, i64 7, !7, i64 11, !8, i64 15, !8, i64 23} !3 = !{!"S2", !4, i64 0, !5, i64 2, !7, i64 3, !7, i64 7, !7, i64 11, !8, i64 15, !8, i64 23}
!4 = !{!"short", !5, i64 0} !4 = !{!"short", !5, i64 0}
!5 = !{!"omnipotent char", !6, i64 0} !5 = !{!"omnipotent char", !6, i64 0}
!6 = !{!"Simple C/C++ TBAA"} !6 = !{!"Simple C/C++ TBAA"}
!7 = !{!"int", !5, i64 0} !7 = !{!"int", !5, i64 0}
!8 = !{!"long", !5, i64 0} !8 = !{!"long", !5, i64 0}
!9 = !{!"S3", !7, i64 0, !4, i64 2, !4, i64 4} !9 = !{!"S3", !7, i64 0, !4, i64 2, !4, i64 4}
!10 = !{!2, !7, i64 42} !10 = !{!2, !7, i64 42}
!11 = !{!2, !7, i64 34} !11 = !{!2, !7, i64 34}
!12 = !{!8, !8, i64 0} !12 = !{!8, !8, i64 0}

llvm/test/Transforms/LoopRotate/vect.omp.persistence.ll

; RUN: opt < %s -loop-rotate -verify-memoryssa -S | FileCheck %s ; RUN: opt < %s -loop-rotate -verify-memoryssa -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
; Ensure that "llvm.loop.vectorize.enable" metadata was not lost after loop-rotate. ; Ensure that "llvm.loop.vectorize.enable" metadata was not lost after loop-rotate.
; In past LoopRotate was clearing that metadata. ; In past LoopRotate was clearing that metadata.
; ;
; See http://reviews.llvm.org/D3348 for details. ; See https://reviews.llvm.org/D3348 for details.
; CHECK-LABEL: @foo ; CHECK-LABEL: @foo
; CHECK: loop_cond: ; CHECK: loop_cond:
; CHECK-NOT: loop-inc ; CHECK-NOT: loop-inc
; CHECK: br i1 %cmp, label %return, label %loop_cond, !llvm.loop !0 ; CHECK: br i1 %cmp, label %return, label %loop_cond, !llvm.loop !0
; CHECK: !0 = distinct !{!0, !1} ; CHECK: !0 = distinct !{!0, !1}
; CHECK: !1 = !{!"llvm.loop.vectorize.enable", i1 true} ; CHECK: !1 = !{!"llvm.loop.vectorize.enable", i1 true}
define i32 @foo(i32 %a) { define i32 @foo(i32 %a) {
Show All 18 Lines

llvm/test/Transforms/LoopStrengthReduce/scev-insertpt-bug.ll

; RUN: opt < %s -loop-reduce -S ; RUN: opt < %s -loop-reduce -S
; Test that SCEV insertpoint's don't get corrupted and cause an ; Test that SCEV insertpoint's don't get corrupted and cause an
; invalid instruction to be inserted in a block other than its parent. ; invalid instruction to be inserted in a block other than its parent.
; See http://reviews.llvm.org/D20703 for context. ; See https://reviews.llvm.org/D20703 for context.
define void @test() { define void @test() {
entry: entry:
%bf.load = load i32, i32* null, align 4 %bf.load = load i32, i32* null, align 4
%bf.clear = lshr i32 %bf.load, 1 %bf.clear = lshr i32 %bf.load, 1
%div = and i32 %bf.clear, 134217727 %div = and i32 %bf.clear, 134217727
%sub = add nsw i32 %div, -1 %sub = add nsw i32 %div, -1
%0 = zext i32 %sub to i64 %0 = zext i32 %sub to i64
br label %while.cond br label %while.cond
Show All 34 Lines

llvm/test/Transforms/LoopVectorize/vect.omp.persistence.ll

; RUN: opt < %s -O2 -force-vector-interleave=2 -force-vector-width=4 -debug-only=loop-vectorize -S 2>&1 | FileCheck %s ; RUN: opt < %s -O2 -force-vector-interleave=2 -force-vector-width=4 -debug-only=loop-vectorize -S 2>&1 | FileCheck %s
; REQUIRES: asserts ; REQUIRES: asserts
; CHECK: LV: Checking a loop in 'foo' ; CHECK: LV: Checking a loop in 'foo'
; CHECK: LV: Loop hints: force=enabled ; CHECK: LV: Loop hints: force=enabled
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
; Ensure that "llvm.loop.vectorize.enable" metadata was not lost even ; Ensure that "llvm.loop.vectorize.enable" metadata was not lost even
; if loop was not rotated. ; if loop was not rotated.
; ;
; See http://reviews.llvm.org/D3348 for details. ; See https://reviews.llvm.org/D3348 for details.
; ;
; CHECK-LABEL: @foo ; CHECK-LABEL: @foo
; CHECK: !llvm.loop !0 ; CHECK: !llvm.loop !0
; CHECK: !0 = distinct !{!0, !1} ; CHECK: !0 = distinct !{!0, !1}
; CHECK: !1 = !{!"llvm.loop.vectorize.enable", i1 true} ; CHECK: !1 = !{!"llvm.loop.vectorize.enable", i1 true}
define i32 @foo(i32 %a) { define i32 @foo(i32 %a) {
entry: entry:
br label %loop_cond br label %loop_cond
Show All 16 Lines

llvm/test/Transforms/SeparateConstOffsetFromGEP/NVPTX/split-gep.ll

Show First 20 Lines • Show All 179 Lines • ▼ Show 20 Linesentry:
%1 = add nuw i32 %a, %0 %1 = add nuw i32 %a, %0
%i = zext i32 %1 to i64 %i = zext i32 %1 to i64
%p = getelementptr [32 x [32 x float]], [32 x [32 x float]]* @float_2d_array, i64 0, i64 0, i64 %i %p = getelementptr [32 x [32 x float]], [32 x [32 x float]]* @float_2d_array, i64 0, i64 0, i64 %i
ret float* %p ret float* %p
} }
; CHECK-LABEL: zext_expr( ; CHECK-LABEL: zext_expr(
; CHECK: getelementptr [32 x [32 x float]], [32 x [32 x float]]* @float_2d_array, i64 0, i64 0, i64 %i ; CHECK: getelementptr [32 x [32 x float]], [32 x [32 x float]]* @float_2d_array, i64 0, i64 0, i64 %i
; Per http://llvm.org/docs/LangRef.html#id181, the indices of a off-bound gep ; Per https://llvm.org/docs/LangRef.html#id181, the indices of a off-bound gep
; should be considered sign-extended to the pointer size. Therefore, ; should be considered sign-extended to the pointer size. Therefore,
; gep base, (add i32 a, b) != gep (gep base, i32 a), i32 b ; gep base, (add i32 a, b) != gep (gep base, i32 a), i32 b
; because ; because
; sext(a + b) != sext(a) + sext(b) ; sext(a + b) != sext(a) + sext(b)
; ;
; This test verifies we do not illegitimately extract the 8 from ; This test verifies we do not illegitimately extract the 8 from
; gep base, (i32 a + 8) ; gep base, (i32 a + 8)
define float* @i32_add(i32 %a) { define float* @i32_add(i32 %a) {
▲ Show 20 Lines • Show All 104 Lines • Show Last 20 Lines

llvm/test/Transforms/SimplifyCFG/PR17073.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -simplifycfg -simplifycfg-require-and-preserve-domtree=1 -S | FileCheck %s ; RUN: opt < %s -simplifycfg -simplifycfg-require-and-preserve-domtree=1 -S | FileCheck %s
; In PR17073 ( http://llvm.org/pr17073 ), we illegally hoisted an operation that can trap. ; In PR17073 ( https://llvm.org/pr17073 ), we illegally hoisted an operation that can trap.
; The first test confirms that we don't do that when the trapping op is reached by the current BB (block1). ; The first test confirms that we don't do that when the trapping op is reached by the current BB (block1).
; The second test confirms that we don't do that when the trapping op is reached by the previous BB (entry). ; The second test confirms that we don't do that when the trapping op is reached by the previous BB (entry).
; The third test confirms that we can still do this optimization for an operation (add) that doesn't trap. ; The third test confirms that we can still do this optimization for an operation (add) that doesn't trap.
; The tests must be complicated enough to prevent previous SimplifyCFG actions from optimizing away ; The tests must be complicated enough to prevent previous SimplifyCFG actions from optimizing away
; the instructions that we're checking for. ; the instructions that we're checking for.
target datalayout = "e-m:o-p:32:32-f64:32:64-f80:128-n8:16:32-S128" target datalayout = "e-m:o-p:32:32-f64:32:64-f80:128-n8:16:32-S128"
target triple = "i386-apple-macosx10.9.0" target triple = "i386-apple-macosx10.9.0"
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

llvm/tools/llvm-cov/SourceCoverageViewHTML.cpp

Show First 20 Lines • Show All 415 Lines • ▼ Show 20 LinesError CoveragePrinterHTML::createIndexFile(
if (Opts.hasProjectTitle()) if (Opts.hasProjectTitle())
OSRef << tag(ProjectTitleTag, escape(Opts.ProjectTitle, Opts)); OSRef << tag(ProjectTitleTag, escape(Opts.ProjectTitle, Opts));
OSRef << tag(ReportTitleTag, "Coverage Report"); OSRef << tag(ReportTitleTag, "Coverage Report");
if (Opts.hasCreatedTime()) if (Opts.hasCreatedTime())
OSRef << tag(CreatedTimeTag, escape(Opts.CreatedTimeStr, Opts)); OSRef << tag(CreatedTimeTag, escape(Opts.CreatedTimeStr, Opts));
// Emit a link to some documentation. // Emit a link to some documentation.
OSRef << tag("p", "Click " + OSRef << tag("p", "Click " +
a("http://clang.llvm.org/docs/" a("https://clang.llvm.org/docs/"
"SourceBasedCodeCoverage.html#interpreting-reports", "SourceBasedCodeCoverage.html#interpreting-reports",
"here") + "here") +
" for information about interpreting this report."); " for information about interpreting this report.");
// Emit a table containing links to reports for each file in the covmapping. // Emit a table containing links to reports for each file in the covmapping.
// Exclude files which don't contain any regions. // Exclude files which don't contain any regions.
OSRef << BeginCenteredDiv << BeginTable; OSRef << BeginCenteredDiv << BeginTable;
emitColumnLabelsForIndex(OSRef, Opts); emitColumnLabelsForIndex(OSRef, Opts);
▲ Show 20 Lines • Show All 336 Lines • Show Last 20 Lines

llvm/unittests/ADT/APFloatTest.cpp

Show First 20 Lines • Show All 523 Lines • ▼ Show 20 LinesTEST(APFloatTest, FMA) {
{ {
APFloat f1(APFloat::IEEEdouble(), "-0x1p-1074"); APFloat f1(APFloat::IEEEdouble(), "-0x1p-1074");
APFloat f2(APFloat::IEEEdouble(), "+0x1p-1074"); APFloat f2(APFloat::IEEEdouble(), "+0x1p-1074");
APFloat f3(0.0); APFloat f3(0.0);
f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven); f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
EXPECT_TRUE(f1.isNegative() && f1.isZero()); EXPECT_TRUE(f1.isNegative() && f1.isZero());
} }
// Test x87 extended precision case from http://llvm.org/PR20728. // Test x87 extended precision case from https://llvm.org/PR20728.
{ {
APFloat M1(APFloat::x87DoubleExtended(), 1); APFloat M1(APFloat::x87DoubleExtended(), 1);
APFloat M2(APFloat::x87DoubleExtended(), 1); APFloat M2(APFloat::x87DoubleExtended(), 1);
APFloat A(APFloat::x87DoubleExtended(), 3); APFloat A(APFloat::x87DoubleExtended(), 3);
bool losesInfo = false; bool losesInfo = false;
M1.fusedMultiplyAdd(M1, A, APFloat::rmNearestTiesToEven); M1.fusedMultiplyAdd(M1, A, APFloat::rmNearestTiesToEven);
M1.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo); M1.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo);
▲ Show 20 Lines • Show All 4,471 Lines • Show Last 20 Lines

llvm/unittests/IR/ConstantRangeTest.cpp

Show First 20 Lines • Show All 1,078 Lines • ▼ Show 20 LinesTEST_F(ConstantRangeTest, Multiply) {
ConstantRange Zero(APInt(16, 0)); ConstantRange Zero(APInt(16, 0));
EXPECT_EQ(Zero.multiply(Full), Zero); EXPECT_EQ(Zero.multiply(Full), Zero);
EXPECT_EQ(Zero.multiply(Some), Zero); EXPECT_EQ(Zero.multiply(Some), Zero);
EXPECT_EQ(Zero.multiply(Wrap), Zero); EXPECT_EQ(Zero.multiply(Wrap), Zero);
EXPECT_EQ(Full.multiply(Zero), Zero); EXPECT_EQ(Full.multiply(Zero), Zero);
EXPECT_EQ(Some.multiply(Zero), Zero); EXPECT_EQ(Some.multiply(Zero), Zero);
EXPECT_EQ(Wrap.multiply(Zero), Zero); EXPECT_EQ(Wrap.multiply(Zero), Zero);
// http://llvm.org/PR4545 // https://llvm.org/PR4545
EXPECT_EQ(ConstantRange(APInt(4, 1), APInt(4, 6)).multiply( EXPECT_EQ(ConstantRange(APInt(4, 1), APInt(4, 6)).multiply(
ConstantRange(APInt(4, 6), APInt(4, 2))), ConstantRange(APInt(4, 6), APInt(4, 2))),
ConstantRange(4, /*isFullSet=*/true)); ConstantRange(4, /*isFullSet=*/true));
EXPECT_EQ(ConstantRange(APInt(8, 254), APInt(8, 0)).multiply( EXPECT_EQ(ConstantRange(APInt(8, 254), APInt(8, 0)).multiply(
ConstantRange(APInt(8, 252), APInt(8, 4))), ConstantRange(APInt(8, 252), APInt(8, 4))),
ConstantRange(APInt(8, 250), APInt(8, 9))); ConstantRange(APInt(8, 250), APInt(8, 9)));
EXPECT_EQ(ConstantRange(APInt(8, 254), APInt(8, 255)).multiply( EXPECT_EQ(ConstantRange(APInt(8, 254), APInt(8, 255)).multiply(
▲ Show 20 Lines • Show All 1,632 Lines • Show Last 20 Lines

llvm/utils/codegen-diff

Show First 20 Lines • Show All 124 Lines • ▼ Show 20 Lines
B<codegen-diff> was written by Brian Gaeke. B<codegen-diff> was written by Brian Gaeke.
=head1 SEE ALSO =head1 SEE ALSO
L<gdb(1)>, L<objdump(1)>, L<script(1)>. L<gdb(1)>, L<objdump(1)>, L<script(1)>.
You will need my B<gdb> patch: You will need my B<gdb> patch:
http://llvm.cs.uiuc.edu/~gaeke/gdb-disassembly-print-bytes.patch https://llvm.cs.uiuc.edu/~gaeke/gdb-disassembly-print-bytes.patch
=cut =cut

llvm/utils/crosstool/create-snapshots.sh

#!/bin/bash #!/bin/bash
# #
# Creates LLVM SVN snapshots: llvm-$REV.tar.bz2 and llvm-gcc-4.2-$REV.tar.bz2, # Creates LLVM SVN snapshots: llvm-$REV.tar.bz2 and llvm-gcc-4.2-$REV.tar.bz2,
# where $REV is an SVN revision of LLVM. This is used for creating stable # where $REV is an SVN revision of LLVM. This is used for creating stable
# tarballs which can be used to build known-to-work crosstools. # tarballs which can be used to build known-to-work crosstools.
# #
# Syntax: # Syntax:
# $0 [REV] -- grabs the revision $REV from SVN; if not specified, grabs the # $0 [REV] -- grabs the revision $REV from SVN; if not specified, grabs the
# latest SVN revision. # latest SVN revision.
set -o nounset set -o nounset
set -o errexit set -o errexit
readonly LLVM_PROJECT_SVN="http://llvm.org/svn/llvm-project" readonly LLVM_PROJECT_SVN="https://llvm.org/svn/llvm-project"
getLatestRevisionFromSVN() { getLatestRevisionFromSVN() {
svn info ${LLVM_PROJECT_SVN} | egrep ^Revision | sed 's/^Revision: //' svn info ${LLVM_PROJECT_SVN} | egrep ^Revision | sed 's/^Revision: //'
} }
readonly REV="${1:-$(getLatestRevisionFromSVN)}" readonly REV="${1:-$(getLatestRevisionFromSVN)}"
createTarballFromSVN() { createTarballFromSVN() {
Show All 10 LinescreateTarballFromSVN() {
echo "Cleaning up '${module}'" echo "Cleaning up '${module}'"
rm -rf ${module} ${log} rm -rf ${module} ${log}
} }
for module in "llvm" "llvm-gcc-4.2"; do for module in "llvm" "llvm-gcc-4.2"; do
createTarballFromSVN ${module} createTarballFromSVN ${module}
done done

llvm/utils/emacs/emacs.el

;; LLVM coding style guidelines in emacs ;; LLVM coding style guidelines in emacs
;; Maintainer: LLVM Team, http://llvm.org/ ;; Maintainer: LLVM Team, https://llvm.org/
(defun llvm-lineup-statement (langelem) (defun llvm-lineup-statement (langelem)
(let ((in-assign (c-lineup-assignments langelem))) (let ((in-assign (c-lineup-assignments langelem)))
(if (not in-assign) (if (not in-assign)
'++ '++
(aset in-assign 0 (aset in-assign 0
(+ (aref in-assign 0) (+ (aref in-assign 0)
(* 2 c-basic-offset))) (* 2 c-basic-offset)))
Show All 22 Lines

llvm/utils/emacs/llvm-mode.el

;;; llvm-mode.el --- Major mode for the LLVM assembler language. ;;; llvm-mode.el --- Major mode for the LLVM assembler language.
;; Maintainer: The LLVM team, http://llvm.org/ ;; Maintainer: The LLVM team, https://llvm.org/
;; Version: 1.0 ;; Version: 1.0
;;; Commentary: ;;; Commentary:
;; Major mode for editing LLVM IR files. ;; Major mode for editing LLVM IR files.
;;; Code: ;;; Code:
▲ Show 20 Lines • Show All 101 Lines • Show Last 20 Lines

llvm/utils/emacs/tablegen-mode.el

;;; tablegen-mode.el --- Major mode for TableGen description files (part of LLVM project) ;;; tablegen-mode.el --- Major mode for TableGen description files (part of LLVM project)
;; Maintainer: The LLVM team, http://llvm.org/ ;; Maintainer: The LLVM team, https://llvm.org/
;;; Commentary: ;;; Commentary:
;; A major mode for TableGen description files in LLVM. ;; A major mode for TableGen description files in LLVM.
(require 'comint) (require 'comint)
(require 'custom) (require 'custom)
(require 'ansi-color) (require 'ansi-color)
▲ Show 20 Lines • Show All 118 Lines • Show Last 20 Lines

llvm/utils/gn/build/BUILD.gn

Show All 12 Linesdeclare_args() {
# out/gn/bin/llvm-undname ... # out/gn/bin/llvm-undname ...
# to generate a HTML report for the binaries passed in the last line. # to generate a HTML report for the binaries passed in the last line.
llvm_build_instrumented_coverage = false llvm_build_instrumented_coverage = false
# If set, puts relative paths in debug info. # If set, puts relative paths in debug info.
# Makes the build output independent of the build directory, but makes # Makes the build output independent of the build directory, but makes
# most debuggers harder to use. See "Getting to local determinism" and # most debuggers harder to use. See "Getting to local determinism" and
# "Getting debuggers to work well with locally deterministic builds" in # "Getting debuggers to work well with locally deterministic builds" in
# http://blog.llvm.org/2019/11/deterministic-builds-with-clang-and-lld.html # https://blog.llvm.org/2019/11/deterministic-builds-with-clang-and-lld.html
# for more information. # for more information.
use_relative_paths_in_debug_info = false use_relative_paths_in_debug_info = false
# The version of host gcc. Ignored if is_clang is true. # The version of host gcc. Ignored if is_clang is true.
gcc_version = 9 gcc_version = 9
} }
assert(!llvm_build_instrumented_coverage || is_clang, assert(!llvm_build_instrumented_coverage || is_clang,
▲ Show 20 Lines • Show All 238 Lines • ▼ Show 20 Lines cflags += [
rebase_path("$root_build_dir/profiles/%4m.profraw"), rebase_path("$root_build_dir/profiles/%4m.profraw"),
] ]
if (current_os != "win") { if (current_os != "win") {
ldflags += [ "-fprofile-instr-generate" ] ldflags += [ "-fprofile-instr-generate" ]
} }
} }
# Deterministic build setup, see # Deterministic build setup, see
# http://blog.llvm.org/2019/11/deterministic-builds-with-clang-and-lld.html # https://blog.llvm.org/2019/11/deterministic-builds-with-clang-and-lld.html
if (current_os == "win") { if (current_os == "win") {
ldflags += [ "/pdbaltpath:%_PDB%" ] ldflags += [ "/pdbaltpath:%_PDB%" ]
} }
if (is_clang) { if (is_clang) {
cflags += [ cflags += [
"-no-canonical-prefixes", "-no-canonical-prefixes",
"-Werror=date-time", "-Werror=date-time",
] ]
▲ Show 20 Lines • Show All 204 Lines • Show Last 20 Lines

llvm/utils/gn/docs/deterministic.md

Show All 9 Lines
1. Make debug info use relative paths by setting 1. Make debug info use relative paths by setting
`use_relative_paths_in_debug_info = true` in your `args.gn` file. With this `use_relative_paths_in_debug_info = true` in your `args.gn` file. With this
set, current debuggers need minor configuration to keep working. See set, current debuggers need minor configuration to keep working. See
"Getting to local determinism" and "Getting debuggers to work well with "Getting to local determinism" and "Getting debuggers to work well with
locally deterministic builds" in the [deterministic builds][1] documentation locally deterministic builds" in the [deterministic builds][1] documentation
for details. for details.
1: http://blog.llvm.org/2019/11/deterministic-builds-with-clang-and-lld.html 1: https://blog.llvm.org/2019/11/deterministic-builds-with-clang-and-lld.html

llvm/utils/lint/cpp_lint.py

#!/usr/bin/env python #!/usr/bin/env python
# #
# Checks C++ files to make sure they conform to LLVM standards, as specified in # Checks C++ files to make sure they conform to LLVM standards, as specified in
# http://llvm.org/docs/CodingStandards.html . # https://llvm.org/docs/CodingStandards.html .
# #
# TODO: add unittests for the verifier functions: # TODO: add unittests for the verifier functions:
# http://docs.python.org/library/unittest.html . # http://docs.python.org/library/unittest.html .
from __future__ import print_function from __future__ import print_function
import common_lint import common_lint
import re import re
import sys import sys
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

llvm/utils/lit/README.txt

Show All 19 Lines utils/lit/lit.py \
--path /path/to/your/llvm/build/bin \ --path /path/to/your/llvm/build/bin \
utils/lit/tests utils/lit/tests
Note that lit's tests depend on 'not' and 'FileCheck', LLVM utilities. Note that lit's tests depend on 'not' and 'FileCheck', LLVM utilities.
You will need to have built LLVM tools in order to run lit's test suite You will need to have built LLVM tools in order to run lit's test suite
successfully. successfully.
You'll also want to confirm that lit continues to work when testing LLVM. You'll also want to confirm that lit continues to work when testing LLVM.
Follow the instructions in http://llvm.org/docs/TestingGuide.html to run the Follow the instructions in https://llvm.org/docs/TestingGuide.html to run the
regression test suite: regression test suite:
make check-llvm make check-llvm
And be sure to run the llvm-lit wrapper script as well: And be sure to run the llvm-lit wrapper script as well:
/path/to/your/llvm/build/bin/llvm-lit utils/lit/tests /path/to/your/llvm/build/bin/llvm-lit utils/lit/tests
Finally, make sure lit works when installed via setuptools: Finally, make sure lit works when installed via setuptools:
python utils/lit/setup.py install python utils/lit/setup.py install
lit --path /path/to/your/llvm/build/bin utils/lit/tests lit --path /path/to/your/llvm/build/bin utils/lit/tests

llvm/utils/lit/lit/formats/shtest.py

from __future__ import absolute_import from __future__ import absolute_import
import lit.TestRunner import lit.TestRunner
import lit.util import lit.util
from .base import FileBasedTest from .base import FileBasedTest
class ShTest(FileBasedTest): class ShTest(FileBasedTest):
"""ShTest is a format with one file per test. """ShTest is a format with one file per test.
This is the primary format for regression tests as described in the LLVM This is the primary format for regression tests as described in the LLVM
testing guide: testing guide:
http://llvm.org/docs/TestingGuide.html https://llvm.org/docs/TestingGuide.html
The ShTest files contain some number of shell-like command pipelines, along The ShTest files contain some number of shell-like command pipelines, along
with assertions about what should be in the output. with assertions about what should be in the output.
""" """
def __init__(self, execute_external=False, extra_substitutions=[], def __init__(self, execute_external=False, extra_substitutions=[],
preamble_commands=[]): preamble_commands=[]):
self.execute_external = execute_external self.execute_external = execute_external
self.extra_substitutions = extra_substitutions self.extra_substitutions = extra_substitutions
self.preamble_commands = preamble_commands self.preamble_commands = preamble_commands
def execute(self, test, litConfig): def execute(self, test, litConfig):
return lit.TestRunner.executeShTest(test, litConfig, return lit.TestRunner.executeShTest(test, litConfig,
self.execute_external, self.execute_external,
self.extra_substitutions, self.extra_substitutions,
self.preamble_commands) self.preamble_commands)

llvm/utils/lit/setup.py

Show All 9 Lines
os.chdir(os.path.dirname(os.path.abspath(__file__))) os.chdir(os.path.dirname(os.path.abspath(__file__)))
setup( setup(
name = "lit", name = "lit",
version = lit.__version__, version = lit.__version__,
author = lit.__author__, author = lit.__author__,
author_email = lit.__email__, author_email = lit.__email__,
url = 'http://llvm.org', url = 'https://llvm.org',
license = 'Apache-2.0 with LLVM exception', license = 'Apache-2.0 with LLVM exception',
license_files = ['LICENSE.TXT'], license_files = ['LICENSE.TXT'],
description = "A Software Testing Tool", description = "A Software Testing Tool",
keywords = 'test C++ automatic discovery', keywords = 'test C++ automatic discovery',
long_description = """\ long_description = """\
*lit* *lit*
+++++ +++++
Show All 15 Lines
* Parallel test execution. * Parallel test execution.
* Support for multiple test formats and test suite designs. * Support for multiple test formats and test suite designs.
Documentation Documentation
============= =============
The official *lit* documentation is in the man page, available online at the LLVM The official *lit* documentation is in the man page, available online at the LLVM
Command Guide: http://llvm.org/cmds/lit.html. Command Guide: https://llvm.org/cmds/lit.html.
Source Source
====== ======
The *lit* source is available as part of LLVM, in the LLVM source repository: The *lit* source is available as part of LLVM, in the LLVM source repository:
https://github.com/llvm/llvm-project/tree/main/llvm/utils/lit https://github.com/llvm/llvm-project/tree/main/llvm/utils/lit
""", """,
Show All 20 Lines

llvm/utils/vim/ftplugin/llvm.vim

" Vim filetype plugin file " Vim filetype plugin file
" Language: LLVM Assembly " Language: LLVM Assembly
" Maintainer: The LLVM team, http://llvm.org/ " Maintainer: The LLVM team, https://llvm.org/
if exists("b:did_ftplugin") if exists("b:did_ftplugin")
finish finish
endif endif
let b:did_ftplugin = 1 let b:did_ftplugin = 1
setlocal softtabstop=2 shiftwidth=2 setlocal softtabstop=2 shiftwidth=2
setlocal expandtab setlocal expandtab
setlocal comments+=:; setlocal comments+=:;

llvm/utils/vim/ftplugin/mir.vim

" Vim filetype plugin file " Vim filetype plugin file
" Language: LLVM Machine IR " Language: LLVM Machine IR
" Maintainer: The LLVM team, http://llvm.org/ " Maintainer: The LLVM team, https://llvm.org/
if exists("b:did_ftplugin") if exists("b:did_ftplugin")
finish finish
endif endif
let b:did_ftplugin = 1 let b:did_ftplugin = 1
setlocal softtabstop=2 shiftwidth=2 setlocal softtabstop=2 shiftwidth=2
setlocal expandtab setlocal expandtab
setlocal comments+=:; setlocal comments+=:;

llvm/utils/vim/ftplugin/tablegen.vim

" Vim filetype plugin file " Vim filetype plugin file
" Language: LLVM TableGen " Language: LLVM TableGen
" Maintainer: The LLVM team, http://llvm.org/ " Maintainer: The LLVM team, https://llvm.org/
if exists("b:did_ftplugin") if exists("b:did_ftplugin")
finish finish
endif endif
let b:did_ftplugin = 1 let b:did_ftplugin = 1
setlocal matchpairs+=<:> setlocal matchpairs+=<:>
setlocal softtabstop=2 shiftwidth=2 setlocal softtabstop=2 shiftwidth=2
setlocal expandtab setlocal expandtab

llvm/utils/vim/indent/llvm.vim

" Vim indent file " Vim indent file
" Language: llvm " Language: llvm
" Maintainer: The LLVM team, http://llvm.org/ " Maintainer: The LLVM team, https://llvm.org/
" What this indent plugin currently does: " What this indent plugin currently does:
" - If no other rule matches copy indent from previous non-empty, " - If no other rule matches copy indent from previous non-empty,
" non-commented line " non-commented line
" - On '}' align the same as the line containing the matching '{' " - On '}' align the same as the line containing the matching '{'
" - If previous line ends with ':' increase indentation " - If previous line ends with ':' increase indentation
" - If the current line ends with ':' indent at the same level as the " - If the current line ends with ':' indent at the same level as the
" enclosing '{'/'}' block " enclosing '{'/'}' block
" Stuff that would be nice to add: " Stuff that would be nice to add:
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

llvm/utils/vim/syntax/llvm.vim

" Vim syntax file " Vim syntax file
" Language: llvm " Language: llvm
" Maintainer: The LLVM team, http://llvm.org/ " Maintainer: The LLVM team, https://llvm.org/
" Version: $Revision$ " Version: $Revision$
if version < 600 if version < 600
syntax clear syntax clear
elseif exists("b:current_syntax") elseif exists("b:current_syntax")
finish finish
endif endif
▲ Show 20 Lines • Show All 260 Lines • Show Last 20 Lines

llvm/utils/vim/syntax/machine-ir.vim

" Vim syntax file " Vim syntax file
" Language: mir " Language: mir
" Maintainer: The LLVM team, http://llvm.org/ " Maintainer: The LLVM team, https://llvm.org/
" Version: $Revision$ " Version: $Revision$
syn case match syn case match
" FIXME: MIR doesn't actually match LLVM IR. Stop including it all as a " FIXME: MIR doesn't actually match LLVM IR. Stop including it all as a
" fallback once enough is implemented. " fallback once enough is implemented.
" See the MIR LangRef: https://llvm.org/docs/MIRLangRef.html " See the MIR LangRef: https://llvm.org/docs/MIRLangRef.html
unlet b:current_syntax " Unlet so that the LLVM syntax will load unlet b:current_syntax " Unlet so that the LLVM syntax will load
Show All 27 Lines

llvm/utils/vim/syntax/mir.vim

" Vim syntax file " Vim syntax file
" Language: mir " Language: mir
" Maintainer: The LLVM team, http://llvm.org/ " Maintainer: The LLVM team, https://llvm.org/
" Version: $Revision$ " Version: $Revision$
if version < 600 if version < 600
syntax clear syntax clear
elseif exists("b:current_syntax") elseif exists("b:current_syntax")
finish finish
endif endif
Show All 37 Lines

llvm/utils/vim/syntax/tablegen.vim

" Vim syntax file " Vim syntax file
" Language: TableGen " Language: TableGen
" Maintainer: The LLVM team, http://llvm.org/ " Maintainer: The LLVM team, https://llvm.org/
" Version: $Revision$ " Version: $Revision$
if version < 600 if version < 600
syntax clear syntax clear
elseif exists("b:current_syntax") elseif exists("b:current_syntax")
finish finish
endif endif
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

llvm/utils/vim/vimrc

" LLVM coding guidelines conformance for VIM " LLVM coding guidelines conformance for VIM
" $Revision$ " $Revision$
" "
" Maintainer: The LLVM Team, http://llvm.org " Maintainer: The LLVM Team, https://llvm.org
" WARNING: Read before you source in all these commands and macros! Some " WARNING: Read before you source in all these commands and macros! Some
" of them may change VIM behavior that you depend on. " of them may change VIM behavior that you depend on.
" "
" You can run VIM with these settings without changing your current setup with: " You can run VIM with these settings without changing your current setup with:
" $ vim -u /path/to/llvm/utils/vim/vimrc " $ vim -u /path/to/llvm/utils/vim/vimrc
" It's VIM, not VI " It's VIM, not VI
set nocompatible set nocompatible
▲ Show 20 Lines • Show All 216 Lines • Show Last 20 Lines

mlir/CMakeLists.txt

Show First 20 Lines • Show All 49 Lines • ▼ Show 20 Lineslist(INSERT CMAKE_MODULE_PATH 0
"${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules" "${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules"
"${LLVM_COMMON_CMAKE_UTILS}/Modules" "${LLVM_COMMON_CMAKE_UTILS}/Modules"
) )
include(AddMLIR) include(AddMLIR)
# -BSymbolic is incompatible with TypeID # -BSymbolic is incompatible with TypeID
if("${CMAKE_SHARED_LINKER_FLAGS}" MATCHES "-Bsymbolic[^-]") if("${CMAKE_SHARED_LINKER_FLAGS}" MATCHES "-Bsymbolic[^-]")
message(FATAL_ERROR " MLIR does not support `-Bsymbolic` (see http://llvm.org/pr51420 )," message(FATAL_ERROR " MLIR does not support `-Bsymbolic` (see https://llvm.org/pr51420 ),"
" try `-Bsymbolic-functions` instead.") " try `-Bsymbolic-functions` instead.")
endif() endif()
# Forbid implicit function declaration: this may lead to subtle bugs and we # Forbid implicit function declaration: this may lead to subtle bugs and we
# don't have a reason to support this. # don't have a reason to support this.
check_c_compiler_flag("-Werror=implicit-function-declaration" C_SUPPORTS_WERROR_IMPLICIT_FUNCTION_DECLARATION) check_c_compiler_flag("-Werror=implicit-function-declaration" C_SUPPORTS_WERROR_IMPLICIT_FUNCTION_DECLARATION)
append_if(C_SUPPORTS_WERROR_IMPLICIT_FUNCTION_DECLARATION "-Werror=implicit-function-declaration" CMAKE_C_FLAGS) append_if(C_SUPPORTS_WERROR_IMPLICIT_FUNCTION_DECLARATION "-Werror=implicit-function-declaration" CMAKE_C_FLAGS)
▲ Show 20 Lines • Show All 180 Lines • Show Last 20 Lines

mlir/docs/Dialects/Vector.md

Show First 20 Lines • Show All 245 Lines • ▼ Show 20 Lines
which conveys higher-D meaning. But it also is one of the most overloaded terms which conveys higher-D meaning. But it also is one of the most overloaded terms
in compilers and hardware. For now, we generally use the `n-D` `vector` name and in compilers and hardware. For now, we generally use the `n-D` `vector` name and
are open to better suggestions. are open to better suggestions.
## DeeperDive ## DeeperDive
This section describes the tradeoffs involved in lowering the MLIR n-D vector This section describes the tradeoffs involved in lowering the MLIR n-D vector
type and operations on it to LLVM-IR. Putting aside the type and operations on it to LLVM-IR. Putting aside the
[LLVM Matrix](http://lists.llvm.org/pipermail/llvm-dev/2018-October/126871.html) [LLVM Matrix](https://lists.llvm.org/pipermail/llvm-dev/2018-October/126871.html)
proposal for now, this assumes LLVM only has built-in support for 1-D vector. proposal for now, this assumes LLVM only has built-in support for 1-D vector.
The relationship with the LLVM Matrix proposal is discussed at the end of this The relationship with the LLVM Matrix proposal is discussed at the end of this
document. document.
MLIR does not currently support dynamic vector sizes (i.e. SVE style) so the MLIR does not currently support dynamic vector sizes (i.e. SVE style) so the
discussion is limited to static rank and static vector sizes (e.g. discussion is limited to static rank and static vector sizes (e.g.
`vector<4x8x16x32xf32>`). This section discusses operations on vectors in LLVM `vector<4x8x16x32xf32>`). This section discusses operations on vectors in LLVM
and MLIR. and MLIR.
▲ Show 20 Lines • Show All 239 Lines • Show Last 20 Lines

mlir/docs/LangRef.md

# MLIR Language Reference # MLIR Language Reference
MLIR (Multi-Level IR) is a compiler intermediate representation with MLIR (Multi-Level IR) is a compiler intermediate representation with
similarities to traditional three-address SSA representations (like similarities to traditional three-address SSA representations (like
[LLVM IR](http://llvm.org/docs/LangRef.html) or [LLVM IR](https://llvm.org/docs/LangRef.html) or
[SIL](https://github.com/apple/swift/blob/main/docs/SIL.rst)), but which [SIL](https://github.com/apple/swift/blob/main/docs/SIL.rst)), but which
introduces notions from polyhedral loop optimization as first-class concepts. introduces notions from polyhedral loop optimization as first-class concepts.
This hybrid design is optimized to represent, analyze, and transform high level This hybrid design is optimized to represent, analyze, and transform high level
dataflow graphs as well as target-specific code generated for high performance dataflow graphs as well as target-specific code generated for high performance
data parallel systems. Beyond its representational capabilities, its single data parallel systems. Beyond its representational capabilities, its single
continuous design provides a framework to lower from dataflow graphs to continuous design provides a framework to lower from dataflow graphs to
high-performance target-specific code. high-performance target-specific code.
▲ Show 20 Lines • Show All 838 Lines • Show Last 20 Lines

mlir/docs/PassManagement.md

Show First 20 Lines • Show All 551 Lines • ▼ Show 20 Lines
pipeline. For example, they help answer questions like "What happens if I run pipeline. For example, they help answer questions like "What happens if I run
CSE again here?". CSE again here?".
Statistics can be added to a pass by using the 'Pass::Statistic' class. This Statistics can be added to a pass by using the 'Pass::Statistic' class. This
class takes as a constructor arguments: the parent pass, a name, and a class takes as a constructor arguments: the parent pass, a name, and a
description. This class acts like an atomic unsigned integer, and may be description. This class acts like an atomic unsigned integer, and may be
incremented and updated accordingly. These statistics rely on the same incremented and updated accordingly. These statistics rely on the same
infrastructure as infrastructure as
[`llvm::Statistic`](http://llvm.org/docs/ProgrammersManual.html#the-statistic-class-stats-option) [`llvm::Statistic`](https://llvm.org/docs/ProgrammersManual.html#the-statistic-class-stats-option)
and thus have similar usage constraints. Collected statistics can be dumped by and thus have similar usage constraints. Collected statistics can be dumped by
the [pass manager](#pass-manager) programmatically via the [pass manager](#pass-manager) programmatically via
`PassManager::enableStatistics`; or via `-mlir-pass-statistics` and `PassManager::enableStatistics`; or via `-mlir-pass-statistics` and
`-mlir-pass-statistics-display` on the command line. `-mlir-pass-statistics-display` on the command line.
An example is shown below: An example is shown below:
```c++ ```c++
▲ Show 20 Lines • Show All 743 Lines • Show Last 20 Lines

mlir/docs/Rationale/MLIRForGraphAlgorithms.md

Show First 20 Lines • Show All 179 Lines • ▼ Show 20 Lines
commit to include a test case, and for these test cases to be stable and commit to include a test case, and for these test cases to be stable and
reliable over time, since they are testing exactly what they are supposed to. reliable over time, since they are testing exactly what they are supposed to.
End to end integration tests are still super useful for some things of course! End to end integration tests are still super useful for some things of course!
### Infrastructure for Warnings and Error Diagnostics and Location Tracking ### Infrastructure for Warnings and Error Diagnostics and Location Tracking
MLIR benefits from the lessons learned from building other compilers - including MLIR benefits from the lessons learned from building other compilers - including
Clang which Clang which
[[set the standard](http://blog.llvm.org/2010/04/amazing-feats-of-clang-error-recovery.html)](http://blog.llvm.org/2010/04/amazing-feats-of-clang-error-recovery.html) [[set the standard](https://blog.llvm.org/2010/04/amazing-feats-of-clang-error-recovery.html)](https://blog.llvm.org/2010/04/amazing-feats-of-clang-error-recovery.html)
for quality of implementation in C/C++ compiler diagnostics. Drawing from this for quality of implementation in C/C++ compiler diagnostics. Drawing from this
experience (and fixing mistakes in LLVM), MLIR requires that operations and experience (and fixing mistakes in LLVM), MLIR requires that operations and
functions carry abstract location information, that transformations propagate functions carry abstract location information, that transformations propagate
this information, and provides standardized mechanisms to emit errors and this information, and provides standardized mechanisms to emit errors and
warnings, as well as for clients to hook into them to capture and report them in warnings, as well as for clients to hook into them to capture and report them in
custom ways. custom ways.
Why is this important? In practice, many graph-to-graph translators can fail Why is this important? In practice, many graph-to-graph translators can fail
▲ Show 20 Lines • Show All 144 Lines • ▼ Show 20 Lines1. Like LLVM, MLIR is designed as a set of libraries that clients can link in
separate from the core IR abstractions, and dialect specific code (e.g. separate from the core IR abstractions, and dialect specific code (e.g.
TensorFlow, TF-Lite, XLA, etc) is all independently selectable by the build TensorFlow, TF-Lite, XLA, etc) is all independently selectable by the build
system. Clients that don't care about XLA don't link in that code, whether system. Clients that don't care about XLA don't link in that code, whether
they are a TF-Lite system or a client that is completely unrelated to they are a TF-Lite system or a client that is completely unrelated to
TensorFlow. TensorFlow.
1. MLIR's only third party dependency is on LLVM, but it doesn't depend on LLVM 1. MLIR's only third party dependency is on LLVM, but it doesn't depend on LLVM
IR or any other heavy dependency - it just depends on LLVM's support library IR or any other heavy dependency - it just depends on LLVM's support library
which provides efficient hash tables and other which provides efficient hash tables and other
[memory efficient data structures that the STL does not](http://llvm.org/docs/ProgrammersManual.html#picking-the-right-data-structure-for-a-task). [memory efficient data structures that the STL does not](https://llvm.org/docs/ProgrammersManual.html#picking-the-right-data-structure-for-a-task).
There have been discussions about splitting this set of libraries out to its There have been discussions about splitting this set of libraries out to its
own subproject in LLVM that the LLVM IR project depends on. This would be own subproject in LLVM that the LLVM IR project depends on. This would be
great for MLIR as well as other LLVM subprojects. great for MLIR as well as other LLVM subprojects.
1. TensorFlow and many other frameworks already use LLVM - if so, MLIR would 1. TensorFlow and many other frameworks already use LLVM - if so, MLIR would
not be pulling in an additional dependency at all. not be pulling in an additional dependency at all.
### How does MLIR represent {control flow, concurrency, …} semantics in TensorFlow? ### How does MLIR represent {control flow, concurrency, …} semantics in TensorFlow?
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

mlir/docs/Rationale/Rationale.md

# MLIR Rationale # MLIR Rationale
This document is intended to capture some of the alternatives considered and This document is intended to capture some of the alternatives considered and
open debates in the design of MLIR, along with the rationale for certain open debates in the design of MLIR, along with the rationale for certain
decisions we made. This is not intended to be a "finely groomed" document - we decisions we made. This is not intended to be a "finely groomed" document - we
prefer the ability to dump in interesting tidbits without worrying too much prefer the ability to dump in interesting tidbits without worrying too much
about their consistency or readability. about their consistency or readability.
[TOC] [TOC]
## Abstract ## Abstract
MLIR is a compiler intermediate representation with similarities to traditional MLIR is a compiler intermediate representation with similarities to traditional
three-address SSA representations (like three-address SSA representations (like
[LLVM IR](http://llvm.org/docs/LangRef.html) or [LLVM IR](https://llvm.org/docs/LangRef.html) or
[SIL](https://github.com/apple/swift/blob/main/docs/SIL.rst)), but which [SIL](https://github.com/apple/swift/blob/main/docs/SIL.rst)), but which
introduces notions from the polyhedral loop optimization works as first class introduces notions from the polyhedral loop optimization works as first class
concepts. This hybrid design is optimized to represent, analyze, and transform concepts. This hybrid design is optimized to represent, analyze, and transform
high level dataflow graphs as well as target-specific code generated for high high level dataflow graphs as well as target-specific code generated for high
performance data parallel systems. Beyond its representational capabilities, its performance data parallel systems. Beyond its representational capabilities, its
single continuous design provides a framework to lower from dataflow graphs to single continuous design provides a framework to lower from dataflow graphs to
high performance target specific code. high performance target specific code.
▲ Show 20 Lines • Show All 141 Lines • ▼ Show 20 Lines
An alternative design is to embed the reference to symbols directly in the An alternative design is to embed the reference to symbols directly in the
type - memref<8x%Nxf32>. We went for the current approach in MLIR because it type - memref<8x%Nxf32>. We went for the current approach in MLIR because it
simplifies the design --- types remain immutable when the values of symbols simplifies the design --- types remain immutable when the values of symbols
change. change.
### Block Arguments vs PHI nodes ### Block Arguments vs PHI nodes
MLIR Regions represent SSA using "[block arguments](../LangRef.md/#blocks)" MLIR Regions represent SSA using "[block arguments](../LangRef.md/#blocks)"
rather than [PHI instructions](http://llvm.org/docs/LangRef.html#i-phi) used in rather than [PHI instructions](https://llvm.org/docs/LangRef.html#i-phi) used in
LLVM. This choice is representationally identical (the same constructs can be LLVM. This choice is representationally identical (the same constructs can be
represented in either form) but block arguments have several advantages: represented in either form) but block arguments have several advantages:
1. LLVM PHI nodes always have to be kept at the top of a block, and 1. LLVM PHI nodes always have to be kept at the top of a block, and
transformations frequently have to manually skip over them. This is defined transformations frequently have to manually skip over them. This is defined
away with BB arguments. away with BB arguments.
1. LLVM has a separate function Argument node. This is defined away with BB 1. LLVM has a separate function Argument node. This is defined away with BB
arguments, because the arguments to the entry block serve this purpose. arguments, because the arguments to the entry block serve this purpose.
1. Blocks of PHI nodes in LLVM execute atomically, which is surprising and 1. Blocks of PHI nodes in LLVM execute atomically, which is surprising and
super confusing to compiler engineers and it is easy to introduce bugs with super confusing to compiler engineers and it is easy to introduce bugs with
this (very related to the this (very related to the
"[lost copy](http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.524.5461&rep=rep1&type=pdf)" "[lost copy](http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.524.5461&rep=rep1&type=pdf)"
problem in SSA lowering literature.) With the BB argument representation, problem in SSA lowering literature.) With the BB argument representation,
this confusion is defined away. this confusion is defined away.
1. The entry list of PHI nodes in LLVM are unordered, and some blocks have 1. The entry list of PHI nodes in LLVM are unordered, and some blocks have
thousands of predecessors (e.g. unwind blocks). This can cause long compile thousands of predecessors (e.g. unwind blocks). This can cause long compile
time problems because transformations have to linearly scan this list. This time problems because transformations have to linearly scan this list. This
is defined away with BB argument representation. is defined away with BB argument representation.
1. LLVM has no way to represent values that are available only in one successor 1. LLVM has no way to represent values that are available only in one successor
but not the other, e.g. its invoke instruction cannot produce the exception but not the other, e.g. its invoke instruction cannot produce the exception
value JUST on the exception edge. Instead, the value JUST on the exception edge. Instead, the
[landingpad instruction](http://llvm.org/docs/LangRef.html#landingpad-instruction) [landingpad instruction](https://llvm.org/docs/LangRef.html#landingpad-instruction)
is a hack used to represent this. MLIR doesn't make use of this capability, is a hack used to represent this. MLIR doesn't make use of this capability,
but SIL uses it extensively, e.g. in the but SIL uses it extensively, e.g. in the
[switch_enum instruction](https://github.com/apple/swift/blob/main/docs/SIL.rst#switch-enum). [switch_enum instruction](https://github.com/apple/swift/blob/main/docs/SIL.rst#switch-enum).
For more context, block arguments were previously used in the Swift For more context, block arguments were previously used in the Swift
[SIL Intermediate Representation](https://github.com/apple/swift/blob/main/docs/SIL.rst), [SIL Intermediate Representation](https://github.com/apple/swift/blob/main/docs/SIL.rst),
and described in and described in
[a talk on YouTube](https://www.youtube.com/watch?v=Ntj8ab-5cvE). The section of [a talk on YouTube](https://www.youtube.com/watch?v=Ntj8ab-5cvE). The section of
▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 Lines
type provides this as an option to help code reuse and consistency. type provides this as an option to help code reuse and consistency.
For the standard dialect, the choice is to have signless integer types. An For the standard dialect, the choice is to have signless integer types. An
integer value does not have an intrinsic sign, and it's up to the specific op integer value does not have an intrinsic sign, and it's up to the specific op
for interpretation. For example, ops like `arith.addi` and `arith.muli` do two's for interpretation. For example, ops like `arith.addi` and `arith.muli` do two's
complement arithmetic, but some other operations get a sign, e.g. `arith.divsi` complement arithmetic, but some other operations get a sign, e.g. `arith.divsi`
vs `arith.divui`. vs `arith.divui`.
LLVM uses the [same design](http://llvm.org/docs/LangRef.html#integer-type), LLVM uses the [same design](https://llvm.org/docs/LangRef.html#integer-type),
which was introduced in a revamp rolled out which was introduced in a revamp rolled out
[in the LLVM 2.0 integer type](http://releases.llvm.org/2.0/docs/LangRef.html#t_derived). [in the LLVM 2.0 integer type](https://releases.llvm.org/2.0/docs/LangRef.html#t_derived).
Prior to that, from Prior to that, from
[LLVM 1.0](http://releases.llvm.org/1.0/docs/LangRef.html#t_classifications) to [LLVM 1.0](https://releases.llvm.org/1.0/docs/LangRef.html#t_classifications) to
[1.9](http://releases.llvm.org/1.9/docs/LangRef.html#t_classifications), LLVM [1.9](https://releases.llvm.org/1.9/docs/LangRef.html#t_classifications), LLVM
uses signed types like "sbyte" and "ubyte". This shift was important and has uses signed types like "sbyte" and "ubyte". This shift was important and has
served LLVM well over the years. The reason this is important is that it is a served LLVM well over the years. The reason this is important is that it is a
good thing for an intermediate representation to represent the same computation good thing for an intermediate representation to represent the same computation
with the same instruction. Signed types got in the way, because (e.g.) an "add with the same instruction. Signed types got in the way, because (e.g.) an "add
of an sbyte" does the same computation as an "add of a ubyte", but the type of an sbyte" does the same computation as an "add of a ubyte", but the type
system made them look artificially different. This split also required casts system made them look artificially different. This split also required casts
like "cast from sbyte to ubyte" which do nothing at the machine level. Removing like "cast from sbyte to ubyte" which do nothing at the machine level. Removing
signs from the type system eliminated these problems, making the compiler signs from the type system eliminated these problems, making the compiler
simpler. simpler.
More information about this split is available in an old More information about this split is available in an old
[talk on youtube](https://www.youtube.com/watch?v=VeRaLPupGks) talking about [talk on youtube](https://www.youtube.com/watch?v=VeRaLPupGks) talking about
LLVM 2.0. LLVM 2.0.
Note that this rationale only applies to the "standard ops" dialect in which we Note that this rationale only applies to the "standard ops" dialect in which we
can express an opinion about its design. Other dialects generally try to model can express an opinion about its design. Other dialects generally try to model
an external system, and should aim to reflect its design as closely as possible. an external system, and should aim to reflect its design as closely as possible.
### Splitting floating point vs integer operations ### Splitting floating point vs integer operations
The MLIR "Arithmetic" dialect splits many integer and floating point operations The MLIR "Arithmetic" dialect splits many integer and floating point operations
into different categories, for example `arith.addf` vs `arith.addi` and into different categories, for example `arith.addf` vs `arith.addi` and
`arith.cmpf` vs `arith.cmpi` `arith.cmpf` vs `arith.cmpi`
([following the design of LLVM](http://llvm.org/docs/LangRef.html#binary-operations)). ([following the design of LLVM](https://llvm.org/docs/LangRef.html#binary-operations)).
These instructions *are* polymorphic on the number of elements in the type These instructions *are* polymorphic on the number of elements in the type
though, for example `addf` is used with scalar floats, vectors of floats, and though, for example `addf` is used with scalar floats, vectors of floats, and
tensors of floats (LLVM does the same thing with its scalar/vector types). tensors of floats (LLVM does the same thing with its scalar/vector types).
This split is important because floating point and integer operations are quite This split is important because floating point and integer operations are quite
different in practice: for example, floating point values include NaN's, so different in practice: for example, floating point values include NaN's, so
[integer comparisons](http://llvm.org/docs/LangRef.html#icmp-instruction) and [integer comparisons](https://llvm.org/docs/LangRef.html#icmp-instruction) and
[floating point comparisons](http://llvm.org/docs/LangRef.html#fcmp-instruction) [floating point comparisons](https://llvm.org/docs/LangRef.html#fcmp-instruction)
should use different comparison opcodes. On the arithmetic side of things, should use different comparison opcodes. On the arithmetic side of things,
floating point operations support rounding modes, floating point contractions, floating point operations support rounding modes, floating point contractions,
["fast math"](http://llvm.org/docs/LangRef.html#fadd-instruction), and integers ["fast math"](https://llvm.org/docs/LangRef.html#fadd-instruction), and integers
may want to have two's complement overflow behavior or be undefined on may want to have two's complement overflow behavior or be undefined on
[various forms of wrapping](http://llvm.org/docs/LangRef.html#add-instruction) [various forms of wrapping](https://llvm.org/docs/LangRef.html#add-instruction)
for performance. for performance.
We are a long way from this sort of thing being a priority to care about in We are a long way from this sort of thing being a priority to care about in
MLIR, but since we have experience and know the right way to do this, we'd MLIR, but since we have experience and know the right way to do this, we'd
rather design it in from the beginning. rather design it in from the beginning.
Note that this rationale only applies to the "standard ops" dialect in which we Note that this rationale only applies to the "standard ops" dialect in which we
can express an opinion about its design. Other dialects generally try to model can express an opinion about its design. Other dialects generally try to model
▲ Show 20 Lines • Show All 756 Lines • Show Last 20 Lines

mlir/docs/Rationale/RationaleGenericDAGRewriter.md

Show First 20 Lines • Show All 154 Lines • ▼ Show 20 Lines
* The cost model for these patterns is not really defined - it is emergent * The cost model for these patterns is not really defined - it is emergent
based on the order the patterns are matched in code. based on the order the patterns are matched in code.
* They are non-extensible without rebuilding the compiler. * They are non-extensible without rebuilding the compiler.
* It isn't practical to apply theorem provers and other tools to these * It isn't practical to apply theorem provers and other tools to these
patterns - they cannot be reused for other purposes. patterns - they cannot be reused for other purposes.
In addition to structured "combiners" like these, there are lots of ad-hoc In addition to structured "combiners" like these, there are lots of ad-hoc
systems like the systems like the
[LLVM Machine code peephole optimizer](http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/PeepholeOptimizer.cpp?view=markup) [LLVM Machine code peephole optimizer](https://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/PeepholeOptimizer.cpp?view=markup)
which are related. which are related.
### LLVM's DAG-to-DAG Instruction Selection Infrastructure ### LLVM's DAG-to-DAG Instruction Selection Infrastructure
The instruction selection subsystem in LLVM is the result of many years worth of The instruction selection subsystem in LLVM is the result of many years worth of
iteration and discovery, driven by the need for LLVM to support code generation iteration and discovery, driven by the need for LLVM to support code generation
for lots of targets, the complexity of code generators for modern instruction for lots of targets, the complexity of code generators for modern instruction
sets (e.g. X86), and the fanatical pursuit of reusing code across targets. Eli sets (e.g. X86), and the fanatical pursuit of reusing code across targets. Eli
▲ Show 20 Lines • Show All 115 Lines • Show Last 20 Lines

mlir/docs/doxygen-mainpage.dox

/// \mainpage MLIR /// \mainpage MLIR
/// ///
/// \section main_intro Introduction /// \section main_intro Introduction
/// Welcome to the MLIR project. /// Welcome to the MLIR project.
/// ///
/// This documentation describes the **internal** software that makes /// This documentation describes the **internal** software that makes
/// up MLIR, not the **external** use of MLIR. There are no instructions /// up MLIR, not the **external** use of MLIR. There are no instructions
/// here on how to use MLIR, only the APIs that make up the software. For /// here on how to use MLIR, only the APIs that make up the software. For
/// usage instructions, please see the [project website](http://mlir.llvm.org) /// usage instructions, please see the [project website](https://mlir.llvm.org)
/// for further detail. /// for further detail.
/// ///
/// \section main_caveat Caveat /// \section main_caveat Caveat
/// This documentation is generated directly from the source code with doxygen. /// This documentation is generated directly from the source code with doxygen.
/// Since MLIR is constantly under active development, what you're about to /// Since MLIR is constantly under active development, what you're about to
/// read is out of date! /// read is out of date!

mlir/include/mlir/Dialect/Vector/IR/VectorOps.td

Show First 20 Lines • Show All 280 Lines • ▼ Show 20 Lines let description = [{
Reduces an 1-D vector "horizontally" into a scalar using the given Reduces an 1-D vector "horizontally" into a scalar using the given
operation (add/mul/min/max for int/fp and and/or/xor for int only). operation (add/mul/min/max for int/fp and and/or/xor for int only).
Some reductions (add/mul for fp) also allow an optional fused Some reductions (add/mul for fp) also allow an optional fused
accumulator. accumulator.
Note that these operations are restricted to 1-D vectors to remain Note that these operations are restricted to 1-D vectors to remain
close to the corresponding LLVM intrinsics: close to the corresponding LLVM intrinsics:
http://llvm.org/docs/LangRef.html#vector-reduction-intrinsics https://llvm.org/docs/LangRef.html#vector-reduction-intrinsics
Example: Example:
```mlir ```mlir
%1 = vector.reduction <add>, %0 : vector<16xf32> into f32 %1 = vector.reduction <add>, %0 : vector<16xf32> into f32
%3 = vector.reduction <xor>, %2 : vector<4xi32> into i32 %3 = vector.reduction <xor>, %2 : vector<4xi32> into i32
▲ Show 20 Lines • Show All 2,047 Lines • ▼ Show 20 Lines let description = [{
The ‘vector.matrix_multiply’ op treats `lhs` as matrix with <lhs_rows> rows The ‘vector.matrix_multiply’ op treats `lhs` as matrix with <lhs_rows> rows
and <lhs_columns> columns, `rhs` as matrix with <lhs_columns> rows and and <lhs_columns> columns, `rhs` as matrix with <lhs_columns> rows and
<rhs_columns> and multiplies them. The result matrix is returned embedded in <rhs_columns> and multiplies them. The result matrix is returned embedded in
the result vector. the result vector.
Also see: Also see:
http://llvm.org/docs/LangRef.html#llvm-matrix-multiply-intrinsic https://llvm.org/docs/LangRef.html#llvm-matrix-multiply-intrinsic
Example: Example:
```mlir ```mlir
%C = vector.matrix_multiply %A, %B %C = vector.matrix_multiply %A, %B
{ lhs_rows = 4: i32, lhs_columns = 16: i32 , rhs_columns = 3: i32 } : { lhs_rows = 4: i32, lhs_columns = 16: i32 , rhs_columns = 3: i32 } :
(vector<64xf64>, vector<48xf64>) -> vector<12xf64> (vector<64xf64>, vector<48xf64>) -> vector<12xf64>
``` ```
Show All 40 Lines let description = [{
to the hardware ISA. to the hardware ISA.
The ‘vector.flat_transpose’ op treats the 1-D input `matrix` as The ‘vector.flat_transpose’ op treats the 1-D input `matrix` as
a 2-D matrix with <rows> rows and <columns> columns, and returns the a 2-D matrix with <rows> rows and <columns> columns, and returns the
transposed matrix in flattened form in 'res'. transposed matrix in flattened form in 'res'.
Also see: Also see:
http://llvm.org/docs/LangRef.html#llvm-matrix-transpose-intrinsic https://llvm.org/docs/LangRef.html#llvm-matrix-transpose-intrinsic
Example: Example:
```mlir ```mlir
%1 = vector.flat_transpose %0 { rows = 4: i32, columns = 4: i32 } %1 = vector.flat_transpose %0 { rows = 4: i32, columns = 4: i32 }
: (vector<16xf32>) -> vector<16xf32> : (vector<16xf32>) -> vector<16xf32>
``` ```
}]; }];
▲ Show 20 Lines • Show All 264 Lines • Show Last 20 Lines

mlir/lib/Transforms/CSE.cpp

Show First 20 Lines • Show All 287 Lines • ▼ Show 20 Linesvoid CSE::simplifyRegion(ScopedMapTy &knownValues, Region &region) {
if (!hasSSADominance) if (!hasSSADominance)
return; return;
// Note, deque is being used here because there was significant performance // Note, deque is being used here because there was significant performance
// gains over vector when the container becomes very large due to the // gains over vector when the container becomes very large due to the
// specific access patterns. If/when these performance issues are no // specific access patterns. If/when these performance issues are no
// longer a problem we can change this to vector. For more information see // longer a problem we can change this to vector. For more information see
// the llvm mailing list discussion on this: // the llvm mailing list discussion on this:
// http://lists.llvm.org/pipermail/llvm-commits/Week-of-Mon-20120116/135228.html // https://lists.llvm.org/pipermail/llvm-commits/Week-of-Mon-20120116/135228.html
std::deque<std::unique_ptr<CFGStackNode>> stack; std::deque<std::unique_ptr<CFGStackNode>> stack;
// Process the nodes of the dom tree for this region. // Process the nodes of the dom tree for this region.
stack.emplace_back(std::make_unique<CFGStackNode>( stack.emplace_back(std::make_unique<CFGStackNode>(
knownValues, domInfo->getRootNode(&region))); knownValues, domInfo->getRootNode(&region)));
while (!stack.empty()) { while (!stack.empty()) {
auto &currentNode = stack.back(); auto &currentNode = stack.back();
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

mlir/test/IR/invalid.mlir

// RUN: mlir-opt -allow-unregistered-dialect %s -split-input-file -verify-diagnostics // RUN: mlir-opt -allow-unregistered-dialect %s -split-input-file -verify-diagnostics
// See http://llvm.org/pr52045 // See https://llvm.org/pr52045
// UNSUPPORTED: asan // UNSUPPORTED: asan
// Check different error cases. // Check different error cases.
// ----- // -----
func.func @illegaltype(i) // expected-error {{expected non-function type}} func.func @illegaltype(i) // expected-error {{expected non-function type}}
// ----- // -----
▲ Show 20 Lines • Show All 1,683 Lines • ▼ Show 20 Lines
// ----- // -----
func.func @func() { func.func @func() {
%c0 = arith.constant // expected-error {{expected attribute value}} %c0 = arith.constant // expected-error {{expected attribute value}}
%x = arith.constant 1 : i32 %x = arith.constant 1 : i32
} }

openmp/libomptarget/README.txt

Show First 20 Lines • Show All 54 Lines • ▼ Show 20 Lines
Front-end Compilers that work with this RTL Front-end Compilers that work with this RTL
=========================================== ===========================================
The following compilers are known to do compatible code generation for The following compilers are known to do compatible code generation for
this RTL: this RTL:
- clang (from https://github.com/clang-ykt ) - clang (from https://github.com/clang-ykt )
- clang (development branch at http://clang.llvm.org - several features still - clang (development branch at https://clang.llvm.org - several features still
under development) under development)
----------------------------------------------------------------------- -----------------------------------------------------------------------
Notices Notices
======= =======
This library and related compiler support is still under development, so the This library and related compiler support is still under development, so the
employed interface is likely to change in the future. employed interface is likely to change in the future.
*Other names and brands may be claimed as the property of others. *Other names and brands may be claimed as the property of others.

openmp/runtime/src/i18n/en_US.txt

Show First 20 Lines • Show All 502 Lines • ▼ Show 20 LinesDuplicateLibrary "This means that multiple copies of the OpenMP runtime have been "
"linked into the program. That is dangerous, since it can degrade " "linked into the program. That is dangerous, since it can degrade "
"performance or cause incorrect results. " "performance or cause incorrect results. "
"The best thing to do is to ensure that only a single OpenMP runtime is " "The best thing to do is to ensure that only a single OpenMP runtime is "
"linked into the process, e.g. by avoiding static linking of the OpenMP " "linked into the process, e.g. by avoiding static linking of the OpenMP "
"runtime in any library. As an unsafe, unsupported, undocumented workaround " "runtime in any library. As an unsafe, unsupported, undocumented workaround "
"you can set the environment variable KMP_DUPLICATE_LIB_OK=TRUE to allow " "you can set the environment variable KMP_DUPLICATE_LIB_OK=TRUE to allow "
"the program to continue to execute, but that may cause crashes or " "the program to continue to execute, but that may cause crashes or "
"silently produce incorrect results. " "silently produce incorrect results. "
"For more information, please see http://openmp.llvm.org/" "For more information, please see https://openmp.llvm.org/"
NameComesFrom_CPUINFO_FILE "This name is specified in environment variable KMP_CPUINFO_FILE." NameComesFrom_CPUINFO_FILE "This name is specified in environment variable KMP_CPUINFO_FILE."
NotEnoughMemory "Seems application required too much memory." NotEnoughMemory "Seems application required too much memory."
ValidBoolValues "Use \"0\", \"FALSE\". \".F.\", \"off\", \"no\" as false values, " ValidBoolValues "Use \"0\", \"FALSE\". \".F.\", \"off\", \"no\" as false values, "
"\"1\", \"TRUE\", \".T.\", \"on\", \"yes\" as true values." "\"1\", \"TRUE\", \".T.\", \"on\", \"yes\" as true values."
BufferOverflow "Perhaps too many threads." BufferOverflow "Perhaps too many threads."
RunningAtMaxPriority "Decrease priority of application. " RunningAtMaxPriority "Decrease priority of application. "
"This will allow the monitor thread run at higher priority than other threads." "This will allow the monitor thread run at higher priority than other threads."
ChangeMonitorStackSize "Try changing KMP_MONITOR_STACKSIZE or the shell stack limit." ChangeMonitorStackSize "Try changing KMP_MONITOR_STACKSIZE or the shell stack limit."
Show All 26 Lines

polly/README

Polly - Polyhedral optimizations for LLVM Polly - Polyhedral optimizations for LLVM
----------------------------------------- -----------------------------------------
http://polly.llvm.org/ https://polly.llvm.org/
Polly uses a mathematical representation, the polyhedral model, to represent and Polly uses a mathematical representation, the polyhedral model, to represent and
transform loops and other control flow structures. Using an abstract transform loops and other control flow structures. Using an abstract
representation it is possible to reason about transformations in a more general representation it is possible to reason about transformations in a more general
way and to use highly optimized linear programming libraries to figure out the way and to use highly optimized linear programming libraries to figure out the
optimal loop structure. These transformations can be used to do constant optimal loop structure. These transformations can be used to do constant
propagation through arrays, remove dead loop iterations, optimize loops for propagation through arrays, remove dead loop iterations, optimize loops for
cache locality, optimize arrays, apply advanced automatic parallelization, drive cache locality, optimize arrays, apply advanced automatic parallelization, drive
vectorization, or they can be used to do software pipelining. vectorization, or they can be used to do software pipelining.

polly/docs/HowToManuallyUseTheIndividualPiecesOfPolly.rst

Show First 20 Lines • Show All 86 Lines • ▼ Show 20 Lines----------------------------------------------------------------------------------------
$ opt -polly-use-llvm-names -basic-aa -view-scops -disable-output matmul.preopt.ll $ opt -polly-use-llvm-names -basic-aa -view-scops -disable-output matmul.preopt.ll
$ opt -polly-use-llvm-names -basic-aa -view-scops-only -disable-output matmul.preopt.ll $ opt -polly-use-llvm-names -basic-aa -view-scops-only -disable-output matmul.preopt.ll
The output for the different functions: The output for the different functions:
- view-scops : main_, init_array_, print_array_ - view-scops : main_, init_array_, print_array_
- view-scops-only : main-scopsonly_, init_array-scopsonly_, print_array-scopsonly_ - view-scops-only : main-scopsonly_, init_array-scopsonly_, print_array-scopsonly_
.. _main: http://polly.llvm.org/experiments/matmul/scops.main.dot.png .. _main: https://polly.llvm.org/experiments/matmul/scops.main.dot.png
.. _init_array: http://polly.llvm.org/experiments/matmul/scops.init_array.dot.png .. _init_array: https://polly.llvm.org/experiments/matmul/scops.init_array.dot.png
.. _print_array: http://polly.llvm.org/experiments/matmul/scops.print_array.dot.png .. _print_array: https://polly.llvm.org/experiments/matmul/scops.print_array.dot.png
.. _main-scopsonly: http://polly.llvm.org/experiments/matmul/scopsonly.main.dot.png .. _main-scopsonly: https://polly.llvm.org/experiments/matmul/scopsonly.main.dot.png
.. _init_array-scopsonly: http://polly.llvm.org/experiments/matmul/scopsonly.init_array.dot.png .. _init_array-scopsonly: https://polly.llvm.org/experiments/matmul/scopsonly.init_array.dot.png
.. _print_array-scopsonly: http://polly.llvm.org/experiments/matmul/scopsonly.print_array.dot.png .. _print_array-scopsonly: https://polly.llvm.org/experiments/matmul/scopsonly.print_array.dot.png
5. **View the polyhedral representation of the SCoPs** 5. **View the polyhedral representation of the SCoPs**
------------------------------------------------------ ------------------------------------------------------
.. code-block:: console .. code-block:: console
$ opt -polly-use-llvm-names -basic-aa -polly-scops -analyze matmul.preopt.ll -polly-process-unprofitable $ opt -polly-use-llvm-names -basic-aa -polly-scops -analyze matmul.preopt.ll -polly-process-unprofitable
▲ Show 20 Lines • Show All 363 Lines • ▼ Show 20 Lines By comparing the runtimes of the different code snippets we see that a
real 0m5.430s real 0m5.430s
user 0m5.424s user 0m5.424s
sys 0m0.004s sys 0m0.004s
$ time ./matmul.polly.interchanged+tiled+vector+openmp.exe $ time ./matmul.polly.interchanged+tiled+vector+openmp.exe
real 0m3.184s real 0m3.184s
user 0m11.972s user 0m11.972s
sys 0m0.036s sys 0m0.036s

polly/docs/index.rst

Show All 21 Lines.. toctree::
:maxdepth: 2 :maxdepth: 2
Architecture Architecture
UsingPollyWithClang UsingPollyWithClang
HowToManuallyUseTheIndividualPiecesOfPolly HowToManuallyUseTheIndividualPiecesOfPolly
TipsAndTricks TipsAndTricks
Performance Performance
* `A list of Polly passes <http://polly.llvm.org/documentation/passes.html>`_ * `A list of Polly passes <https://polly.llvm.org/documentation/passes.html>`_
Indices and tables Indices and tables
================== ==================
* :ref:`genindex` * :ref:`genindex`
* :ref:`search` * :ref:`search`

polly/lib/External/ppcg/README

Requirements: Requirements:
- automake, autoconf, libtool - automake, autoconf, libtool
(not needed when compiling a release) (not needed when compiling a release)
- pkg-config (http://www.freedesktop.org/wiki/Software/pkg-config) - pkg-config (http://www.freedesktop.org/wiki/Software/pkg-config)
(not needed when compiling a release using the included isl and pet) (not needed when compiling a release using the included isl and pet)
- gmp (http://gmplib.org/) - gmp (http://gmplib.org/)
- libyaml (http://pyyaml.org/wiki/LibYAML) - libyaml (http://pyyaml.org/wiki/LibYAML)
(only needed if you want to compile the pet executable) (only needed if you want to compile the pet executable)
- LLVM/clang libraries, 2.9 or higher (http://clang.llvm.org/get_started.html) - LLVM/clang libraries, 2.9 or higher (https://clang.llvm.org/get_started.html)
Unless you have some other reasons for wanting to use the svn version, Unless you have some other reasons for wanting to use the svn version,
it is best to install the latest release (3.9). it is best to install the latest release (3.9).
For more details, see pet/README. For more details, see pet/README.
If you are installing on Ubuntu, then you can install the following packages: If you are installing on Ubuntu, then you can install the following packages:
automake autoconf libtool pkg-config libgmp3-dev libyaml-dev libclang-dev llvm automake autoconf libtool pkg-config libgmp3-dev libyaml-dev libclang-dev llvm
▲ Show 20 Lines • Show All 228 Lines • Show Last 20 Lines

polly/lib/Support/Mainpage.h

/*! \mainpage Polly main page /*! \mainpage Polly main page
* *
* This is the documentation of http://polly.llvm.org * This is the documentation of https://polly.llvm.org
*/ */

polly/test/CodeGen/test-invalid-operands-for-select-2.ll

; RUN: opt %loadPolly -S -polly-codegen -verify-loop-info < %s | FileCheck %s ; RUN: opt %loadPolly -S -polly-codegen -verify-loop-info < %s | FileCheck %s
; ;
; Check that we do not crash as described here: http://llvm.org/bugs/show_bug.cgi?id=21167 ; Check that we do not crash as described here: https://llvm.org/bugs/show_bug.cgi?id=21167
; ;
; CHECK: polly.split_new_and_old ; CHECK: polly.split_new_and_old
; ;
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
; Function Attrs: nounwind uwtable ; Function Attrs: nounwind uwtable
define void @kernel_fdtd_apml(i32 %cxm, i32 %cym, [65 x [65 x double]]* %Bza, [65 x [65 x double]]* %Hz, double* %czp) #0 { define void @kernel_fdtd_apml(i32 %cxm, i32 %cym, [65 x [65 x double]]* %Bza, [65 x [65 x double]]* %Hz, double* %czp) #0 {
entry: entry:
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

polly/test/CodeGen/test-invalid-operands-for-select.ll

; RUN: opt %loadPolly -S -polly-codegen < %s | FileCheck %s ; RUN: opt %loadPolly -S -polly-codegen < %s | FileCheck %s
; ;
; Check that we do not crash as described here: http://llvm.org/PR21167 ; Check that we do not crash as described here: https://llvm.org/PR21167
; ;
; In case the pieceweise affine function used to create an isl_ast_expr ; In case the pieceweise affine function used to create an isl_ast_expr
; had empty cases (e.g., with contradicting constraints on the ; had empty cases (e.g., with contradicting constraints on the
; parameters), it was possible that the condition of the isl_ast_expr ; parameters), it was possible that the condition of the isl_ast_expr
; select was not a comparison but a constant (thus of type i64). ; select was not a comparison but a constant (thus of type i64).
; However, we shouldn't crash in such a case :) ; However, we shouldn't crash in such a case :)
; ;
; CHECK: polly.split_new_and_old ; CHECK: polly.split_new_and_old
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

polly/www/index.html

Show First 20 Lines • Show All 184 Lines • ▼ Show 20 Lines<div id="content">
</td> </td>
</tr> </tr>
<tr><td width="120"><p>February</p></td> <tr><td width="120"><p>February</p></td>
<td> <td>
<h4>Polly presentation at FOSDEM 2014</h4> Polly was <a <h4>Polly presentation at FOSDEM 2014</h4> Polly was <a
href="https://fosdem.org/2014/schedule/event/polly/">presented</a> at the href="https://fosdem.org/2014/schedule/event/polly/">presented</a> at the
FOSDEM LLVM developer's meeting. FOSDEM LLVM developer's meeting.
<h4>New LLVM test-suite buildbots</h4> <h4>New LLVM test-suite buildbots</h4>
The set of <a href="http://lab.llvm.org:8011/console?category=polly">Polly The set of <a href="https://lab.llvm.org:8011/console?category=polly">Polly
buildbots</a> has been extended. We now have 16 new blades that track buildbots</a> has been extended. We now have 16 new blades that track
correctness and performance when compiling the LLVM test-suite. For now five correctness and performance when compiling the LLVM test-suite. For now five
of them are used to provide <a of them are used to provide <a
href="https://llvm.org/perf/db_default/v4/nts/22463">fine granularity href="https://llvm.org/perf/db_default/v4/nts/22463">fine granularity
reports</a> (almost per-commit) reports</a> (almost per-commit)
for 'clang -O3' (no polly). We also have six machines that track different for 'clang -O3' (no polly). We also have six machines that track different
configurations of polly. configurations of polly.
</td> </td>
▲ Show 20 Lines • Show All 120 Lines • ▼ Show 20 Linesresearch tool.<br \>
clang plugin</a></p> clang plugin</a></p>
</td> </td>
</tr> </tr>
<tr> <tr>
<td><p>July</p></td> <td><p>July</p></td>
<td> <td>
<p> Polly builder as part of the <a <p> Polly builder as part of the <a
href="http://lab.llvm.org:8011/console">LLVM Buildbots</a> href="https://lab.llvm.org:8011/console">LLVM Buildbots</a>
</p> </p>
</td> </td>
</tr> </tr>
<tr> <tr>
<td><p>June</p></td> <td><p>June</p></td>
<td> <td>
<p><a href="https://www.grosser.es">Tobias</a> is founded for <p><a href="https://www.grosser.es">Tobias</a> is founded for
▲ Show 20 Lines • Show All 112 Lines • Show Last 20 Lines

polly/www/menu.html.incl

<div id="head" style="position: relative"> <div id="head" style="position: relative">
<h1><span><a href="/">Polly</a></span></h1> <h1><span><a href="/">Polly</a></span></h1>
<h2><span>LLVM Framework for High-Level Loop and Data-Locality <h2><span>LLVM Framework for High-Level Loop and Data-Locality
Optimizations</span></h2> Optimizations</span></h2>
<p> Hexagonal tiling in 3D</p> <p> Hexagonal tiling in 3D</p>
</div> </div>
<div id="menu"> <div id="menu">
<a href="http://llvm.org">llvm.org</a> <a href="https://llvm.org">llvm.org</a>
<div class="submenu"> <div class="submenu">
<label>Information</label> <label>Information</label>
<a href="/index.html">Overview and News</a> <a href="/index.html">Overview and News</a>
<a href="/get_started.html">Get and Install</a> <a href="/get_started.html">Get and Install</a>
</a> </a>
<a href="/docs">Documentation</a> <a href="/docs">Documentation</a>
<a href="/performance.html">Performance</a> <a href="/performance.html">Performance</a>
<a href="/publications.html">Publications</a> <a href="/publications.html">Publications</a>
<a href="/contributors.html">Contributors</a> <a href="/contributors.html">Contributors</a>
<a href="/todo.html">TODO</a> <a href="/todo.html">TODO</a>
<a href="/changelog.html">ChangeLog</a> <a href="/changelog.html">ChangeLog</a>
<a href="/projects.html">Open Projects</a> <a href="/projects.html">Open Projects</a>
</div> </div>
<div class="submenu"> <div class="submenu">
<label>Development </label> <label>Development </label>
<a href="http://lists.llvm.org/mailman/listinfo/llvm-commits"> <a href="https://lists.llvm.org/mailman/listinfo/llvm-commits">
Mailing List (patches) Mailing List (patches)
</a> </a>
<a href="http://groups.google.com/group/polly-dev">Mailing List (discussion)</a> <a href="http://groups.google.com/group/polly-dev">Mailing List (discussion)</a>
<a href="/bugs.html">Bug Reports</a> <a href="/bugs.html">Bug Reports</a>
<a href="http://lab.llvm.org:8011/console?category=polly">Buildbot</a> <a href="https://lab.llvm.org:8011/console?category=polly">Buildbot</a>
<a href="http://lab.llvm.org:8080/coverage/coverage-reports/polly/index.html">Code Coverage</a> <a href="https://lab.llvm.org:8080/coverage/coverage-reports/polly/index.html">Code Coverage</a>
<a href="http://llvm.org/reports/scan-build/">Static analysis</a> <a href="https://llvm.org/reports/scan-build/">Static analysis</a>
<a href="/doxygen/">Doxygen</a> <a href="/doxygen/">Doxygen</a>
<a href="https://github.com/llvm/llvm-project/tree/main/polly">Source @ GitHub</a> <a href="https://github.com/llvm/llvm-project/tree/main/polly">Source @ GitHub</a>
</div> </div>
<div class="submenu"> <div class="submenu">
<label>Resources</label> <label>Resources</label>
<br> <br>
<a href="https://www.pollylabs.org"><img style="padding-left: 3.5em; <a href="https://www.pollylabs.org"><img style="padding-left: 3.5em;
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

polly/www/todo.html

Show First 20 Lines • Show All 429 Lines • ▼ Show 20 Lines
<th align="left"> Website <th align="left"> Website
</th><td class="done" align="center"> </th><td class="done" align="center">
<a href="https://polly.llvm.org">https://polly.llvm.org</a> <a href="https://polly.llvm.org">https://polly.llvm.org</a>
</td><td> Tobias </td><td> Tobias
</td></tr> </td></tr>
<tr> <tr>
<th align="left">Buildbot that runs 'make polly-test' <th align="left">Buildbot that runs 'make polly-test'
</th><td class="done" align="center"> </th><td class="done" align="center">
<a href="http://lab.llvm.org:8011/console">Buildbot</a> <a href="https://lab.llvm.org:8011/console">Buildbot</a>
</td> </td>
<td> Tobias, Andreas <td> Tobias, Andreas
</td></tr> </td></tr>
</th><td> </th><td>
</td></tr> </td></tr>
</tbody></table> </tbody></table>
<h3 id="phase2"> Phase 2 - First Optimizations and Enhanced User Experience (Finished <h3 id="phase2"> Phase 2 - First Optimizations and Enhanced User Experience (Finished
▲ Show 20 Lines • Show All 200 Lines • Show Last 20 Lines

third-party/benchmark/.ycm_extra_conf.py

Show All 19 Lines
'-I', 'include', '-I', 'include',
'-isystem', '/usr/include', '-isystem', '/usr/include',
'-isystem', '/usr/local/include', '-isystem', '/usr/local/include',
] ]
# Set this to the absolute path to the folder (NOT the file!) containing the # Set this to the absolute path to the folder (NOT the file!) containing the
# compile_commands.json file to use that instead of 'flags'. See here for # compile_commands.json file to use that instead of 'flags'. See here for
# more details: http://clang.llvm.org/docs/JSONCompilationDatabase.html # more details: https://clang.llvm.org/docs/JSONCompilationDatabase.html
# #
# Most projects will NOT need to set this to anything; you can just change the # Most projects will NOT need to set this to anything; you can just change the
# 'flags' list of compilation flags. Notice that YCM itself uses that approach. # 'flags' list of compilation flags. Notice that YCM itself uses that approach.
compilation_database_folder = '' compilation_database_folder = ''
if os.path.exists( compilation_database_folder ): if os.path.exists( compilation_database_folder ):
database = ycm_core.CompilationDatabase( compilation_database_folder ) database = ycm_core.CompilationDatabase( compilation_database_folder )
else: else:
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines

utils/bazel/llvm-project-overlay/llvm/tblgen.bzl

# This file is licensed under the Apache License v2.0 with LLVM Exceptions. # This file is licensed under the Apache License v2.0 with LLVM Exceptions.
# See https://llvm.org/LICENSE.txt for license information. # See https://llvm.org/LICENSE.txt for license information.
# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
"""This file contains BUILD extensions for generating source code from LLVM's """This file contains BUILD extensions for generating source code from LLVM's
table definition files using the TableGen tool. table definition files using the TableGen tool.
See http://llvm.org/cmds/tblgen.html for more information on the TableGen See https://llvm.org/cmds/tblgen.html for more information on the TableGen
tool. tool.
TODO(chandlerc): Currently this expresses include-based dependencies as TODO(chandlerc): Currently this expresses include-based dependencies as
"sources", and has no transitive understanding due to these files not being "sources", and has no transitive understanding due to these files not being
correctly understood by the build system. correctly understood by the build system.
""" """
def gentbl( def gentbl(
name, name,
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines