[llvm-branch-commits] [clang-tools-extra] [clang-tidy][docs] Rewrite check docs in six modules to Markdown (PR #217672)
via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Thu Aug 20 09:01:10 PDT 2026
llvmorg-github-actions[bot] wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-clang-tools-extra
Author: Zeyi Xu (zeyi2)
<details>
<summary>Changes</summary>
<sub>Stack created with <a href="https://github.com/github/gh-stack">GitHub Stacks CLI</a> • <a href="https://gh.io/stacks-feedback">Give Feedback 💬</a></sub>
---
Patch is 40.59 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/217672.diff
10 Files Affected:
- (modified) clang-tools-extra/docs/clang-tidy/checks/altera/single-work-item-barrier.md (+36-38)
- (modified) clang-tools-extra/docs/clang-tidy/checks/altera/struct-pack-align.md (+42-43)
- (modified) clang-tools-extra/docs/clang-tidy/checks/altera/unroll-loops.md (+82-84)
- (modified) clang-tools-extra/docs/clang-tidy/checks/android/comparison-in-temp-failure-retry.md (+26-28)
- (modified) clang-tools-extra/docs/clang-tidy/checks/boost/use-ranges.md (+156-157)
- (modified) clang-tools-extra/docs/clang-tidy/checks/cert/err33-c.md (+187-188)
- (modified) clang-tools-extra/docs/clang-tidy/checks/concurrency/mt-unsafe.md (+31-33)
- (modified) clang-tools-extra/docs/clang-tidy/checks/fuchsia/statically-constructed-objects.md (+28-28)
- (modified) clang-tools-extra/docs/clang-tidy/checks/fuchsia/temporary-objects.md (+28-29)
- (modified) clang-tools-extra/docs/clang-tidy/checks/fuchsia/trailing-return.md (+23-24)
``````````diff
diff --git a/clang-tools-extra/docs/clang-tidy/checks/altera/single-work-item-barrier.md b/clang-tools-extra/docs/clang-tidy/checks/altera/single-work-item-barrier.md
index 0e059f1af6e81..308d960c1e1a0 100644
--- a/clang-tools-extra/docs/clang-tidy/checks/altera/single-work-item-barrier.md
+++ b/clang-tools-extra/docs/clang-tidy/checks/altera/single-work-item-barrier.md
@@ -1,11 +1,11 @@
-.. title:: clang-tidy - altera-single-work-item-barrier
+```{title} clang-tidy - altera-single-work-item-barrier
+```
-altera-single-work-item-barrier
-===============================
+# altera-single-work-item-barrier
Finds OpenCL kernel functions that call a barrier function but do not call
-an ID function (``get_local_id``, ``get_local_id``, ``get_group_id``, or
-``get_local_linear_id``).
+an ID function (`get_local_id`, `get_local_id`, `get_group_id`, or
+`get_local_linear_id`).
These kernels may be viable single work-item kernels, but will be forced to
execute as NDRange kernels if using a newer version of the Altera Offline
@@ -15,44 +15,42 @@ If using an older version of the Altera Offline Compiler, these kernel
functions will be treated as single work-item kernels, which could be
inefficient or lead to errors if NDRange semantics were intended.
-Based on the `Altera SDK for OpenCL: Best Practices Guide
-<https://www.altera.com/en_US/pdfs/literature/hb/opencl-sdk/aocl_optimization_guide.pdf>`_.
+Based on the [Altera SDK for OpenCL: Best Practices Guide](https://www.altera.com/en_US/pdfs/literature/hb/opencl-sdk/aocl_optimization_guide.pdf).
Examples:
-.. code-block:: c++
-
- // error: function calls barrier but does not call an ID function.
- void __kernel barrier_no_id(__global int * foo, int size) {
- for (int i = 0; i < 100; i++) {
- foo[i] += 5;
- }
- barrier(CLK_GLOBAL_MEM_FENCE);
+```c++
+// error: function calls barrier but does not call an ID function.
+void __kernel barrier_no_id(__global int * foo, int size) {
+ for (int i = 0; i < 100; i++) {
+ foo[i] += 5;
}
-
- // ok: function calls barrier and an ID function.
- void __kernel barrier_with_id(__global int * foo, int size) {
- for (int i = 0; i < 100; i++) {
- int tid = get_global_id(0);
- foo[tid] += 5;
- }
- barrier(CLK_GLOBAL_MEM_FENCE);
+ barrier(CLK_GLOBAL_MEM_FENCE);
+}
+
+// ok: function calls barrier and an ID function.
+void __kernel barrier_with_id(__global int * foo, int size) {
+ for (int i = 0; i < 100; i++) {
+ int tid = get_global_id(0);
+ foo[tid] += 5;
}
-
- // ok with AOC Version 17.01: the reqd_work_group_size turns this into
- // an NDRange.
- __attribute__((reqd_work_group_size(2,2,2)))
- void __kernel barrier_with_id(__global int * foo, int size) {
- for (int i = 0; i < 100; i++) {
- foo[tid] += 5;
- }
- barrier(CLK_GLOBAL_MEM_FENCE);
+ barrier(CLK_GLOBAL_MEM_FENCE);
+}
+
+// ok with AOC Version 17.01: the reqd_work_group_size turns this into
+// an NDRange.
+__attribute__((reqd_work_group_size(2,2,2)))
+void __kernel barrier_with_id(__global int * foo, int size) {
+ for (int i = 0; i < 100; i++) {
+ foo[tid] += 5;
}
+ barrier(CLK_GLOBAL_MEM_FENCE);
+}
+```
-Options
--------
-
-.. option:: AOCVersion
+## Options
- Defines the version of the Altera Offline Compiler. Defaults to ``1600``
- (corresponding to version 16.00).
+```{option} AOCVersion
+Defines the version of the Altera Offline Compiler. Default is `1600`
+(corresponding to version 16.00).
+```
diff --git a/clang-tools-extra/docs/clang-tidy/checks/altera/struct-pack-align.md b/clang-tools-extra/docs/clang-tidy/checks/altera/struct-pack-align.md
index b03a4fcf7fcf3..ab77344a9703e 100644
--- a/clang-tools-extra/docs/clang-tidy/checks/altera/struct-pack-align.md
+++ b/clang-tools-extra/docs/clang-tidy/checks/altera/struct-pack-align.md
@@ -1,7 +1,7 @@
-.. title:: clang-tidy - altera-struct-pack-align
+```{title} clang-tidy - altera-struct-pack-align
+```
-altera-struct-pack-align
-========================
+# altera-struct-pack-align
Finds structs that are inefficiently packed or aligned, and recommends
packing and/or aligning of said structs as needed.
@@ -12,43 +12,42 @@ structs that are not well aligned is inefficient.
Fix-its are provided to fix both of these issues by inserting and/or amending
relevant struct attributes.
-Based on the `Altera SDK for OpenCL: Best Practices Guide
-<https://www.altera.com/en_US/pdfs/literature/hb/opencl-sdk/aocl_optimization_guide.pdf>`_.
-
-.. code-block:: c++
-
- // The following struct is originally aligned to 4 bytes, and thus takes up
- // 12 bytes of memory instead of 10. Packing the struct will make it use
- // only 10 bytes of memory, and aligning it to 16 bytes will make it
- // efficient to access.
- struct example {
- char a; // 1 byte
- double b; // 8 bytes
- char c; // 1 byte
- };
-
- // The following struct is arranged in such a way that packing is not needed.
- // However, it is aligned to 4 bytes instead of 8, and thus needs to be
- // explicitly aligned.
- struct implicitly_packed_example {
- char a; // 1 byte
- char b; // 1 byte
- char c; // 1 byte
- char d; // 1 byte
- int e; // 4 bytes
- };
-
- // The following struct is explicitly aligned and packed.
- struct good_example {
- char a; // 1 byte
- double b; // 8 bytes
- char c; // 1 byte
- } __attribute__((packed)) __attribute__((aligned(16));
-
- // Explicitly aligning a struct to the wrong value will result in a warning.
- // The following example should be aligned to 16 bytes, not 32.
- struct badly_aligned_example {
- char a; // 1 byte
- double b; // 8 bytes
- char c; // 1 byte
- } __attribute__((packed)) __attribute__((aligned(32)));
+Based on the [Altera SDK for OpenCL: Best Practices Guide](https://www.altera.com/en_US/pdfs/literature/hb/opencl-sdk/aocl_optimization_guide.pdf).
+
+```c++
+// The following struct is originally aligned to 4 bytes, and thus takes up
+// 12 bytes of memory instead of 10. Packing the struct will make it use
+// only 10 bytes of memory, and aligning it to 16 bytes will make it
+// efficient to access.
+struct example {
+ char a; // 1 byte
+ double b; // 8 bytes
+ char c; // 1 byte
+};
+
+// The following struct is arranged in such a way that packing is not needed.
+// However, it is aligned to 4 bytes instead of 8, and thus needs to be
+// explicitly aligned.
+struct implicitly_packed_example {
+ char a; // 1 byte
+ char b; // 1 byte
+ char c; // 1 byte
+ char d; // 1 byte
+ int e; // 4 bytes
+};
+
+// The following struct is explicitly aligned and packed.
+struct good_example {
+ char a; // 1 byte
+ double b; // 8 bytes
+ char c; // 1 byte
+} __attribute__((packed)) __attribute__((aligned(16));
+
+// Explicitly aligning a struct to the wrong value will result in a warning.
+// The following example should be aligned to 16 bytes, not 32.
+struct badly_aligned_example {
+ char a; // 1 byte
+ double b; // 8 bytes
+ char c; // 1 byte
+} __attribute__((packed)) __attribute__((aligned(32)));
+```
diff --git a/clang-tools-extra/docs/clang-tidy/checks/altera/unroll-loops.md b/clang-tools-extra/docs/clang-tidy/checks/altera/unroll-loops.md
index 419a1edf02112..158566b580d83 100644
--- a/clang-tools-extra/docs/clang-tidy/checks/altera/unroll-loops.md
+++ b/clang-tools-extra/docs/clang-tidy/checks/altera/unroll-loops.md
@@ -1,7 +1,7 @@
-.. title:: clang-tidy - altera-unroll-loops
+```{title} clang-tidy - altera-unroll-loops
+```
-altera-unroll-loops
-===================
+# altera-unroll-loops
Finds inner loops that have not been unrolled, as well as fully unrolled loops
with unknown loop bounds or a large number of iterations.
@@ -12,94 +12,92 @@ be fully unrolled, and should be partially unrolled.
Notes:
-- This check is unable to determine the number of iterations in a ``while`` or
- ``do..while`` loop; hence if such a loop is fully unrolled, a note is emitted
+- This check is unable to determine the number of iterations in a `while` or
+ `do..while` loop; hence if such a loop is fully unrolled, a note is emitted
advising the user to partially unroll instead.
-
-- In ``for`` loops, our check only works with simple arithmetic increments (
- ``+``, ``-``, ``*``, ``/``). For all other increments, partial unrolling is
+- In `for` loops, our check only works with simple arithmetic increments (
+ `+`, `-`, `*`, `/`). For all other increments, partial unrolling is
advised.
-
- Depending on the exit condition, the calculations for determining if the
number of iterations is large may be off by 1. This should not be an issue
since the cut-off is generally arbitrary.
-Based on the `Altera SDK for OpenCL: Best Practices Guide
-<https://www.altera.com/en_US/pdfs/literature/hb/opencl-sdk/aocl_optimization_guide.pdf>`_.
-
-.. code-block:: c++
-
- for (int i = 0; i < 10; i++) { // ok: outer loops should not be unrolled
- int j = 0;
- do { // warning: this inner do..while loop should be unrolled
- j++;
- } while (j < 15);
-
- int k = 0;
- #pragma unroll
- while (k < 20) { // ok: this inner loop is already unrolled
- k++;
- }
- }
-
- int A[1000];
- #pragma unroll
- // warning: this loop is large and should be partially unrolled
- for (int a : A) {
- printf("%d", a);
- }
+Based on the [Altera SDK for OpenCL: Best Practices Guide](https://www.altera.com/en_US/pdfs/literature/hb/opencl-sdk/aocl_optimization_guide.pdf).
- #pragma unroll 5
- // ok: this loop is large, but is partially unrolled
- for (int a : A) {
- printf("%d", a);
- }
+```c++
+for (int i = 0; i < 10; i++) { // ok: outer loops should not be unrolled
+ int j = 0;
+ do { // warning: this inner do..while loop should be unrolled
+ j++;
+ } while (j < 15);
+ int k = 0;
#pragma unroll
- // warning: this loop is large and should be partially unrolled
- for (int i = 0; i < 1000; ++i) {
- printf("%d", i);
+ while (k < 20) { // ok: this inner loop is already unrolled
+ k++;
}
-
- #pragma unroll 5
- // ok: this loop is large, but is partially unrolled
- for (int i = 0; i < 1000; ++i) {
- printf("%d", i);
- }
-
- #pragma unroll
- // warning: << operator not supported, recommend partial unrolling
- for (int i = 0; i < 1000; i<<1) {
- printf("%d", i);
- }
-
- std::vector<int> someVector (100, 0);
- int i = 0;
- #pragma unroll
- // note: loop may be large, recommend partial unrolling
- while (i < someVector.size()) {
- someVector[i]++;
- }
-
- #pragma unroll
- // note: loop may be large, recommend partial unrolling
- while (true) {
- printf("In loop");
- }
-
- #pragma unroll 5
- // ok: loop may be large, but is partially unrolled
- while (i < someVector.size()) {
- someVector[i]++;
- }
-
-Options
--------
-
-.. option:: MaxLoopIterations
-
- Defines the maximum number of loop iterations that a fully unrolled loop
- can have. By default, it is set to `100`.
-
- In practice, this refers to the integer value of the upper bound
- within the loop statement's condition expression.
+}
+
+int A[1000];
+#pragma unroll
+// warning: this loop is large and should be partially unrolled
+for (int a : A) {
+ printf("%d", a);
+}
+
+#pragma unroll 5
+// ok: this loop is large, but is partially unrolled
+for (int a : A) {
+ printf("%d", a);
+}
+
+#pragma unroll
+// warning: this loop is large and should be partially unrolled
+for (int i = 0; i < 1000; ++i) {
+ printf("%d", i);
+}
+
+#pragma unroll 5
+// ok: this loop is large, but is partially unrolled
+for (int i = 0; i < 1000; ++i) {
+ printf("%d", i);
+}
+
+#pragma unroll
+// warning: << operator not supported, recommend partial unrolling
+for (int i = 0; i < 1000; i<<1) {
+ printf("%d", i);
+}
+
+std::vector<int> someVector (100, 0);
+int i = 0;
+#pragma unroll
+// note: loop may be large, recommend partial unrolling
+while (i < someVector.size()) {
+ someVector[i]++;
+}
+
+#pragma unroll
+// note: loop may be large, recommend partial unrolling
+while (true) {
+ printf("In loop");
+}
+
+#pragma unroll 5
+// ok: loop may be large, but is partially unrolled
+while (i < someVector.size()) {
+ someVector[i]++;
+}
+```
+
+## Options
+
+```{option} MaxLoopIterations
+Defines the maximum number of loop iterations that a fully unrolled loop
+can have.
+
+In practice, this refers to the integer value of the upper bound
+within the loop statement's condition expression.
+
+Default is `100`.
+```
diff --git a/clang-tools-extra/docs/clang-tidy/checks/android/comparison-in-temp-failure-retry.md b/clang-tools-extra/docs/clang-tidy/checks/android/comparison-in-temp-failure-retry.md
index 42e8dd97452ef..2f7c5cad3c041 100644
--- a/clang-tools-extra/docs/clang-tidy/checks/android/comparison-in-temp-failure-retry.md
+++ b/clang-tools-extra/docs/clang-tidy/checks/android/comparison-in-temp-failure-retry.md
@@ -1,44 +1,42 @@
-.. title:: clang-tidy - android-comparison-in-temp-failure-retry
+```{title} clang-tidy - android-comparison-in-temp-failure-retry
+```
-android-comparison-in-temp-failure-retry
-========================================
+# android-comparison-in-temp-failure-retry
Diagnoses comparisons that appear to be incorrectly placed in the argument to
-the ``TEMP_FAILURE_RETRY`` macro. Having such a use is incorrect in the vast
+the `TEMP_FAILURE_RETRY` macro. Having such a use is incorrect in the vast
majority of cases, and will often silently defeat the purpose of the
-``TEMP_FAILURE_RETRY`` macro.
+`TEMP_FAILURE_RETRY` macro.
-For context, ``TEMP_FAILURE_RETRY`` is `a convenience macro
-<https://www.gnu.org/software/libc/manual/html_node/Interrupted-Primitives.html>`_
+For context, `TEMP_FAILURE_RETRY` is [a convenience macro](https://www.gnu.org/software/libc/manual/html_node/Interrupted-Primitives.html)
provided by both glibc and Bionic. Its purpose is to repeatedly run a syscall
until it either succeeds, or fails for reasons other than being interrupted.
Example buggy usage looks like:
-.. code-block:: c
+```c
+char cs[1];
+while (TEMP_FAILURE_RETRY(read(STDIN_FILENO, cs, sizeof(cs)) != 0)) {
+ // Do something with cs.
+}
+```
- char cs[1];
- while (TEMP_FAILURE_RETRY(read(STDIN_FILENO, cs, sizeof(cs)) != 0)) {
- // Do something with cs.
- }
-
-Because ``TEMP_FAILURE_RETRY`` will check for whether the result
-*of the comparison* is ``-1``, and retry if so.
+Because `TEMP_FAILURE_RETRY` will check for whether the result
+*of the comparison* is `-1`, and retry if so.
If you encounter this, the fix is simple: lift the comparison out of the
-``TEMP_FAILURE_RETRY`` argument, like so:
-
-.. code-block:: c
-
- char cs[1];
- while (TEMP_FAILURE_RETRY(read(STDIN_FILENO, cs, sizeof(cs))) != 0) {
- // Do something with cs.
- }
+`TEMP_FAILURE_RETRY` argument, like so:
-Options
--------
+```c
+char cs[1];
+while (TEMP_FAILURE_RETRY(read(STDIN_FILENO, cs, sizeof(cs))) != 0) {
+ // Do something with cs.
+}
+```
-.. option:: RetryMacros
+## Options
- A comma-separated list of the names of retry macros to be checked.
- Default is `TEMP_FAILURE_RETRY`.
+```{option} RetryMacros
+A comma-separated list of the names of retry macros to be checked.
+Default is `TEMP_FAILURE_RETRY`.
+```
diff --git a/clang-tools-extra/docs/clang-tidy/checks/boost/use-ranges.md b/clang-tools-extra/docs/clang-tidy/checks/boost/use-ranges.md
index 6cf54347ad613..2fc35aade18e9 100644
--- a/clang-tools-extra/docs/clang-tidy/checks/boost/use-ranges.md
+++ b/clang-tools-extra/docs/clang-tidy/checks/boost/use-ranges.md
@@ -1,187 +1,186 @@
-.. title:: clang-tidy - boost-use-ranges
+```{title} clang-tidy - boost-use-ranges
+```
-boost-use-ranges
-================
+# boost-use-ranges
Detects calls to standard library iterator algorithms that could be replaced
with a Boost ranges version instead.
-Example
--------
-
-.. code-block:: c++
-
- auto Iter1 = std::find(Items.begin(), Items.end(), 0);
- auto AreSame = std::equal(Items1.cbegin(), Items1.cend(), std::begin(Items2),
- std::end(Items2));
+## Example
+```c++
+auto Iter1 = std::find(Items.begin(), Items.end(), 0);
+auto AreSame = std::equal(Items1.cbegin(), Items1.cend(), std::begin(Items2),
+ std::end(Items2));
+```
Transforms to:
-.. code-block:: c++
-
- auto Iter1 = boost::range::find(Items, 0);
- auto AreSame = boost::range::equal(Items1, Items2);
+```c++
+auto Iter1 = boost::range::find(Items, 0);
+auto AreSame = boost::range::equal(Items1, Items2);
+```
-Supported algorithms
---------------------
+## Supported algorithms
Calls to the following std library algorithms are checked:
-``std::accumulate``,
-``std::adjacent_difference``,
-``std::adjacent_find``,
-``std::all_of``,
-``std::any_of``,
-``std::binary_search``,
-``std::copy_backward``,
-``std::copy_if``,
-``std::copy``,
-``std::count_if``,
-``std::count``,
-``std::equal_range``,
-``std::equal``,
-``std::fill``,
-``std::find_end``,
-``std::find_first_of``,
-``std::find_if_not``,
-``std::find_if``,
-``std::find``,
-``std::for_each``,
-``std::generate``,
-``std::includes``,
-``std::iota``,
-``std::is_partitioned``,
-``std::is_permutation``,
-``std::is_sorted_until``,
-``std::is_sorted``,
-``std::lexicographical_compare``,
-``std::lower_bound``,
-``std::make_heap``,
-``std::max_element``,
-``std::merge``,
-``std::min_element``,
-``std::mismatch``,
-``std::next_permutation``,
-``std::none_of``,
-``std::partial_sum``,
-``std::partial_sort_copy``,
-``std::partition_copy``,
-``std::partition_point``,
-``std::partition``,
-``std::pop_heap``,
-``std::prev_permutation``,
-``std::push_heap``,
-``std::random_shuffle``,
-``std::reduce``,
-``std::remove_copy_if``,
-``std::remove_copy``,
-``std::remove_if``,
-``std::remove``,
-``std::replace_copy_if``,
-``std::replace_copy``,
-``std::replace_if``,
-``std::replace``,
-``std::reverse_copy``,
-``std::reverse``,
-``std::search``,
-``std::set_difference``,
-``std::set_intersection``,
-``std::set_symmetric_difference``,
-``std::set_union``,
-``std::sort_heap``,
-``std::sort``,
-``std::stable_partition``,
-``std::stable_sort``,
-``std::transform``,
-``std::unique_copy``,
-``std::unique``,
-``std::upper_bound``.
+`std::accumulate`,
+`std::adjacent_difference`,
+`std::adjacent_find`,
+`std::all_of`,
+`std::any_of`,
+`std::binary_search`,
+`std::copy_backward`,
+`std::copy_if`,
+`std::copy`,
+`std::count_if`,
+`std::count`,
+`std::equal_range`,
+`std::equal`,
+`std::fill`,
+`std::find_end`,
+`std::find_first_of`,
+`std::find_if_not`,
+`std::find_if`,
+`std::find`,
+`std::for_each`,
+`std::generate`,
+`std::includes`,
+`std::iota`,
+`std::is_partitioned`,
+`std::is_permutation`,
+`std::is_sorted_until`,
+`std::is_sorted`,
+`std::lexicographical_compare`,
+`std::lower_bound`,
+`std::make_heap`,
+`std::max_element`,
+`std::merge`,
+`std::min_element`,
+`std::mismatch`,
+`std::next_permutation`,
+`std::none_of`,
+`std::partial_sum`,
+`std::partial_sort_copy`,
+`std::partition_copy`,
+`std::partition_point`,
+`std::partition`,
+`std::pop_heap`,
+`std::prev_permutation`,
+`std::push_heap`,
+`std::random_shuffle`,
+`std::reduce`,
+`std::remove_copy_if`,
+`std::remove_copy`,
+`std::remove_if`,
+`std::remove`,
+`std::replace_copy_if`,
+`std::replace_copy`,
+`std::replace_if`,
+`std::replace`,
+`std::reverse_copy`,
+`std::reverse`,
+`std::search`,
+`std::set_difference`,
+`std::set_intersection`,
+`std::set_symmetric_difference`,
+`std::set_union`,
+`std::sort_heap`,
+`std::sort`,
+`std::stable_partition`,
+`std::stable_sort`,
+`std::transform`,
+`std::unique_copy`,
+`std::unique`,
+`std::upper_bound`.
The check will also look for the following functions from the
-``boost::algorithm`` namespace:
-
-``all_of_equal``,
-``any_of_equal``,
-``any_of``,
-``apply_permutation``,
-``apply_reverse_permutation``,
-``clamp_range``,
-``copy_if_until``,
-``copy_if_while``,
-``copy_if``,
-``copy_until``,
-``copy_while``,
-``find_backward``,
-``find_if_backward``,
-``find_if_not_backward``,
-``find_if_not``,
-``find_not_backward``,
-``hex_lower``,
-``hex``,
-``iota``, ``all_of``,
-``is_decreasing``,
-``is_increasing``,
-``is_palindrome``,
-``is_partitioned_until``,
-``is_partitioned``,
-``is_permutation``,
-``is_sorted_until``,
-``is_sorted``,
-``is_strictly_decreasing``,
-``is_strictly_inc...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/217672
More information about the llvm-branch-commits
mailing list