This is an archive of the discontinued LLVM Phabricator instance.

Differential D127313

[libc++] Implement P0618R0 (Deprecating <codecvt>)
ClosedPublic

Authored by philnik on Jun 8 2022, 8:46 AM.

Details

Reviewers
ldionne
Mordante
var-const
Group Reviewers
Restricted Project
Commits
rG3ee9a50a146c: [libc++] Implement P0618R0 (Deprecating <codecvt>)

Diff Detail

Event Timeline

philnik created this revision.Jun 8 2022, 8:46 AM
Herald added a project: Restricted Project. · View Herald TranscriptJun 8 2022, 8:46 AM
philnik requested review of this revision.Jun 8 2022, 8:46 AM
Herald added a project: Restricted Project. · View Herald TranscriptJun 8 2022, 8:46 AM
Herald added a reviewer: Restricted Project. · View Herald Transcript
Herald added a subscriber: libcxx-commits. · View Herald Transcript
Harbormaster completed remote builds in B168588: Diff 435190.Jun 8 2022, 9:11 AM
philnik retitled this revision from [libc++] Implement P0618R0 (Deprecationg <codecvt>) to [libc++] Implement P0618R0 (Deprecating <codecvt>).Jun 8 2022, 9:42 AM
philnik updated this revision to Diff 435227.Jun 8 2022, 9:57 AM
  • Try to fix CI
Herald added a reviewer: alexander-shaposhnikov. · View Herald TranscriptJun 8 2022, 9:57 AM
Herald added a reviewer: rupprecht. · View Herald Transcript
Herald added a reviewer: jhenderson. · View Herald Transcript
Herald added projects: Restricted Project, Restricted Project, Restricted Project, Restricted Project. · View Herald Transcript
Herald added subscribers: llvm-commits, Restricted Project, cfe-commits and 60 others. · View Herald Transcript
philnik updated this revision to Diff 435230.Jun 8 2022, 10:01 AM

Fix Patch

philnik removed reviewers: alexander-shaposhnikov, rupprecht, jhenderson.Jun 8 2022, 10:03 AM
philnik removed projects: Restricted Project, Restricted Project, Restricted Project, Restricted Project.
philnik removed subscribers: emaste, mgorny, sbc100 and 58 others.
Harbormaster completed remote builds in B168615: Diff 435230.Jun 8 2022, 10:05 AM
ldionne accepted this revision.Jun 10 2022, 8:17 AM

LGTM with changes applied and passing CI.

libcxx/docs/ReleaseNotes.rst
149–152

This should be under API Changes, not ABI Changes

libcxx/include/codecvt
266–267

Here and elsewhere, let's use _LIBCPP_SUPPRESS_DEPRECATED_PUSH and _LIBCPP_SUPPRESS_DEPRECATED_POP instead.

libcxx/src/locale.cpp
1834–1835

_LIBCPP_SUPPRESS_DEPRECATED_PUSH

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/depr.verify.cpp
8

I think you'll need to handle no-localization and no-wide-characters here.

This revision is now accepted and ready to land.Jun 10 2022, 8:17 AM
philnik updated this revision to Diff 436032.Jun 10 2022, 1:39 PM
philnik marked 3 inline comments as done.
  • Address comments
Harbormaster completed remote builds in B169158: Diff 436032.Jun 10 2022, 2:23 PM
philnik updated this revision to Diff 436126.Jun 11 2022, 4:14 AM

Rebased to fix CI

Harbormaster completed remote builds in B169228: Diff 436126.Jun 11 2022, 5:19 AM
philnik updated this revision to Diff 437951.Jun 17 2022, 9:57 AM
  • Try to fix CI
Harbormaster completed remote builds in B170543: Diff 437951.Jun 17 2022, 12:08 PM
philnik updated this revision to Diff 438407.Jun 20 2022, 8:21 AM
  • Try to fix CI
Harbormaster completed remote builds in B170875: Diff 438407.Jun 20 2022, 9:30 AM
philnik updated this revision to Diff 438486.Jun 20 2022, 3:09 PM
  • Try to fix CI
Harbormaster completed remote builds in B170931: Diff 438486.Jun 20 2022, 3:10 PM
philnik updated this revision to Diff 438576.Jun 21 2022, 12:35 AM

Rebased

Harbormaster completed remote builds in B170993: Diff 438576.Jun 21 2022, 1:45 AM
philnik updated this revision to Diff 441353.Jun 30 2022, 4:47 AM
  • Try to fix CI
Harbormaster completed remote builds in B173007: Diff 441353.Jun 30 2022, 5:48 AM
Closed by commit rG3ee9a50a146c: [libc++] Implement P0618R0 (Deprecating <codecvt>) (authored by philnik). · Explain WhyJun 30 2022, 7:48 AM
This revision was automatically updated to reflect the committed changes.
philnik added a commit: rG3ee9a50a146c: [libc++] Implement P0618R0 (Deprecating <codecvt>).

Revision Contents

PathSize
clang/
docs/
5 lines
test/
Driver/
41 lines
compiler-rt/
lib/
asan/
13 lines
4 lines
lsan/
5 lines
orc/
3 lines
sanitizer_common/
3 lines
12 lines
12 lines
59 lines
2 lines
1 line
7 lines
3 lines
2 lines
37 lines
4 lines
2 lines
5 lines
test/
hwasan/
TestCases/
2 lines
msan/
Linux/
15 lines
sanitizer_common/
TestCases/
FreeBSD/
28 lines
Linux/
18 lines
libcxx/
docs/
6 lines
Status/
2 lines
include/
1 line
__algorithm/
78 lines
11 lines
41 lines
4 lines
1 line
src/
7 lines
test/
libcxx/
algorithms/
4 lines
4 lines
localization/
locales/
locale.convenience/
conversions/
conversions.string/
2 lines
1 line
std/
algorithms/
alg.modifying.operations/
alg.transform/
2 lines
alg.nonmodifying/
alg.adjacent.find/
197 lines
library/
description/
conventions/
customization.point.object/
2 lines
localization/
locale.stdcvt/
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
20 lines
locales/
locale.convenience/
conversions/
conversions.buffer/
2 lines
depr.verify.cpp
state.pass.cpp
27 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
conversions.string/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
conversions.string/
conversions.buffer/
depr.verify.cpp
state.pass.cpp
27 lines
llvm/
7 lines
docs/
9 lines
20 lines
2 lines
include/
llvm/
ADT/
9 lines
Support/
14 lines
lib/
Analysis/
2 lines
3 lines
CodeGen/
1 line
SelectionDAG/
19 lines
14 lines
ExecutionEngine/
JITLink/
205 lines
Target/
AArch64/
28 lines
DirectX/
2 lines
Transforms/
Coroutines/
4 lines
IPO/
4 lines
InstCombine/
4 lines
Utils/
1 line
test/
Bitcode/
2 lines
CodeGen/
AArch64/
378 lines
DirectX/
10 lines
RISCV/
117 lines
225 lines
ExecutionEngine/
JITLink/
AArch64/
169 lines
Transforms/
Coroutines/
3 lines
IndVarSimplify/
47 lines
InstCombine/
10 lines
21 lines
tools/
llvm-objcopy/
wasm/
1 line
unittests/
ADT/
1 line
63 lines
utils/
gn/
secondary/
llvm/
unittests/
ADT/
1 line
mlir/
22 lines
include/
mlir/
Dialect/
Bufferization/
Transforms/
3 lines
SCF/
32 lines
lib/
Dialect/
Bufferization/
Transforms/
188 lines
MemRef/
IR/
7 lines
test/
Dialect/
Bufferization/
Transforms/
31 lines
Tensor/
16 lines

Diff 435227

clang/docs/ReleaseNotes.rst

Show First 20 Lines • Show All 347 Lines • ▼ Show 20 Lines
--------------- ---------------
- Add support for MSVC-compatible ``/JMC``/``/JMC-`` flag in clang-cl (supports - Add support for MSVC-compatible ``/JMC``/``/JMC-`` flag in clang-cl (supports
X86/X64/ARM/ARM64). ``/JMC`` could only be used when ``/Zi`` or ``/Z7`` is X86/X64/ARM/ARM64). ``/JMC`` could only be used when ``/Zi`` or ``/Z7`` is
turned on. With this addition, clang-cl can be used in Visual Studio for the turned on. With this addition, clang-cl can be used in Visual Studio for the
JustMyCode feature. Note, you may need to manually add ``/JMC`` as additional JustMyCode feature. Note, you may need to manually add ``/JMC`` as additional
compile options in the Visual Studio since it currently assumes clang-cl does not support ``/JMC``. compile options in the Visual Studio since it currently assumes clang-cl does not support ``/JMC``.
- Implemented generation of SEH unwind information on ARM. (C++ exception
handling in MSVC mode is still unimplemented though.)
- Switched MinGW mode on ARM to use SEH instead of DWARF for unwind information.
AIX Support AIX Support
----------- -----------
- The driver no longer adds ``-mignore-xcoff-visibility`` by default for AIX - The driver no longer adds ``-mignore-xcoff-visibility`` by default for AIX
targets when no other visibility command-line options are in effect, as targets when no other visibility command-line options are in effect, as
ignoring hidden visibility can silently have undesirable side effects (e.g ignoring hidden visibility can silently have undesirable side effects (e.g
when libraries depend on visibility to hide non-ABI facing entities). The when libraries depend on visibility to hide non-ABI facing entities). The
``-mignore-xcoff-visibility`` option can be manually specified on the ``-mignore-xcoff-visibility`` option can be manually specified on the
▲ Show 20 Lines • Show All 209 Lines • Show Last 20 Lines

clang/test/Driver/sanitizer-ld.c

Show All 9 Lines
// CHECK-ASAN-LINUX-NOT: "-lc" // CHECK-ASAN-LINUX-NOT: "-lc"
// CHECK-ASAN-LINUX: libclang_rt.asan-i386.a" // CHECK-ASAN-LINUX: libclang_rt.asan-i386.a"
// CHECK-ASAN-LINUX-NOT: "--export-dynamic" // CHECK-ASAN-LINUX-NOT: "--export-dynamic"
// CHECK-ASAN-LINUX: "--dynamic-list={{.*}}libclang_rt.asan-i386.a.syms" // CHECK-ASAN-LINUX: "--dynamic-list={{.*}}libclang_rt.asan-i386.a.syms"
// CHECK-ASAN-LINUX-NOT: "--export-dynamic" // CHECK-ASAN-LINUX-NOT: "--export-dynamic"
// CHECK-ASAN-LINUX: "-lpthread" // CHECK-ASAN-LINUX: "-lpthread"
// CHECK-ASAN-LINUX: "-lrt" // CHECK-ASAN-LINUX: "-lrt"
// CHECK-ASAN-LINUX: "-ldl" // CHECK-ASAN-LINUX: "-ldl"
// CHECK-ASAN-LINUX: "-lresolv"
// RUN: %clang -fsanitize=address -fno-sanitize-link-runtime -### %s 2>&1 \ // RUN: %clang -fsanitize=address -fno-sanitize-link-runtime -### %s 2>&1 \
// RUN: --target=x86_64-unknown-linux -fuse-ld=ld \ // RUN: --target=x86_64-unknown-linux -fuse-ld=ld \
// RUN: -resource-dir=%S/Inputs/resource_dir \ // RUN: -resource-dir=%S/Inputs/resource_dir \
// RUN: --sysroot=%S/Inputs/basic_linux_tree \ // RUN: --sysroot=%S/Inputs/basic_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-ASAN-NO-LINK-RUNTIME-LINUX %s // RUN: | FileCheck --check-prefix=CHECK-ASAN-NO-LINK-RUNTIME-LINUX %s
// //
// CHECK-ASAN-NO-LINK-RUNTIME-LINUX-NOT: libclang_rt.asan-x86_64 // CHECK-ASAN-NO-LINK-RUNTIME-LINUX-NOT: libclang_rt.asan-x86_64
Show All 38 Lines
// CHECK-SHARED-ASAN-LINUX: "{{(.*[^-.0-9A-Z_a-z])?}}ld{{(.exe)?}}" // CHECK-SHARED-ASAN-LINUX: "{{(.*[^-.0-9A-Z_a-z])?}}ld{{(.exe)?}}"
// CHECK-SHARED-ASAN-LINUX-NOT: "-lc" // CHECK-SHARED-ASAN-LINUX-NOT: "-lc"
// CHECK-SHARED-ASAN-LINUX-NOT: libclang_rt.asan-i386.a" // CHECK-SHARED-ASAN-LINUX-NOT: libclang_rt.asan-i386.a"
// CHECK-SHARED-ASAN-LINUX: libclang_rt.asan-i386.so" // CHECK-SHARED-ASAN-LINUX: libclang_rt.asan-i386.so"
// CHECK-SHARED-ASAN-LINUX: "--whole-archive" "{{.*}}libclang_rt.asan-preinit-i386.a" "--no-whole-archive" // CHECK-SHARED-ASAN-LINUX: "--whole-archive" "{{.*}}libclang_rt.asan-preinit-i386.a" "--no-whole-archive"
// CHECK-SHARED-ASAN-LINUX-NOT: "-lpthread" // CHECK-SHARED-ASAN-LINUX-NOT: "-lpthread"
// CHECK-SHARED-ASAN-LINUX-NOT: "-lrt" // CHECK-SHARED-ASAN-LINUX-NOT: "-lrt"
// CHECK-SHARED-ASAN-LINUX-NOT: "-ldl" // CHECK-SHARED-ASAN-LINUX-NOT: "-ldl"
// CHECK-SHARED-ASAN-LINUX-NOT: "-lresolv"
// CHECK-SHARED-ASAN-LINUX-NOT: "--export-dynamic" // CHECK-SHARED-ASAN-LINUX-NOT: "--export-dynamic"
// CHECK-SHARED-ASAN-LINUX-NOT: "--dynamic-list" // CHECK-SHARED-ASAN-LINUX-NOT: "--dynamic-list"
// RUN: %clang -### %s -o %t.so -shared 2>&1 \ // RUN: %clang -### %s -o %t.so -shared 2>&1 \
// RUN: --target=i386-unknown-linux -fuse-ld=ld -fsanitize=address -shared-libsan \ // RUN: --target=i386-unknown-linux -fuse-ld=ld -fsanitize=address -shared-libsan \
// RUN: -resource-dir=%S/Inputs/resource_dir \ // RUN: -resource-dir=%S/Inputs/resource_dir \
// RUN: --sysroot=%S/Inputs/basic_linux_tree \ // RUN: --sysroot=%S/Inputs/basic_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-DSO-SHARED-ASAN-LINUX %s // RUN: | FileCheck --check-prefix=CHECK-DSO-SHARED-ASAN-LINUX %s
// //
// CHECK-DSO-SHARED-ASAN-LINUX: "{{(.*[^-.0-9A-Z_a-z])?}}ld{{(.exe)?}}" // CHECK-DSO-SHARED-ASAN-LINUX: "{{(.*[^-.0-9A-Z_a-z])?}}ld{{(.exe)?}}"
// CHECK-DSO-SHARED-ASAN-LINUX-NOT: "-lc" // CHECK-DSO-SHARED-ASAN-LINUX-NOT: "-lc"
// CHECK-DSO-SHARED-ASAN-LINUX-NOT: libclang_rt.asan-i386.a" // CHECK-DSO-SHARED-ASAN-LINUX-NOT: libclang_rt.asan-i386.a"
// CHECK-DSO-SHARED-ASAN-LINUX-NOT: "libclang_rt.asan-preinit-i386.a" // CHECK-DSO-SHARED-ASAN-LINUX-NOT: "libclang_rt.asan-preinit-i386.a"
// CHECK-DSO-SHARED-ASAN-LINUX: libclang_rt.asan-i386.so" // CHECK-DSO-SHARED-ASAN-LINUX: libclang_rt.asan-i386.so"
// CHECK-DSO-SHARED-ASAN-LINUX-NOT: "-lpthread" // CHECK-DSO-SHARED-ASAN-LINUX-NOT: "-lpthread"
// CHECK-DSO-SHARED-ASAN-LINUX-NOT: "-lrt" // CHECK-DSO-SHARED-ASAN-LINUX-NOT: "-lrt"
// CHECK-DSO-SHARED-ASAN-LINUX-NOT: "-ldl" // CHECK-DSO-SHARED-ASAN-LINUX-NOT: "-ldl"
// CHECK-DSO-SHARED-ASAN-LINUX-NOT: "-lresolv"
// CHECK-DSO-SHARED-ASAN-LINUX-NOT: "--export-dynamic" // CHECK-DSO-SHARED-ASAN-LINUX-NOT: "--export-dynamic"
// CHECK-DSO-SHARED-ASAN-LINUX-NOT: "--dynamic-list" // CHECK-DSO-SHARED-ASAN-LINUX-NOT: "--dynamic-list"
// RUN: %clang -### %s 2>&1 \ // RUN: %clang -### %s 2>&1 \
// RUN: --target=i386-unknown-freebsd -fuse-ld=ld -fsanitize=address \ // RUN: --target=i386-unknown-freebsd -fuse-ld=ld -fsanitize=address \
// RUN: -resource-dir=%S/Inputs/resource_dir \ // RUN: -resource-dir=%S/Inputs/resource_dir \
// RUN: --sysroot=%S/Inputs/basic_freebsd_tree \ // RUN: --sysroot=%S/Inputs/basic_freebsd_tree \
// RUN: | FileCheck --check-prefix=CHECK-ASAN-FREEBSD %s // RUN: | FileCheck --check-prefix=CHECK-ASAN-FREEBSD %s
// //
// CHECK-ASAN-FREEBSD: "{{(.*[^-.0-9A-Z_a-z])?}}ld{{(.exe)?}}" // CHECK-ASAN-FREEBSD: "{{(.*[^-.0-9A-Z_a-z])?}}ld{{(.exe)?}}"
// CHECK-ASAN-FREEBSD-NOT: "-lc" // CHECK-ASAN-FREEBSD-NOT: "-lc"
// CHECK-ASAN-FREEBSD-NOT: libclang_rt.asan_cxx // CHECK-ASAN-FREEBSD-NOT: libclang_rt.asan_cxx
// CHECK-ASAN-FREEBSD: freebsd{{/|\\+}}libclang_rt.asan-i386.a" // CHECK-ASAN-FREEBSD: freebsd{{/|\\+}}libclang_rt.asan-i386.a"
// CHECK-ASAN-FREEBSD-NOT: libclang_rt.asan_cxx // CHECK-ASAN-FREEBSD-NOT: libclang_rt.asan_cxx
// CHECK-ASAN-FREEBSD-NOT: "--dynamic-list" // CHECK-ASAN-FREEBSD-NOT: "--dynamic-list"
// CHECK-ASAN-FREEBSD: "--export-dynamic" // CHECK-ASAN-FREEBSD: "--export-dynamic"
// CHECK-ASAN-FREEBSD: "-lpthread" // CHECK-ASAN-FREEBSD: "-lpthread"
// CHECK-ASAN-FREEBSD: "-lrt" // CHECK-ASAN-FREEBSD: "-lrt"
// CHECK-ASAN-FREEBSD: "-lresolv"
// RUN: %clang -### %s 2>&1 \ // RUN: %clang -### %s 2>&1 \
// RUN: --target=i386-unknown-freebsd -fuse-ld=ld -fsanitize=address \ // RUN: --target=i386-unknown-freebsd -fuse-ld=ld -fsanitize=address \
// RUN: -resource-dir=%S/Inputs/resource_dir \ // RUN: -resource-dir=%S/Inputs/resource_dir \
// RUN: --sysroot=%S/Inputs/basic_freebsd_tree \ // RUN: --sysroot=%S/Inputs/basic_freebsd_tree \
// RUN: | FileCheck --check-prefix=CHECK-ASAN-FREEBSD-LDL %s // RUN: | FileCheck --check-prefix=CHECK-ASAN-FREEBSD-LDL %s
// //
// CHECK-ASAN-FREEBSD-LDL: "{{(.*[^-.0-9A-Z_a-z])?}}ld{{(.exe)?}}" // CHECK-ASAN-FREEBSD-LDL: "{{(.*[^-.0-9A-Z_a-z])?}}ld{{(.exe)?}}"
Show All 10 Lines
// CHECK-ASAN-LINUX-CXX: "--whole-archive" "{{.*}}libclang_rt.asan-i386.a" "--no-whole-archive" // CHECK-ASAN-LINUX-CXX: "--whole-archive" "{{.*}}libclang_rt.asan-i386.a" "--no-whole-archive"
// CHECK-ASAN-LINUX-CXX: "--whole-archive" "{{.*}}libclang_rt.asan_cxx-i386.a" "--no-whole-archive" // CHECK-ASAN-LINUX-CXX: "--whole-archive" "{{.*}}libclang_rt.asan_cxx-i386.a" "--no-whole-archive"
// CHECK-ASAN-LINUX-CXX-NOT: "--dynamic-list" // CHECK-ASAN-LINUX-CXX-NOT: "--dynamic-list"
// CHECK-ASAN-LINUX-CXX: "--export-dynamic" // CHECK-ASAN-LINUX-CXX: "--export-dynamic"
// CHECK-ASAN-LINUX-CXX: stdc++ // CHECK-ASAN-LINUX-CXX: stdc++
// CHECK-ASAN-LINUX-CXX: "-lpthread" // CHECK-ASAN-LINUX-CXX: "-lpthread"
// CHECK-ASAN-LINUX-CXX: "-lrt" // CHECK-ASAN-LINUX-CXX: "-lrt"
// CHECK-ASAN-LINUX-CXX: "-ldl" // CHECK-ASAN-LINUX-CXX: "-ldl"
// CHECK-ASAN-LINUX-CXX: "-lresolv"
// RUN: %clang -### %s -o /dev/null -fsanitize=address \ // RUN: %clang -### %s -o /dev/null -fsanitize=address \
// RUN: --target=i386-unknown-linux -fuse-ld=ld -stdlib=platform \ // RUN: --target=i386-unknown-linux -fuse-ld=ld -stdlib=platform \
// RUN: -resource-dir=%S/Inputs/resource_dir \ // RUN: -resource-dir=%S/Inputs/resource_dir \
// RUN: --sysroot=%S/Inputs/basic_linux_tree -lstdc++ -static 2>&1 \ // RUN: --sysroot=%S/Inputs/basic_linux_tree -lstdc++ -static 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-ASAN-LINUX-CXX-STATIC %s // RUN: | FileCheck --check-prefix=CHECK-ASAN-LINUX-CXX-STATIC %s
// //
// CHECK-ASAN-LINUX-CXX-STATIC: "{{(.*[^-.0-9A-Z_a-z])?}}ld{{(.exe)?}}" // CHECK-ASAN-LINUX-CXX-STATIC: "{{(.*[^-.0-9A-Z_a-z])?}}ld{{(.exe)?}}"
Show All 23 Lines
// RUN: --target=arm-linux-androideabi -fuse-ld=ld -fsanitize=address \ // RUN: --target=arm-linux-androideabi -fuse-ld=ld -fsanitize=address \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: | FileCheck --check-prefix=CHECK-ASAN-ANDROID %s // RUN: | FileCheck --check-prefix=CHECK-ASAN-ANDROID %s
// //
// CHECK-ASAN-ANDROID: "{{(.*[^.0-9A-Z_a-z])?}}ld{{(.exe)?}}" // CHECK-ASAN-ANDROID: "{{(.*[^.0-9A-Z_a-z])?}}ld{{(.exe)?}}"
// CHECK-ASAN-ANDROID: "-pie" // CHECK-ASAN-ANDROID: "-pie"
// CHECK-ASAN-ANDROID-NOT: "-lc" // CHECK-ASAN-ANDROID-NOT: "-lc"
// CHECK-ASAN-ANDROID-NOT: "-lpthread" // CHECK-ASAN-ANDROID-NOT: "-lpthread"
// CHECK-ASAN-ANDROID-NOT: "-lresolv"
// CHECK-ASAN-ANDROID: libclang_rt.asan-arm-android.so" // CHECK-ASAN-ANDROID: libclang_rt.asan-arm-android.so"
// CHECK-ASAN-ANDROID-NOT: "-lpthread" // CHECK-ASAN-ANDROID-NOT: "-lpthread"
// CHECK-ASAN-ANDROID-NOT: "-lresolv"
// RUN: %clang -### %s 2>&1 \ // RUN: %clang -### %s 2>&1 \
// RUN: --target=arm-linux-androideabi -fuse-ld=ld -fsanitize=address \ // RUN: --target=arm-linux-androideabi -fuse-ld=ld -fsanitize=address \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: -static-libsan \ // RUN: -static-libsan \
// RUN: | FileCheck --check-prefix=CHECK-ASAN-ANDROID-STATICLIBASAN %s // RUN: | FileCheck --check-prefix=CHECK-ASAN-ANDROID-STATICLIBASAN %s
// //
// CHECK-ASAN-ANDROID-STATICLIBASAN: "{{(.*[^.0-9A-Z_a-z])?}}ld{{(.exe)?}}" // CHECK-ASAN-ANDROID-STATICLIBASAN: "{{(.*[^.0-9A-Z_a-z])?}}ld{{(.exe)?}}"
// CHECK-ASAN-ANDROID-STATICLIBASAN: libclang_rt.asan-arm-android.a" // CHECK-ASAN-ANDROID-STATICLIBASAN: libclang_rt.asan-arm-android.a"
// CHECK-ASAN-ANDROID-STATICLIBASAN-NOT: "-lpthread" // CHECK-ASAN-ANDROID-STATICLIBASAN-NOT: "-lpthread"
// CHECK-ASAN-ANDROID-STATICLIBASAN-NOT: "-lrt" // CHECK-ASAN-ANDROID-STATICLIBASAN-NOT: "-lrt"
// CHECK-ASAN-ANDROID-STATICLIBASAN-NOT: "-lresolv"
// RUN: %clang -### %s 2>&1 \ // RUN: %clang -### %s 2>&1 \
// RUN: --target=arm-linux-androideabi -fuse-ld=ld -fsanitize=undefined \ // RUN: --target=arm-linux-androideabi -fuse-ld=ld -fsanitize=undefined \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: | FileCheck --check-prefix=CHECK-UBSAN-ANDROID %s // RUN: | FileCheck --check-prefix=CHECK-UBSAN-ANDROID %s
// //
// CHECK-UBSAN-ANDROID: "{{(.*[^.0-9A-Z_a-z])?}}ld{{(.exe)?}}" // CHECK-UBSAN-ANDROID: "{{(.*[^.0-9A-Z_a-z])?}}ld{{(.exe)?}}"
// CHECK-UBSAN-ANDROID: "-pie" // CHECK-UBSAN-ANDROID: "-pie"
// CHECK-UBSAN-ANDROID-NOT: "-lc" // CHECK-UBSAN-ANDROID-NOT: "-lc"
// CHECK-UBSAN-ANDROID-NOT: "-lpthread" // CHECK-UBSAN-ANDROID-NOT: "-lpthread"
// CHECK-UBSAN-ANDROID-NOT: "-lresolv"
// CHECK-UBSAN-ANDROID: libclang_rt.ubsan_standalone-arm-android.so" // CHECK-UBSAN-ANDROID: libclang_rt.ubsan_standalone-arm-android.so"
// CHECK-UBSAN-ANDROID-NOT: "-lpthread" // CHECK-UBSAN-ANDROID-NOT: "-lpthread"
// CHECK-UBSAN-ANDROID-NOT: "-lresolv"
// RUN: %clang -### %s 2>&1 \ // RUN: %clang -### %s 2>&1 \
// RUN: --target=arm-linux-androideabi -fuse-ld=ld -fsanitize=undefined \ // RUN: --target=arm-linux-androideabi -fuse-ld=ld -fsanitize=undefined \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: -static-libsan \ // RUN: -static-libsan \
// RUN: | FileCheck --check-prefix=CHECK-UBSAN-ANDROID-STATICLIBASAN %s // RUN: | FileCheck --check-prefix=CHECK-UBSAN-ANDROID-STATICLIBASAN %s
// //
// CHECK-UBSAN-ANDROID-STATICLIBASAN: "{{(.*[^.0-9A-Z_a-z])?}}ld{{(.exe)?}}" // CHECK-UBSAN-ANDROID-STATICLIBASAN: "{{(.*[^.0-9A-Z_a-z])?}}ld{{(.exe)?}}"
// CHECK-UBSAN-ANDROID-STATICLIBASAN: libclang_rt.ubsan_standalone-arm-android.a" // CHECK-UBSAN-ANDROID-STATICLIBASAN: libclang_rt.ubsan_standalone-arm-android.a"
// CHECK-UBSAN-ANDROID-STATICLIBASAN-NOT: "-lpthread" // CHECK-UBSAN-ANDROID-STATICLIBASAN-NOT: "-lpthread"
// CHECK-UBSAN-ANDROID-STATICLIBASAN-NOT: "-lrt" // CHECK-UBSAN-ANDROID-STATICLIBASAN-NOT: "-lrt"
// CHECK-UBSAN-ANDROID-STATICLIBASAN-NOT: "-lresolv"
// //
// RUN: %clang -### %s 2>&1 \ // RUN: %clang -### %s 2>&1 \
// RUN: --target=i686-linux-android -fuse-ld=ld -fsanitize=address \ // RUN: --target=i686-linux-android -fuse-ld=ld -fsanitize=address \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: | FileCheck --check-prefix=CHECK-ASAN-ANDROID-X86 %s // RUN: | FileCheck --check-prefix=CHECK-ASAN-ANDROID-X86 %s
// //
// CHECK-ASAN-ANDROID-X86: "{{(.*[^.0-9A-Z_a-z])?}}ld{{(.exe)?}}" // CHECK-ASAN-ANDROID-X86: "{{(.*[^.0-9A-Z_a-z])?}}ld{{(.exe)?}}"
// CHECK-ASAN-ANDROID-X86: "-pie" // CHECK-ASAN-ANDROID-X86: "-pie"
// CHECK-ASAN-ANDROID-X86-NOT: "-lc" // CHECK-ASAN-ANDROID-X86-NOT: "-lc"
// CHECK-ASAN-ANDROID-X86-NOT: "-lpthread" // CHECK-ASAN-ANDROID-X86-NOT: "-lpthread"
// CHECK-ASAN-ANDROID-X86-NOT: "-lresolv"
// CHECK-ASAN-ANDROID-X86: libclang_rt.asan-i686-android.so" // CHECK-ASAN-ANDROID-X86: libclang_rt.asan-i686-android.so"
// CHECK-ASAN-ANDROID-X86-NOT: "-lpthread" // CHECK-ASAN-ANDROID-X86-NOT: "-lpthread"
// CHECK-ASAN-ANDROID-X86-NOT: "-lresolv"
// //
// RUN: %clang -### %s 2>&1 \ // RUN: %clang -### %s 2>&1 \
// RUN: --target=arm-linux-androideabi -fsanitize=address \ // RUN: --target=arm-linux-androideabi -fsanitize=address \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: -shared-libsan \ // RUN: -shared-libsan \
// RUN: | FileCheck --check-prefix=CHECK-ASAN-ANDROID-SHARED-LIBASAN %s // RUN: | FileCheck --check-prefix=CHECK-ASAN-ANDROID-SHARED-LIBASAN %s
// //
// CHECK-ASAN-ANDROID-SHARED-LIBASAN-NOT: argument unused during compilation: '-shared-libsan' // CHECK-ASAN-ANDROID-SHARED-LIBASAN-NOT: argument unused during compilation: '-shared-libsan'
// //
// RUN: %clang -### %s 2>&1 \ // RUN: %clang -### %s 2>&1 \
// RUN: --target=arm-linux-androideabi -fuse-ld=ld -fsanitize=address \ // RUN: --target=arm-linux-androideabi -fuse-ld=ld -fsanitize=address \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: -shared \ // RUN: -shared \
// RUN: | FileCheck --check-prefix=CHECK-ASAN-ANDROID-SHARED %s // RUN: | FileCheck --check-prefix=CHECK-ASAN-ANDROID-SHARED %s
// //
// CHECK-ASAN-ANDROID-SHARED: "{{(.*[^.0-9A-Z_a-z])?}}ld{{(.exe)?}}" // CHECK-ASAN-ANDROID-SHARED: "{{(.*[^.0-9A-Z_a-z])?}}ld{{(.exe)?}}"
// CHECK-ASAN-ANDROID-SHARED-NOT: "-lc" // CHECK-ASAN-ANDROID-SHARED-NOT: "-lc"
// CHECK-ASAN-ANDROID-SHARED: libclang_rt.asan-arm-android.so" // CHECK-ASAN-ANDROID-SHARED: libclang_rt.asan-arm-android.so"
// CHECK-ASAN-ANDROID-SHARED-NOT: "-lpthread" // CHECK-ASAN-ANDROID-SHARED-NOT: "-lpthread"
// CHECK-ASAN-ANDROID-SHARED-NOT: "-lresolv"
// RUN: %clang -### %s 2>&1 \ // RUN: %clang -### %s 2>&1 \
// RUN: --target=sparcel-myriad-rtems-elf -fuse-ld=ld -fsanitize=address \ // RUN: --target=sparcel-myriad-rtems-elf -fuse-ld=ld -fsanitize=address \
// RUN: --sysroot=%S/Inputs/basic_myriad_tree \ // RUN: --sysroot=%S/Inputs/basic_myriad_tree \
// RUN: | FileCheck --check-prefix=CHECK-ASAN-MYRIAD %s // RUN: | FileCheck --check-prefix=CHECK-ASAN-MYRIAD %s
// //
// CHECK-ASAN-MYRIAD: "{{(.*[^.0-9A-Z_a-z])?}}ld{{(.exe)?}}" // CHECK-ASAN-MYRIAD: "{{(.*[^.0-9A-Z_a-z])?}}ld{{(.exe)?}}"
// CHECK-ASAN-MYRIAD-NOT: "-lc" // CHECK-ASAN-MYRIAD-NOT: "-lc"
Show All 12 Lines
// CHECK-TSAN-LINUX-CXX: "--dynamic-list={{.*}}libclang_rt.tsan-x86_64.a.syms" // CHECK-TSAN-LINUX-CXX: "--dynamic-list={{.*}}libclang_rt.tsan-x86_64.a.syms"
// CHECK-TSAN-LINUX-CXX: "--whole-archive" "{{.*}}libclang_rt.tsan_cxx-x86_64.a" "--no-whole-archive" // CHECK-TSAN-LINUX-CXX: "--whole-archive" "{{.*}}libclang_rt.tsan_cxx-x86_64.a" "--no-whole-archive"
// CHECK-TSAN-LINUX-CXX: "--dynamic-list={{.*}}libclang_rt.tsan_cxx-x86_64.a.syms" // CHECK-TSAN-LINUX-CXX: "--dynamic-list={{.*}}libclang_rt.tsan_cxx-x86_64.a.syms"
// CHECK-TSAN-LINUX-CXX-NOT: "--export-dynamic" // CHECK-TSAN-LINUX-CXX-NOT: "--export-dynamic"
// CHECK-TSAN-LINUX-CXX: stdc++ // CHECK-TSAN-LINUX-CXX: stdc++
// CHECK-TSAN-LINUX-CXX: "-lpthread" // CHECK-TSAN-LINUX-CXX: "-lpthread"
// CHECK-TSAN-LINUX-CXX: "-lrt" // CHECK-TSAN-LINUX-CXX: "-lrt"
// CHECK-TSAN-LINUX-CXX: "-ldl" // CHECK-TSAN-LINUX-CXX: "-ldl"
// CHECK-TSAN-LINUX-CXX: "-lresolv"
// RUN: %clang -fsanitize=thread -fno-sanitize-link-runtime -### %s 2>&1 \ // RUN: %clang -fsanitize=thread -fno-sanitize-link-runtime -### %s 2>&1 \
// RUN: --target=x86_64-unknown-linux -fuse-ld=ld \ // RUN: --target=x86_64-unknown-linux -fuse-ld=ld \
// RUN: -resource-dir=%S/Inputs/resource_dir \ // RUN: -resource-dir=%S/Inputs/resource_dir \
// RUN: --sysroot=%S/Inputs/basic_linux_tree \ // RUN: --sysroot=%S/Inputs/basic_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-TSAN-NO-LINK-RUNTIME-LINUX %s // RUN: | FileCheck --check-prefix=CHECK-TSAN-NO-LINK-RUNTIME-LINUX %s
// //
// CHECK-TSAN-NO-LINK-RUNTIME-LINUX-NOT: libclang_rt.tsan // CHECK-TSAN-NO-LINK-RUNTIME-LINUX-NOT: libclang_rt.tsan
Show All 11 Lines
// CHECK-MSAN-LINUX-CXX: "--dynamic-list={{.*}}libclang_rt.msan-x86_64.a.syms" // CHECK-MSAN-LINUX-CXX: "--dynamic-list={{.*}}libclang_rt.msan-x86_64.a.syms"
// CHECK-MSAN-LINUX-CXX: "--whole-archive" "{{.*}}libclang_rt.msan_cxx-x86_64.a" "--no-whole-archive" // CHECK-MSAN-LINUX-CXX: "--whole-archive" "{{.*}}libclang_rt.msan_cxx-x86_64.a" "--no-whole-archive"
// CHECK-MSAN-LINUX-CXX: "--dynamic-list={{.*}}libclang_rt.msan_cxx-x86_64.a.syms" // CHECK-MSAN-LINUX-CXX: "--dynamic-list={{.*}}libclang_rt.msan_cxx-x86_64.a.syms"
// CHECK-MSAN-LINUX-CXX-NOT: "--export-dynamic" // CHECK-MSAN-LINUX-CXX-NOT: "--export-dynamic"
// CHECK-MSAN-LINUX-CXX: stdc++ // CHECK-MSAN-LINUX-CXX: stdc++
// CHECK-MSAN-LINUX-CXX: "-lpthread" // CHECK-MSAN-LINUX-CXX: "-lpthread"
// CHECK-MSAN-LINUX-CXX: "-lrt" // CHECK-MSAN-LINUX-CXX: "-lrt"
// CHECK-MSAN-LINUX-CXX: "-ldl" // CHECK-MSAN-LINUX-CXX: "-ldl"
// CHECK-MSAN-LINUX-CXX: "-lresolv"
// RUN: %clang -fsanitize=memory -fno-sanitize-link-runtime -### %s 2>&1 \ // RUN: %clang -fsanitize=memory -fno-sanitize-link-runtime -### %s 2>&1 \
// RUN: --target=x86_64-unknown-linux -fuse-ld=ld \ // RUN: --target=x86_64-unknown-linux -fuse-ld=ld \
// RUN: -resource-dir=%S/Inputs/resource_dir \ // RUN: -resource-dir=%S/Inputs/resource_dir \
// RUN: --sysroot=%S/Inputs/basic_linux_tree \ // RUN: --sysroot=%S/Inputs/basic_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-MSAN-NO-LINK-RUNTIME-LINUX %s // RUN: | FileCheck --check-prefix=CHECK-MSAN-NO-LINK-RUNTIME-LINUX %s
// //
// CHECK-MSAN-NO-LINK-RUNTIME-LINUX-NOT: libclang_rt.msan // CHECK-MSAN-NO-LINK-RUNTIME-LINUX-NOT: libclang_rt.msan
Show All 20 Lines
// CHECK-UBSAN-LINUX: "{{.*}}ld{{(.exe)?}}" // CHECK-UBSAN-LINUX: "{{.*}}ld{{(.exe)?}}"
// CHECK-UBSAN-LINUX-NOT: libclang_rt.asan // CHECK-UBSAN-LINUX-NOT: libclang_rt.asan
// CHECK-UBSAN-LINUX-NOT: libclang_rt.ubsan_standalone_cxx // CHECK-UBSAN-LINUX-NOT: libclang_rt.ubsan_standalone_cxx
// CHECK-UBSAN-LINUX: "--whole-archive" "{{.*}}libclang_rt.ubsan_standalone-x32.a" "--no-whole-archive" // CHECK-UBSAN-LINUX: "--whole-archive" "{{.*}}libclang_rt.ubsan_standalone-x32.a" "--no-whole-archive"
// CHECK-UBSAN-LINUX-NOT: libclang_rt.asan // CHECK-UBSAN-LINUX-NOT: libclang_rt.asan
// CHECK-UBSAN-LINUX-NOT: libclang_rt.ubsan_standalone_cxx // CHECK-UBSAN-LINUX-NOT: libclang_rt.ubsan_standalone_cxx
// CHECK-UBSAN-LINUX-NOT: "-lstdc++" // CHECK-UBSAN-LINUX-NOT: "-lstdc++"
// CHECK-UBSAN-LINUX: "-lpthread" // CHECK-UBSAN-LINUX: "-lpthread"
// CHECK-UBSAN-LINUX: "-lresolv"
// RUN: %clang -fsanitize=undefined -fno-sanitize-link-runtime -### %s 2>&1 \ // RUN: %clang -fsanitize=undefined -fno-sanitize-link-runtime -### %s 2>&1 \
// RUN: --target=x86_64-unknown-linux -fuse-ld=ld \ // RUN: --target=x86_64-unknown-linux -fuse-ld=ld \
// RUN: -resource-dir=%S/Inputs/resource_dir \ // RUN: -resource-dir=%S/Inputs/resource_dir \
// RUN: --sysroot=%S/Inputs/basic_linux_tree \ // RUN: --sysroot=%S/Inputs/basic_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-UBSAN-NO-LINK-RUNTIME-LINUX %s // RUN: | FileCheck --check-prefix=CHECK-UBSAN-NO-LINK-RUNTIME-LINUX %s
// //
// CHECK-UBSAN-NO-LINK-RUNTIME-LINUX-NOT: libclang_rt.undefined // CHECK-UBSAN-NO-LINK-RUNTIME-LINUX-NOT: libclang_rt.undefined
Show All 40 Lines
// CHECK-UBSAN-LINUX-CXX-NOT: libclang_rt.asan // CHECK-UBSAN-LINUX-CXX-NOT: libclang_rt.asan
// CHECK-UBSAN-LINUX-CXX: "--whole-archive" "{{.*}}libclang_rt.ubsan_standalone-i386.a" "--no-whole-archive" // CHECK-UBSAN-LINUX-CXX: "--whole-archive" "{{.*}}libclang_rt.ubsan_standalone-i386.a" "--no-whole-archive"
// CHECK-UBSAN-LINUX-CXX-NOT: libclang_rt.asan // CHECK-UBSAN-LINUX-CXX-NOT: libclang_rt.asan
// CHECK-UBSAN-LINUX-CXX: "--whole-archive" "{{.*}}libclang_rt.ubsan_standalone_cxx-i386.a" "--no-whole-archive" // CHECK-UBSAN-LINUX-CXX: "--whole-archive" "{{.*}}libclang_rt.ubsan_standalone_cxx-i386.a" "--no-whole-archive"
// CHECK-UBSAN-LINUX-CXX-NOT: libclang_rt.asan // CHECK-UBSAN-LINUX-CXX-NOT: libclang_rt.asan
// CHECK-UBSAN-LINUX-CXX: "-lstdc++" // CHECK-UBSAN-LINUX-CXX: "-lstdc++"
// CHECK-UBSAN-LINUX-CXX-NOT: libclang_rt.asan // CHECK-UBSAN-LINUX-CXX-NOT: libclang_rt.asan
// CHECK-UBSAN-LINUX-CXX: "-lpthread" // CHECK-UBSAN-LINUX-CXX: "-lpthread"
// CHECK-UBSAN-LINUX-CXX: "-lresolv"
// RUN: %clang -fsanitize=undefined -fsanitize-minimal-runtime -### %s 2>&1 \ // RUN: %clang -fsanitize=undefined -fsanitize-minimal-runtime -### %s 2>&1 \
// RUN: --target=i386-unknown-linux -fuse-ld=ld \ // RUN: --target=i386-unknown-linux -fuse-ld=ld \
// RUN: -resource-dir=%S/Inputs/resource_dir \ // RUN: -resource-dir=%S/Inputs/resource_dir \
// RUN: --sysroot=%S/Inputs/basic_linux_tree \ // RUN: --sysroot=%S/Inputs/basic_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-UBSAN-MINIMAL-LINUX %s // RUN: | FileCheck --check-prefix=CHECK-UBSAN-MINIMAL-LINUX %s
// CHECK-UBSAN-MINIMAL-LINUX: "{{.*}}ld{{(.exe)?}}" // CHECK-UBSAN-MINIMAL-LINUX: "{{.*}}ld{{(.exe)?}}"
// CHECK-UBSAN-MINIMAL-LINUX: "--whole-archive" "{{.*}}libclang_rt.ubsan_minimal-i386.a" "--no-whole-archive" // CHECK-UBSAN-MINIMAL-LINUX: "--whole-archive" "{{.*}}libclang_rt.ubsan_minimal-i386.a" "--no-whole-archive"
// CHECK-UBSAN-MINIMAL-LINUX: "-lpthread" // CHECK-UBSAN-MINIMAL-LINUX: "-lpthread"
// CHECK-UBSAN-MINIMAL-LINUX: "-lresolv"
// RUN: %clang -fsanitize=undefined -fsanitize-minimal-runtime -### %s 2>&1 \ // RUN: %clang -fsanitize=undefined -fsanitize-minimal-runtime -### %s 2>&1 \
// RUN: --target=x86_64-apple-darwin -fuse-ld=ld \ // RUN: --target=x86_64-apple-darwin -fuse-ld=ld \
// RUN: --sysroot=%S/Inputs/basic_linux_tree \ // RUN: --sysroot=%S/Inputs/basic_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-UBSAN-MINIMAL-DARWIN %s // RUN: | FileCheck --check-prefix=CHECK-UBSAN-MINIMAL-DARWIN %s
// CHECK-UBSAN-MINIMAL-DARWIN: "{{.*}}ld{{(.exe)?}}" // CHECK-UBSAN-MINIMAL-DARWIN: "{{.*}}ld{{(.exe)?}}"
// CHECK-UBSAN-MINIMAL-DARWIN: "{{.*}}libclang_rt.ubsan_minimal_osx_dynamic.dylib" // CHECK-UBSAN-MINIMAL-DARWIN: "{{.*}}libclang_rt.ubsan_minimal_osx_dynamic.dylib"
Show All 9 Lines
// RUN: -resource-dir=%S/Inputs/resource_dir \ // RUN: -resource-dir=%S/Inputs/resource_dir \
// RUN: --sysroot=%S/Inputs/basic_linux_tree \ // RUN: --sysroot=%S/Inputs/basic_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-ASAN-UBSAN-LINUX %s // RUN: | FileCheck --check-prefix=CHECK-ASAN-UBSAN-LINUX %s
// CHECK-ASAN-UBSAN-LINUX: "{{.*}}ld{{(.exe)?}}" // CHECK-ASAN-UBSAN-LINUX: "{{.*}}ld{{(.exe)?}}"
// CHECK-ASAN-UBSAN-LINUX: "--whole-archive" "{{.*}}libclang_rt.asan-i386.a" "--no-whole-archive" // CHECK-ASAN-UBSAN-LINUX: "--whole-archive" "{{.*}}libclang_rt.asan-i386.a" "--no-whole-archive"
// CHECK-ASAN-UBSAN-LINUX-NOT: libclang_rt.ubsan // CHECK-ASAN-UBSAN-LINUX-NOT: libclang_rt.ubsan
// CHECK-ASAN-UBSAN-LINUX-NOT: "-lstdc++" // CHECK-ASAN-UBSAN-LINUX-NOT: "-lstdc++"
// CHECK-ASAN-UBSAN-LINUX: "-lpthread" // CHECK-ASAN-UBSAN-LINUX: "-lpthread"
// CHECK-ASAN-UBSAN-LINUX: "-lresolv"
// RUN: %clangxx -fsanitize=address,undefined -### %s 2>&1 \ // RUN: %clangxx -fsanitize=address,undefined -### %s 2>&1 \
// RUN: --target=i386-unknown-linux -fuse-ld=ld -stdlib=platform \ // RUN: --target=i386-unknown-linux -fuse-ld=ld -stdlib=platform \
// RUN: -resource-dir=%S/Inputs/resource_dir \ // RUN: -resource-dir=%S/Inputs/resource_dir \
// RUN: --sysroot=%S/Inputs/basic_linux_tree \ // RUN: --sysroot=%S/Inputs/basic_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-ASAN-UBSAN-LINUX-CXX %s // RUN: | FileCheck --check-prefix=CHECK-ASAN-UBSAN-LINUX-CXX %s
// CHECK-ASAN-UBSAN-LINUX-CXX: "{{.*}}ld{{(.exe)?}}" // CHECK-ASAN-UBSAN-LINUX-CXX: "{{.*}}ld{{(.exe)?}}"
// CHECK-ASAN-UBSAN-LINUX-CXX: "--whole-archive" "{{.*}}libclang_rt.asan-i386.a" "--no-whole-archive" // CHECK-ASAN-UBSAN-LINUX-CXX: "--whole-archive" "{{.*}}libclang_rt.asan-i386.a" "--no-whole-archive"
// CHECK-ASAN-UBSAN-LINUX-CXX: "--whole-archive" "{{.*}}libclang_rt.asan_cxx-i386.a" "--no-whole-archive" // CHECK-ASAN-UBSAN-LINUX-CXX: "--whole-archive" "{{.*}}libclang_rt.asan_cxx-i386.a" "--no-whole-archive"
// CHECK-ASAN-UBSAN-LINUX-CXX-NOT: libclang_rt.ubsan // CHECK-ASAN-UBSAN-LINUX-CXX-NOT: libclang_rt.ubsan
// CHECK-ASAN-UBSAN-LINUX-CXX: "-lstdc++" // CHECK-ASAN-UBSAN-LINUX-CXX: "-lstdc++"
// CHECK-ASAN-UBSAN-LINUX-CXX: "-lpthread" // CHECK-ASAN-UBSAN-LINUX-CXX: "-lpthread"
// CHECK-ASAN-UBSAN-LINUX-CXX: "-lresolv"
// RUN: %clangxx -fsanitize=memory,undefined -### %s 2>&1 \ // RUN: %clangxx -fsanitize=memory,undefined -### %s 2>&1 \
// RUN: --target=x86_64-unknown-linux -fuse-ld=ld \ // RUN: --target=x86_64-unknown-linux -fuse-ld=ld \
// RUN: -resource-dir=%S/Inputs/resource_dir \ // RUN: -resource-dir=%S/Inputs/resource_dir \
// RUN: --sysroot=%S/Inputs/basic_linux_tree \ // RUN: --sysroot=%S/Inputs/basic_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-MSAN-UBSAN-LINUX-CXX %s // RUN: | FileCheck --check-prefix=CHECK-MSAN-UBSAN-LINUX-CXX %s
// CHECK-MSAN-UBSAN-LINUX-CXX: "{{.*}}ld{{(.exe)?}}" // CHECK-MSAN-UBSAN-LINUX-CXX: "{{.*}}ld{{(.exe)?}}"
// CHECK-MSAN-UBSAN-LINUX-CXX: "--whole-archive" "{{.*}}libclang_rt.msan-x86_64.a" "--no-whole-archive" // CHECK-MSAN-UBSAN-LINUX-CXX: "--whole-archive" "{{.*}}libclang_rt.msan-x86_64.a" "--no-whole-archive"
Show All 26 Lines
// RUN: | FileCheck --check-prefix=CHECK-LSAN-LINUX %s // RUN: | FileCheck --check-prefix=CHECK-LSAN-LINUX %s
// //
// CHECK-LSAN-LINUX: "{{(.*[^-.0-9A-Z_a-z])?}}ld{{(.exe)?}}" // CHECK-LSAN-LINUX: "{{(.*[^-.0-9A-Z_a-z])?}}ld{{(.exe)?}}"
// CHECK-LSAN-LINUX-NOT: "-lc" // CHECK-LSAN-LINUX-NOT: "-lc"
// CHECK-LSAN-LINUX-NOT: libclang_rt.ubsan // CHECK-LSAN-LINUX-NOT: libclang_rt.ubsan
// CHECK-LSAN-LINUX: libclang_rt.lsan-x86_64.a" // CHECK-LSAN-LINUX: libclang_rt.lsan-x86_64.a"
// CHECK-LSAN-LINUX: "-lpthread" // CHECK-LSAN-LINUX: "-lpthread"
// CHECK-LSAN-LINUX: "-ldl" // CHECK-LSAN-LINUX: "-ldl"
// CHECK-LSAN-LINUX: "-lresolv"
// RUN: %clang -fsanitize=leak -fno-sanitize-link-runtime -### %s 2>&1 \ // RUN: %clang -fsanitize=leak -fno-sanitize-link-runtime -### %s 2>&1 \
// RUN: --target=x86_64-unknown-linux -fuse-ld=ld \ // RUN: --target=x86_64-unknown-linux -fuse-ld=ld \
// RUN: -resource-dir=%S/Inputs/resource_dir \ // RUN: -resource-dir=%S/Inputs/resource_dir \
// RUN: --sysroot=%S/Inputs/basic_linux_tree \ // RUN: --sysroot=%S/Inputs/basic_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-LSAN-NO-LINK-RUNTIME-LINUX %s // RUN: | FileCheck --check-prefix=CHECK-LSAN-NO-LINK-RUNTIME-LINUX %s
// //
// CHECK-LSAN-NO-LINK-RUNTIME-LINUX-NOT: libclang_rt.lsan // CHECK-LSAN-NO-LINK-RUNTIME-LINUX-NOT: libclang_rt.lsan
// RUN: %clang -### %s 2>&1 \ // RUN: %clang -### %s 2>&1 \
// RUN: --target=x86_64-unknown-linux -fuse-ld=ld -fsanitize=leak -fsanitize-coverage=func \ // RUN: --target=x86_64-unknown-linux -fuse-ld=ld -fsanitize=leak -fsanitize-coverage=func \
// RUN: -resource-dir=%S/Inputs/resource_dir \ // RUN: -resource-dir=%S/Inputs/resource_dir \
// RUN: --sysroot=%S/Inputs/basic_linux_tree \ // RUN: --sysroot=%S/Inputs/basic_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-LSAN-COV-LINUX %s // RUN: | FileCheck --check-prefix=CHECK-LSAN-COV-LINUX %s
// //
// CHECK-LSAN-COV-LINUX: "{{(.*[^-.0-9A-Z_a-z])?}}ld{{(.exe)?}}" // CHECK-LSAN-COV-LINUX: "{{(.*[^-.0-9A-Z_a-z])?}}ld{{(.exe)?}}"
// CHECK-LSAN-COV-LINUX-NOT: "-lc" // CHECK-LSAN-COV-LINUX-NOT: "-lc"
// CHECK-LSAN-COV-LINUX-NOT: libclang_rt.ubsan // CHECK-LSAN-COV-LINUX-NOT: libclang_rt.ubsan
// CHECK-LSAV-COV-LINUX: libclang_rt.lsan-x86_64.a" // CHECK-LSAV-COV-LINUX: libclang_rt.lsan-x86_64.a"
// CHECK-LSAN-COV-LINUX-NOT: libclang_rt.ubsan // CHECK-LSAN-COV-LINUX-NOT: libclang_rt.ubsan
// CHECK-LSAN-COV-LINUX: "-lpthread" // CHECK-LSAN-COV-LINUX: "-lpthread"
// CHECK-LSAN-COV-LINUX: "-ldl" // CHECK-LSAN-COV-LINUX: "-ldl"
// CHECK-LSAN-COV-LINUX: "-lresolv"
// RUN: %clang -fsanitize=leak,address -### %s 2>&1 \ // RUN: %clang -fsanitize=leak,address -### %s 2>&1 \
// RUN: --target=x86_64-unknown-linux -fuse-ld=ld \ // RUN: --target=x86_64-unknown-linux -fuse-ld=ld \
// RUN: -resource-dir=%S/Inputs/resource_dir \ // RUN: -resource-dir=%S/Inputs/resource_dir \
// RUN: --sysroot=%S/Inputs/basic_linux_tree \ // RUN: --sysroot=%S/Inputs/basic_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-LSAN-ASAN-LINUX %s // RUN: | FileCheck --check-prefix=CHECK-LSAN-ASAN-LINUX %s
// CHECK-LSAN-ASAN-LINUX: "{{.*}}ld{{(.exe)?}}" // CHECK-LSAN-ASAN-LINUX: "{{.*}}ld{{(.exe)?}}"
// CHECK-LSAN-ASAN-LINUX-NOT: libclang_rt.lsan // CHECK-LSAN-ASAN-LINUX-NOT: libclang_rt.lsan
// CHECK-LSAN-ASAN-LINUX: libclang_rt.asan-x86_64 // CHECK-LSAN-ASAN-LINUX: libclang_rt.asan-x86_64
// CHECK-LSAN-ASAN-LINUX-NOT: libclang_rt.lsan // CHECK-LSAN-ASAN-LINUX-NOT: libclang_rt.lsan
// RUN: %clang -fsanitize=address -fsanitize-coverage=func -### %s 2>&1 \ // RUN: %clang -fsanitize=address -fsanitize-coverage=func -### %s 2>&1 \
// RUN: --target=x86_64-unknown-linux -fuse-ld=ld \ // RUN: --target=x86_64-unknown-linux -fuse-ld=ld \
// RUN: -resource-dir=%S/Inputs/resource_dir \ // RUN: -resource-dir=%S/Inputs/resource_dir \
// RUN: --sysroot=%S/Inputs/basic_linux_tree \ // RUN: --sysroot=%S/Inputs/basic_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-ASAN-COV-LINUX %s // RUN: | FileCheck --check-prefix=CHECK-ASAN-COV-LINUX %s
// CHECK-ASAN-COV-LINUX: "{{.*}}ld{{(.exe)?}}" // CHECK-ASAN-COV-LINUX: "{{.*}}ld{{(.exe)?}}"
// CHECK-ASAN-COV-LINUX: "--whole-archive" "{{.*}}libclang_rt.asan-x86_64.a" "--no-whole-archive" // CHECK-ASAN-COV-LINUX: "--whole-archive" "{{.*}}libclang_rt.asan-x86_64.a" "--no-whole-archive"
// CHECK-ASAN-COV-LINUX-NOT: libclang_rt.ubsan // CHECK-ASAN-COV-LINUX-NOT: libclang_rt.ubsan
// CHECK-ASAN-COV-LINUX-NOT: "-lstdc++" // CHECK-ASAN-COV-LINUX-NOT: "-lstdc++"
// CHECK-ASAN-COV-LINUX: "-lpthread" // CHECK-ASAN-COV-LINUX: "-lpthread"
// CHECK-ASAN-COV-LINUX: "-lresolv"
// RUN: %clang -fsanitize=memory -fsanitize-coverage=func -### %s 2>&1 \ // RUN: %clang -fsanitize=memory -fsanitize-coverage=func -### %s 2>&1 \
// RUN: --target=x86_64-unknown-linux -fuse-ld=ld \ // RUN: --target=x86_64-unknown-linux -fuse-ld=ld \
// RUN: -resource-dir=%S/Inputs/resource_dir \ // RUN: -resource-dir=%S/Inputs/resource_dir \
// RUN: --sysroot=%S/Inputs/basic_linux_tree \ // RUN: --sysroot=%S/Inputs/basic_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-MSAN-COV-LINUX %s // RUN: | FileCheck --check-prefix=CHECK-MSAN-COV-LINUX %s
// CHECK-MSAN-COV-LINUX: "{{.*}}ld{{(.exe)?}}" // CHECK-MSAN-COV-LINUX: "{{.*}}ld{{(.exe)?}}"
// CHECK-MSAN-COV-LINUX: "--whole-archive" "{{.*}}libclang_rt.msan-x86_64.a" "--no-whole-archive" // CHECK-MSAN-COV-LINUX: "--whole-archive" "{{.*}}libclang_rt.msan-x86_64.a" "--no-whole-archive"
// CHECK-MSAN-COV-LINUX-NOT: libclang_rt.ubsan // CHECK-MSAN-COV-LINUX-NOT: libclang_rt.ubsan
// CHECK-MSAN-COV-LINUX-NOT: "-lstdc++" // CHECK-MSAN-COV-LINUX-NOT: "-lstdc++"
// CHECK-MSAN-COV-LINUX: "-lpthread" // CHECK-MSAN-COV-LINUX: "-lpthread"
// CHECK-MSAN-COV-LINUX: "-lresolv"
// RUN: %clang -fsanitize=dataflow -fsanitize-coverage=func -### %s 2>&1 \ // RUN: %clang -fsanitize=dataflow -fsanitize-coverage=func -### %s 2>&1 \
// RUN: --target=x86_64-unknown-linux -fuse-ld=ld \ // RUN: --target=x86_64-unknown-linux -fuse-ld=ld \
// RUN: -resource-dir=%S/Inputs/resource_dir \ // RUN: -resource-dir=%S/Inputs/resource_dir \
// RUN: --sysroot=%S/Inputs/basic_linux_tree \ // RUN: --sysroot=%S/Inputs/basic_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-DFSAN-COV-LINUX %s // RUN: | FileCheck --check-prefix=CHECK-DFSAN-COV-LINUX %s
// CHECK-DFSAN-COV-LINUX: "{{.*}}ld{{(.exe)?}}" // CHECK-DFSAN-COV-LINUX: "{{.*}}ld{{(.exe)?}}"
// CHECK-DFSAN-COV-LINUX: "--whole-archive" "{{.*}}libclang_rt.dfsan-x86_64.a" "--no-whole-archive" // CHECK-DFSAN-COV-LINUX: "--whole-archive" "{{.*}}libclang_rt.dfsan-x86_64.a" "--no-whole-archive"
// CHECK-DFSAN-COV-LINUX-NOT: libclang_rt.ubsan // CHECK-DFSAN-COV-LINUX-NOT: libclang_rt.ubsan
// CHECK-DFSAN-COV-LINUX-NOT: "-lstdc++" // CHECK-DFSAN-COV-LINUX-NOT: "-lstdc++"
// CHECK-DFSAN-COV-LINUX: "-lpthread" // CHECK-DFSAN-COV-LINUX: "-lpthread"
// CHECK-DFSAN-COV-LINUX: "-lresolv"
// RUN: %clang -fsanitize=undefined -fsanitize-coverage=func -### %s 2>&1 \ // RUN: %clang -fsanitize=undefined -fsanitize-coverage=func -### %s 2>&1 \
// RUN: --target=x86_64-unknown-linux -fuse-ld=ld \ // RUN: --target=x86_64-unknown-linux -fuse-ld=ld \
// RUN: -resource-dir=%S/Inputs/resource_dir \ // RUN: -resource-dir=%S/Inputs/resource_dir \
// RUN: --sysroot=%S/Inputs/basic_linux_tree \ // RUN: --sysroot=%S/Inputs/basic_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-UBSAN-COV-LINUX %s // RUN: | FileCheck --check-prefix=CHECK-UBSAN-COV-LINUX %s
// CHECK-UBSAN-COV-LINUX: "{{.*}}ld{{(.exe)?}}" // CHECK-UBSAN-COV-LINUX: "{{.*}}ld{{(.exe)?}}"
// CHECK-UBSAN-COV-LINUX: "--whole-archive" "{{.*}}libclang_rt.ubsan_standalone-x86_64.a" "--no-whole-archive" // CHECK-UBSAN-COV-LINUX: "--whole-archive" "{{.*}}libclang_rt.ubsan_standalone-x86_64.a" "--no-whole-archive"
// CHECK-UBSAN-COV-LINUX-NOT: "-lstdc++" // CHECK-UBSAN-COV-LINUX-NOT: "-lstdc++"
// CHECK-UBSAN-COV-LINUX: "-lpthread" // CHECK-UBSAN-COV-LINUX: "-lpthread"
// CHECK-UBSAN-COV-LINUX: "-lresolv"
// RUN: %clang -fsanitize-coverage=func -### %s 2>&1 \ // RUN: %clang -fsanitize-coverage=func -### %s 2>&1 \
// RUN: --target=x86_64-unknown-linux -fuse-ld=ld \ // RUN: --target=x86_64-unknown-linux -fuse-ld=ld \
// RUN: -resource-dir=%S/Inputs/resource_dir \ // RUN: -resource-dir=%S/Inputs/resource_dir \
// RUN: --sysroot=%S/Inputs/basic_linux_tree \ // RUN: --sysroot=%S/Inputs/basic_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-COV-LINUX %s // RUN: | FileCheck --check-prefix=CHECK-COV-LINUX %s
// CHECK-COV-LINUX: "{{.*}}ld{{(.exe)?}}" // CHECK-COV-LINUX: "{{.*}}ld{{(.exe)?}}"
// CHECK-COV-LINUX: "--whole-archive" "{{.*}}libclang_rt.ubsan_standalone-x86_64.a" "--no-whole-archive" // CHECK-COV-LINUX: "--whole-archive" "{{.*}}libclang_rt.ubsan_standalone-x86_64.a" "--no-whole-archive"
// CHECK-COV-LINUX-NOT: "-lstdc++" // CHECK-COV-LINUX-NOT: "-lstdc++"
// CHECK-COV-LINUX: "-lpthread" // CHECK-COV-LINUX: "-lpthread"
// CHECK-COV-LINUX: "-lresolv"
// CFI by itself does not link runtime libraries. // CFI by itself does not link runtime libraries.
// RUN: %clang -fsanitize=cfi -### %s 2>&1 \ // RUN: %clang -fsanitize=cfi -### %s 2>&1 \
// RUN: --target=x86_64-unknown-linux -fuse-ld=ld -rtlib=platform \ // RUN: --target=x86_64-unknown-linux -fuse-ld=ld -rtlib=platform \
// RUN: -resource-dir=%S/Inputs/resource_dir \ // RUN: -resource-dir=%S/Inputs/resource_dir \
// RUN: --sysroot=%S/Inputs/basic_linux_tree \ // RUN: --sysroot=%S/Inputs/basic_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-CFI-LINUX %s // RUN: | FileCheck --check-prefix=CHECK-CFI-LINUX %s
// CHECK-CFI-LINUX: "{{.*}}ld{{(.exe)?}}" // CHECK-CFI-LINUX: "{{.*}}ld{{(.exe)?}}"
▲ Show 20 Lines • Show All 78 Lines • ▼ Show 20 Lines
// //
// CHECK-SAFESTACK-LINUX: "{{(.*[^-.0-9A-Z_a-z])?}}ld{{(.exe)?}}" // CHECK-SAFESTACK-LINUX: "{{(.*[^-.0-9A-Z_a-z])?}}ld{{(.exe)?}}"
// CHECK-SAFESTACK-LINUX-NOT: "-lc" // CHECK-SAFESTACK-LINUX-NOT: "-lc"
// CHECK-SAFESTACK-LINUX-NOT: whole-archive // CHECK-SAFESTACK-LINUX-NOT: whole-archive
// CHECK-SAFESTACK-LINUX: libclang_rt.safestack-x86_64.a" // CHECK-SAFESTACK-LINUX: libclang_rt.safestack-x86_64.a"
// CHECK-SAFESTACK-LINUX: "-u" "__safestack_init" // CHECK-SAFESTACK-LINUX: "-u" "__safestack_init"
// CHECK-SAFESTACK-LINUX: "-lpthread" // CHECK-SAFESTACK-LINUX: "-lpthread"
// CHECK-SAFESTACK-LINUX: "-ldl" // CHECK-SAFESTACK-LINUX: "-ldl"
// CHECK-SAFESTACK-LINUX: "-lresolv"
// RUN: %clang -fsanitize=shadow-call-stack -### %s 2>&1 \ // RUN: %clang -fsanitize=shadow-call-stack -### %s 2>&1 \
// RUN: --target=x86_64-unknown-linux -fuse-ld=ld \ // RUN: --target=x86_64-unknown-linux -fuse-ld=ld \
// RUN: | FileCheck --check-prefix=CHECK-SHADOWCALLSTACK-LINUX-X86-64 %s // RUN: | FileCheck --check-prefix=CHECK-SHADOWCALLSTACK-LINUX-X86-64 %s
// CHECK-SHADOWCALLSTACK-LINUX-X86-64-NOT: error: // CHECK-SHADOWCALLSTACK-LINUX-X86-64-NOT: error:
// RUN: %clang -fsanitize=shadow-call-stack -### %s 2>&1 \ // RUN: %clang -fsanitize=shadow-call-stack -### %s 2>&1 \
// RUN: --target=aarch64-unknown-linux -fuse-ld=ld \ // RUN: --target=aarch64-unknown-linux -fuse-ld=ld \
▲ Show 20 Lines • Show All 161 Lines • ▼ Show 20 Lines
// RUN: --sysroot=%S/Inputs/basic_linux_tree \ // RUN: --sysroot=%S/Inputs/basic_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-SCUDO-LINUX %s // RUN: | FileCheck --check-prefix=CHECK-SCUDO-LINUX %s
// CHECK-SCUDO-LINUX: "{{.*}}ld{{(.exe)?}}" // CHECK-SCUDO-LINUX: "{{.*}}ld{{(.exe)?}}"
// CHECK-SCUDO-LINUX: "-pie" // CHECK-SCUDO-LINUX: "-pie"
// CHECK-SCUDO-LINUX: "--whole-archive" "{{.*}}libclang_rt.scudo-i386.a" "--no-whole-archive" // CHECK-SCUDO-LINUX: "--whole-archive" "{{.*}}libclang_rt.scudo-i386.a" "--no-whole-archive"
// CHECK-SCUDO-LINUX-NOT: "-lstdc++" // CHECK-SCUDO-LINUX-NOT: "-lstdc++"
// CHECK-SCUDO-LINUX: "-lpthread" // CHECK-SCUDO-LINUX: "-lpthread"
// CHECK-SCUDO-LINUX: "-ldl" // CHECK-SCUDO-LINUX: "-ldl"
// CHECK-SCUDO-LINUX: "-lresolv"
// RUN: %clang -fsanitize=scudo -fsanitize-minimal-runtime -### %s 2>&1 \ // RUN: %clang -fsanitize=scudo -fsanitize-minimal-runtime -### %s 2>&1 \
// RUN: --target=i386-unknown-linux -fuse-ld=ld \ // RUN: --target=i386-unknown-linux -fuse-ld=ld \
// RUN: -resource-dir=%S/Inputs/resource_dir \ // RUN: -resource-dir=%S/Inputs/resource_dir \
// RUN: --sysroot=%S/Inputs/basic_linux_tree \ // RUN: --sysroot=%S/Inputs/basic_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-SCUDO-MINIMAL-LINUX %s // RUN: | FileCheck --check-prefix=CHECK-SCUDO-MINIMAL-LINUX %s
// CHECK-SCUDO-MINIMAL-LINUX: "{{.*}}ld{{(.exe)?}}" // CHECK-SCUDO-MINIMAL-LINUX: "{{.*}}ld{{(.exe)?}}"
// CHECK-SCUDO-MINIMAL-LINUX: "-pie" // CHECK-SCUDO-MINIMAL-LINUX: "-pie"
// CHECK-SCUDO-MINIMAL-LINUX: "--whole-archive" "{{.*}}libclang_rt.scudo_minimal-i386.a" "--no-whole-archive" // CHECK-SCUDO-MINIMAL-LINUX: "--whole-archive" "{{.*}}libclang_rt.scudo_minimal-i386.a" "--no-whole-archive"
// CHECK-SCUDO-MINIMAL-LINUX: "-lpthread" // CHECK-SCUDO-MINIMAL-LINUX: "-lpthread"
// CHECK-SCUDO-MINIMAL-LINUX: "-lresolv"
// RUN: %clang -### %s -o %t.so -shared 2>&1 \ // RUN: %clang -### %s -o %t.so -shared 2>&1 \
// RUN: --target=i386-unknown-linux -fuse-ld=ld -fsanitize=scudo -shared-libsan \ // RUN: --target=i386-unknown-linux -fuse-ld=ld -fsanitize=scudo -shared-libsan \
// RUN: -resource-dir=%S/Inputs/resource_dir \ // RUN: -resource-dir=%S/Inputs/resource_dir \
// RUN: --sysroot=%S/Inputs/basic_linux_tree \ // RUN: --sysroot=%S/Inputs/basic_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-SCUDO-SHARED-LINUX %s // RUN: | FileCheck --check-prefix=CHECK-SCUDO-SHARED-LINUX %s
// //
// CHECK-SCUDO-SHARED-LINUX: "{{(.*[^-.0-9A-Z_a-z])?}}ld{{(.exe)?}}" // CHECK-SCUDO-SHARED-LINUX: "{{(.*[^-.0-9A-Z_a-z])?}}ld{{(.exe)?}}"
// CHECK-SCUDO-SHARED-LINUX-NOT: "-lc" // CHECK-SCUDO-SHARED-LINUX-NOT: "-lc"
// CHECK-SCUDO-SHARED-LINUX-NOT: libclang_rt.scudo-i386.a" // CHECK-SCUDO-SHARED-LINUX-NOT: libclang_rt.scudo-i386.a"
// CHECK-SCUDO-SHARED-LINUX: libclang_rt.scudo-i386.so" // CHECK-SCUDO-SHARED-LINUX: libclang_rt.scudo-i386.so"
// CHECK-SCUDO-SHARED-LINUX-NOT: "-lpthread" // CHECK-SCUDO-SHARED-LINUX-NOT: "-lpthread"
// CHECK-SCUDO-SHARED-LINUX-NOT: "-lrt" // CHECK-SCUDO-SHARED-LINUX-NOT: "-lrt"
// CHECK-SCUDO-SHARED-LINUX-NOT: "-ldl" // CHECK-SCUDO-SHARED-LINUX-NOT: "-ldl"
// CHECK-SCUDO-SHARED-LINUX-NOT: "-lresolv"
// CHECK-SCUDO-SHARED-LINUX-NOT: "--export-dynamic" // CHECK-SCUDO-SHARED-LINUX-NOT: "--export-dynamic"
// CHECK-SCUDO-SHARED-LINUX-NOT: "--dynamic-list" // CHECK-SCUDO-SHARED-LINUX-NOT: "--dynamic-list"
// RUN: %clang -### %s 2>&1 \ // RUN: %clang -### %s 2>&1 \
// RUN: --target=arm-linux-androideabi -fuse-ld=ld -fsanitize=scudo \ // RUN: --target=arm-linux-androideabi -fuse-ld=ld -fsanitize=scudo \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: | FileCheck --check-prefix=CHECK-SCUDO-ANDROID %s // RUN: | FileCheck --check-prefix=CHECK-SCUDO-ANDROID %s
// //
// CHECK-SCUDO-ANDROID: "{{(.*[^.0-9A-Z_a-z])?}}ld{{(.exe)?}}" // CHECK-SCUDO-ANDROID: "{{(.*[^.0-9A-Z_a-z])?}}ld{{(.exe)?}}"
// CHECK-SCUDO-ANDROID-NOT: "-lc" // CHECK-SCUDO-ANDROID-NOT: "-lc"
// CHECK-SCUDO-ANDROID: "-pie" // CHECK-SCUDO-ANDROID: "-pie"
// CHECK-SCUDO-ANDROID-NOT: "-lpthread" // CHECK-SCUDO-ANDROID-NOT: "-lpthread"
// CHECK-SCUDO-ANDROID-NOT: "-lresolv"
// CHECK-SCUDO-ANDROID: libclang_rt.scudo-arm-android.so" // CHECK-SCUDO-ANDROID: libclang_rt.scudo-arm-android.so"
// CHECK-SCUDO-ANDROID-NOT: "-lpthread" // CHECK-SCUDO-ANDROID-NOT: "-lpthread"
// CHECK-SCUDO-ANDROID-NOT: "-lresolv"
// RUN: %clang -### %s 2>&1 \ // RUN: %clang -### %s 2>&1 \
// RUN: --target=arm-linux-androideabi -fuse-ld=ld -fsanitize=scudo \ // RUN: --target=arm-linux-androideabi -fuse-ld=ld -fsanitize=scudo \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: -static-libsan \ // RUN: -static-libsan \
// RUN: | FileCheck --check-prefix=CHECK-SCUDO-ANDROID-STATIC %s // RUN: | FileCheck --check-prefix=CHECK-SCUDO-ANDROID-STATIC %s
// CHECK-SCUDO-ANDROID-STATIC: "{{(.*[^.0-9A-Z_a-z])?}}ld{{(.exe)?}}" // CHECK-SCUDO-ANDROID-STATIC: "{{(.*[^.0-9A-Z_a-z])?}}ld{{(.exe)?}}"
// CHECK-SCUDO-ANDROID-STATIC: "-pie" // CHECK-SCUDO-ANDROID-STATIC: "-pie"
// CHECK-SCUDO-ANDROID-STATIC: "--whole-archive" "{{.*}}libclang_rt.scudo-arm-android.a" "--no-whole-archive" // CHECK-SCUDO-ANDROID-STATIC: "--whole-archive" "{{.*}}libclang_rt.scudo-arm-android.a" "--no-whole-archive"
// CHECK-SCUDO-ANDROID-STATIC-NOT: "-lstdc++" // CHECK-SCUDO-ANDROID-STATIC-NOT: "-lstdc++"
// CHECK-SCUDO-ANDROID-STATIC-NOT: "-lpthread" // CHECK-SCUDO-ANDROID-STATIC-NOT: "-lpthread"
// CHECK-SCUDO-ANDROID-STATIC-NOT: "-lrt" // CHECK-SCUDO-ANDROID-STATIC-NOT: "-lrt"
// CHECK-SCUDO-ANDROID-STATIC-NOT: "-lresolv"
// RUN: %clang -### %s 2>&1 \ // RUN: %clang -### %s 2>&1 \
// RUN: --target=x86_64-unknown-linux -fuse-ld=ld -fsanitize=hwaddress \ // RUN: --target=x86_64-unknown-linux -fuse-ld=ld -fsanitize=hwaddress \
// RUN: -resource-dir=%S/Inputs/resource_dir \ // RUN: -resource-dir=%S/Inputs/resource_dir \
// RUN: --sysroot=%S/Inputs/basic_linux_tree \ // RUN: --sysroot=%S/Inputs/basic_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-HWASAN-X86-64-LINUX %s // RUN: | FileCheck --check-prefix=CHECK-HWASAN-X86-64-LINUX %s
// //
// CHECK-HWASAN-X86-64-LINUX: "{{(.*[^-.0-9A-Z_a-z])?}}ld{{(.exe)?}}" // CHECK-HWASAN-X86-64-LINUX: "{{(.*[^-.0-9A-Z_a-z])?}}ld{{(.exe)?}}"
// CHECK-HWASAN-X86-64-LINUX: "-pie" // CHECK-HWASAN-X86-64-LINUX: "-pie"
// CHECK-HWASAN-X86-64-LINUX-NOT: "-lc" // CHECK-HWASAN-X86-64-LINUX-NOT: "-lc"
// CHECK-HWASAN-X86-64-LINUX: libclang_rt.hwasan-x86_64.a" // CHECK-HWASAN-X86-64-LINUX: libclang_rt.hwasan-x86_64.a"
// CHECK-HWASAN-X86-64-LINUX-NOT: "--export-dynamic" // CHECK-HWASAN-X86-64-LINUX-NOT: "--export-dynamic"
// CHECK-HWASAN-X86-64-LINUX: "--dynamic-list={{.*}}libclang_rt.hwasan-x86_64.a.syms" // CHECK-HWASAN-X86-64-LINUX: "--dynamic-list={{.*}}libclang_rt.hwasan-x86_64.a.syms"
// CHECK-HWASAN-X86-64-LINUX-NOT: "--export-dynamic" // CHECK-HWASAN-X86-64-LINUX-NOT: "--export-dynamic"
// CHECK-HWASAN-X86-64-LINUX: "-lpthread" // CHECK-HWASAN-X86-64-LINUX: "-lpthread"
// CHECK-HWASAN-X86-64-LINUX: "-lrt" // CHECK-HWASAN-X86-64-LINUX: "-lrt"
// CHECK-HWASAN-X86-64-LINUX: "-ldl" // CHECK-HWASAN-X86-64-LINUX: "-ldl"
// CHECK-HWASAN-X86-64-LINUX: "-lresolv"
// RUN: %clang -### %s 2>&1 \ // RUN: %clang -### %s 2>&1 \
// RUN: --target=x86_64-unknown-linux -fuse-ld=ld -fsanitize=hwaddress \ // RUN: --target=x86_64-unknown-linux -fuse-ld=ld -fsanitize=hwaddress \
// RUN: -shared-libsan -resource-dir=%S/Inputs/resource_dir \ // RUN: -shared-libsan -resource-dir=%S/Inputs/resource_dir \
// RUN: --sysroot=%S/Inputs/basic_linux_tree \ // RUN: --sysroot=%S/Inputs/basic_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-SHARED-HWASAN-X86-64-LINUX %s // RUN: | FileCheck --check-prefix=CHECK-SHARED-HWASAN-X86-64-LINUX %s
// //
// CHECK-SHARED-HWASAN-X86-64-LINUX: "{{(.*[^-.0-9A-Z_a-z])?}}ld{{(.exe)?}}" // CHECK-SHARED-HWASAN-X86-64-LINUX: "{{(.*[^-.0-9A-Z_a-z])?}}ld{{(.exe)?}}"
// CHECK-SHARED-HWASAN-X86-64-LINUX: "-pie" // CHECK-SHARED-HWASAN-X86-64-LINUX: "-pie"
// CHECK-SHARED-HWASAN-X86-64-LINUX-NOT: "-lc" // CHECK-SHARED-HWASAN-X86-64-LINUX-NOT: "-lc"
// CHECK-SHARED-HWASAN-X86-64-LINUX: libclang_rt.hwasan-x86_64.so" // CHECK-SHARED-HWASAN-X86-64-LINUX: libclang_rt.hwasan-x86_64.so"
// CHECK-SHARED-HWASAN-X86-64-LINUX-NOT: "-lpthread" // CHECK-SHARED-HWASAN-X86-64-LINUX-NOT: "-lpthread"
// CHECK-SHARED-HWASAN-X86-64-LINUX-NOT: "-lrt" // CHECK-SHARED-HWASAN-X86-64-LINUX-NOT: "-lrt"
// CHECK-SHARED-HWASAN-X86-64-LINUX-NOT: "-ldl" // CHECK-SHARED-HWASAN-X86-64-LINUX-NOT: "-ldl"
// CHECK-SHARED-HWASAN-X86-64-LINUX-NOT: "-lresolv"
// CHECK-SHARED-HWASAN-X86-64-LINUX-NOT: "--export-dynamic" // CHECK-SHARED-HWASAN-X86-64-LINUX-NOT: "--export-dynamic"
// CHECK-SHARED-HWASAN-X86-64-LINUX-NOT: "--dynamic-list" // CHECK-SHARED-HWASAN-X86-64-LINUX-NOT: "--dynamic-list"
// RUN: %clang -### %s -o %t.so -shared 2>&1 \ // RUN: %clang -### %s -o %t.so -shared 2>&1 \
// RUN: --target=x86_64-unknown-linux -fuse-ld=ld -fsanitize=hwaddress \ // RUN: --target=x86_64-unknown-linux -fuse-ld=ld -fsanitize=hwaddress \
// RUN: -shared-libsan -resource-dir=%S/Inputs/resource_dir \ // RUN: -shared-libsan -resource-dir=%S/Inputs/resource_dir \
// RUN: --sysroot=%S/Inputs/basic_linux_tree \ // RUN: --sysroot=%S/Inputs/basic_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-DSO-SHARED-HWASAN-X86-64-LINUX %s // RUN: | FileCheck --check-prefix=CHECK-DSO-SHARED-HWASAN-X86-64-LINUX %s
// //
// CHECK-DSO-SHARED-HWASAN-X86-64-LINUX: "{{(.*[^-.0-9A-Z_a-z])?}}ld{{(.exe)?}}" // CHECK-DSO-SHARED-HWASAN-X86-64-LINUX: "{{(.*[^-.0-9A-Z_a-z])?}}ld{{(.exe)?}}"
// CHECK-DSO_SHARED-HWASAN-X86-64-LINUX: "-pie" // CHECK-DSO_SHARED-HWASAN-X86-64-LINUX: "-pie"
// CHECK-DSO-SHARED-HWASAN-X86-64-LINUX-NOT: "-lc" // CHECK-DSO-SHARED-HWASAN-X86-64-LINUX-NOT: "-lc"
// CHECK-DSO-SHARED-HWASAN-X86-64-LINUX: libclang_rt.hwasan-x86_64.so" // CHECK-DSO-SHARED-HWASAN-X86-64-LINUX: libclang_rt.hwasan-x86_64.so"
// CHECK-DSO-SHARED-HWASAN-X86-64-LINUX-NOT: "-lpthread" // CHECK-DSO-SHARED-HWASAN-X86-64-LINUX-NOT: "-lpthread"
// CHECK-DSO-SHARED-HWASAN-X86-64-LINUX-NOT: "-lrt" // CHECK-DSO-SHARED-HWASAN-X86-64-LINUX-NOT: "-lrt"
// CHECK-DSO-SHARED-HWASAN-X86-64-LINUX-NOT: "-ldl" // CHECK-DSO-SHARED-HWASAN-X86-64-LINUX-NOT: "-ldl"
// CHECK-DSO-SHARED-HWASAN-X86-64-LINUX-NOT: "-lresolv"
// CHECK-DSO-SHARED-HWASAN-X86-64-LINUX-NOT: "--export-dynamic" // CHECK-DSO-SHARED-HWASAN-X86-64-LINUX-NOT: "--export-dynamic"
// CHECK-DSO-SHARED-HWASAN-X86-64-LINUX-NOT: "--dynamic-list" // CHECK-DSO-SHARED-HWASAN-X86-64-LINUX-NOT: "--dynamic-list"
// RUN: %clang -### %s 2>&1 \ // RUN: %clang -### %s 2>&1 \
// RUN: --target=aarch64-unknown-linux -fuse-ld=ld -fsanitize=hwaddress \ // RUN: --target=aarch64-unknown-linux -fuse-ld=ld -fsanitize=hwaddress \
// RUN: -resource-dir=%S/Inputs/resource_dir \ // RUN: -resource-dir=%S/Inputs/resource_dir \
// RUN: --sysroot=%S/Inputs/basic_linux_tree \ // RUN: --sysroot=%S/Inputs/basic_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-HWASAN-AARCH64-LINUX %s // RUN: | FileCheck --check-prefix=CHECK-HWASAN-AARCH64-LINUX %s
// //
// CHECK-HWASAN-AARCH64-LINUX: "{{(.*[^-.0-9A-Z_a-z])?}}ld{{(.exe)?}}" // CHECK-HWASAN-AARCH64-LINUX: "{{(.*[^-.0-9A-Z_a-z])?}}ld{{(.exe)?}}"
// CHECK-HWASAN-AARCH64-LINUX: "-pie" // CHECK-HWASAN-AARCH64-LINUX: "-pie"
// CHECK-HWASAN-AARCH64-LINUX-NOT: "-lc" // CHECK-HWASAN-AARCH64-LINUX-NOT: "-lc"
// CHECK-HWASAN-AARCH64-LINUX: libclang_rt.hwasan-aarch64.a" // CHECK-HWASAN-AARCH64-LINUX: libclang_rt.hwasan-aarch64.a"
// CHECK-HWASAN-AARCH64-LINUX-NOT: "--export-dynamic" // CHECK-HWASAN-AARCH64-LINUX-NOT: "--export-dynamic"
// CHECK-HWASAN-AARCH64-LINUX: "--dynamic-list={{.*}}libclang_rt.hwasan-aarch64.a.syms" // CHECK-HWASAN-AARCH64-LINUX: "--dynamic-list={{.*}}libclang_rt.hwasan-aarch64.a.syms"
// CHECK-HWASAN-AARCH64-LINUX-NOT: "--export-dynamic" // CHECK-HWASAN-AARCH64-LINUX-NOT: "--export-dynamic"
// CHECK-HWASAN-AARCH64-LINUX: "-lpthread" // CHECK-HWASAN-AARCH64-LINUX: "-lpthread"
// CHECK-HWASAN-AARCH64-LINUX: "-lrt" // CHECK-HWASAN-AARCH64-LINUX: "-lrt"
// CHECK-HWASAN-AARCH64-LINUX: "-ldl" // CHECK-HWASAN-AARCH64-LINUX: "-ldl"
// CHECK-HWASAN-AARCH64-LINUX: "-lresolv"
// RUN: %clang -### %s 2>&1 \ // RUN: %clang -### %s 2>&1 \
// RUN: --target=aarch64-unknown-linux -fuse-ld=ld -fsanitize=hwaddress \ // RUN: --target=aarch64-unknown-linux -fuse-ld=ld -fsanitize=hwaddress \
// RUN: -shared-libsan \ // RUN: -shared-libsan \
// RUN: -resource-dir=%S/Inputs/resource_dir \ // RUN: -resource-dir=%S/Inputs/resource_dir \
// RUN: --sysroot=%S/Inputs/basic_linux_tree \ // RUN: --sysroot=%S/Inputs/basic_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-SHARED-HWASAN-AARCH64-LINUX %s // RUN: | FileCheck --check-prefix=CHECK-SHARED-HWASAN-AARCH64-LINUX %s
// //
// CHECK-SHARED-HWASAN-AARCH64-LINUX: "{{(.*[^-.0-9A-Z_a-z])?}}ld{{(.exe)?}}" // CHECK-SHARED-HWASAN-AARCH64-LINUX: "{{(.*[^-.0-9A-Z_a-z])?}}ld{{(.exe)?}}"
// CHECK-SHARED-HWASAN-AARCH64-LINUX: "-pie" // CHECK-SHARED-HWASAN-AARCH64-LINUX: "-pie"
// CHECK-SHARED-HWASAN-AARCH64-LINUX-NOT: "-lc" // CHECK-SHARED-HWASAN-AARCH64-LINUX-NOT: "-lc"
// CHECK-SHARED-HWASAN-AARCH64-LINUX: libclang_rt.hwasan-aarch64.so" // CHECK-SHARED-HWASAN-AARCH64-LINUX: libclang_rt.hwasan-aarch64.so"
// CHECK-SHARED-HWASAN-AARCH64-LINUX-NOT: "-lpthread" // CHECK-SHARED-HWASAN-AARCH64-LINUX-NOT: "-lpthread"
// CHECK-SHARED-HWASAN-AARCH64-LINUX-NOT: "-lrt" // CHECK-SHARED-HWASAN-AARCH64-LINUX-NOT: "-lrt"
// CHECK-SHARED-HWASAN-AARCH64-LINUX-NOT: "-ldl" // CHECK-SHARED-HWASAN-AARCH64-LINUX-NOT: "-ldl"
// CHECK-SHARED-HWASAN-AARCH64-LINUX-NOT: "-lresolv"
// CHECK-SHARED-HWASAN-AARCH64-LINUX-NOT: "--export-dynamic" // CHECK-SHARED-HWASAN-AARCH64-LINUX-NOT: "--export-dynamic"
// CHECK-SHARED-HWASAN-AARCH64-LINUX-NOT: "--dynamic-list" // CHECK-SHARED-HWASAN-AARCH64-LINUX-NOT: "--dynamic-list"
// RUN: %clang -### %s -o %t.so -shared 2>&1 \ // RUN: %clang -### %s -o %t.so -shared 2>&1 \
// RUN: --target=aarch64-unknown-linux -fuse-ld=ld -fsanitize=hwaddress \ // RUN: --target=aarch64-unknown-linux -fuse-ld=ld -fsanitize=hwaddress \
// RUN: -shared-libsan -resource-dir=%S/Inputs/resource_dir \ // RUN: -shared-libsan -resource-dir=%S/Inputs/resource_dir \
// RUN: --sysroot=%S/Inputs/basic_linux_tree \ // RUN: --sysroot=%S/Inputs/basic_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-DSO-SHARED-HWASAN-AARCH64-LINUX %s // RUN: | FileCheck --check-prefix=CHECK-DSO-SHARED-HWASAN-AARCH64-LINUX %s
// //
// CHECK-DSO-SHARED-HWASAN-AARCH64-LINUX: "{{(.*[^-.0-9A-Z_a-z])?}}ld{{(.exe)?}}" // CHECK-DSO-SHARED-HWASAN-AARCH64-LINUX: "{{(.*[^-.0-9A-Z_a-z])?}}ld{{(.exe)?}}"
// CHECK-DSO_SHARED-HWASAN-AARCH64-LINUX: "-pie" // CHECK-DSO_SHARED-HWASAN-AARCH64-LINUX: "-pie"
// CHECK-DSO-SHARED-HWASAN-AARCH64-LINUX-NOT: "-lc" // CHECK-DSO-SHARED-HWASAN-AARCH64-LINUX-NOT: "-lc"
// CHECK-DSO-SHARED-HWASAN-AARCH64-LINUX: libclang_rt.hwasan-aarch64.so" // CHECK-DSO-SHARED-HWASAN-AARCH64-LINUX: libclang_rt.hwasan-aarch64.so"
// CHECK-DSO-SHARED-HWASAN-AARCH64-LINUX-NOT: "-lpthread" // CHECK-DSO-SHARED-HWASAN-AARCH64-LINUX-NOT: "-lpthread"
// CHECK-DSO-SHARED-HWASAN-AARCH64-LINUX-NOT: "-lrt" // CHECK-DSO-SHARED-HWASAN-AARCH64-LINUX-NOT: "-lrt"
// CHECK-DSO-SHARED-HWASAN-AARCH64-LINUX-NOT: "-ldl" // CHECK-DSO-SHARED-HWASAN-AARCH64-LINUX-NOT: "-ldl"
// CHECK-DSO-SHARED-HWASAN-AARCH64-LINUX-NOT: "-lresolv"
// CHECK-DSO-SHARED-HWASAN-AARCH64-LINUX-NOT: "--export-dynamic" // CHECK-DSO-SHARED-HWASAN-AARCH64-LINUX-NOT: "--export-dynamic"
// CHECK-DSO-SHARED-HWASAN-AARCH64-LINUX-NOT: "--dynamic-list" // CHECK-DSO-SHARED-HWASAN-AARCH64-LINUX-NOT: "--dynamic-list"

compiler-rt/lib/asan/asan_allocator.h

Show All 11 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef ASAN_ALLOCATOR_H #ifndef ASAN_ALLOCATOR_H
#define ASAN_ALLOCATOR_H #define ASAN_ALLOCATOR_H
#include "asan_flags.h" #include "asan_flags.h"
#include "asan_interceptors.h" #include "asan_interceptors.h"
#include "asan_internal.h" #include "asan_internal.h"
#include "lsan/lsan_allocator.h"
#include "sanitizer_common/sanitizer_allocator.h" #include "sanitizer_common/sanitizer_allocator.h"
#include "sanitizer_common/sanitizer_list.h" #include "sanitizer_common/sanitizer_list.h"
#include "sanitizer_common/sanitizer_platform.h" #include "sanitizer_common/sanitizer_platform.h"
namespace __asan { namespace __asan {
enum AllocType { enum AllocType {
FROM_MALLOC = 1, // Memory block came from malloc, calloc, realloc, etc. FROM_MALLOC = 1, // Memory block came from malloc, calloc, realloc, etc.
▲ Show 20 Lines • Show All 85 Lines • ▼ Show 20 Lines
}; };
struct AsanMapUnmapCallback { struct AsanMapUnmapCallback {
void OnMap(uptr p, uptr size) const; void OnMap(uptr p, uptr size) const;
void OnUnmap(uptr p, uptr size) const; void OnUnmap(uptr p, uptr size) const;
}; };
#if SANITIZER_CAN_USE_ALLOCATOR64 #if SANITIZER_CAN_USE_ALLOCATOR64
# if SANITIZER_FUCHSIA # if defined(__powerpc64__)
const uptr kAllocatorSpace = ~(uptr)0;
const uptr kAllocatorSize = 0x40000000000ULL; // 4T.
typedef DefaultSizeClassMap SizeClassMap;
# elif defined(__powerpc64__)
const uptr kAllocatorSpace = ~(uptr)0; const uptr kAllocatorSpace = ~(uptr)0;
// NOTE: This differs slightly from the LSan allocator size which is 4T.
const uptr kAllocatorSize = 0x20000000000ULL; // 2T. const uptr kAllocatorSize = 0x20000000000ULL; // 2T.
typedef DefaultSizeClassMap SizeClassMap; typedef DefaultSizeClassMap SizeClassMap;
# elif defined(__aarch64__) && SANITIZER_ANDROID # elif defined(__aarch64__) && SANITIZER_ANDROID
// Android needs to support 39, 42 and 48 bit VMA. // Android needs to support 39, 42 and 48 bit VMA.
const uptr kAllocatorSpace = ~(uptr)0; const uptr kAllocatorSpace = ~(uptr)0;
const uptr kAllocatorSize = 0x2000000000ULL; // 128G. const uptr kAllocatorSize = 0x2000000000ULL; // 128G.
typedef VeryCompactSizeClassMap SizeClassMap; typedef VeryCompactSizeClassMap SizeClassMap;
#elif SANITIZER_RISCV64 #elif SANITIZER_RISCV64
Show All 10 Lines
const uptr kAllocatorSpace = ~(uptr)0; const uptr kAllocatorSpace = ~(uptr)0;
const uptr kAllocatorSize = 0x20000000000ULL; // 2T. const uptr kAllocatorSize = 0x20000000000ULL; // 2T.
typedef DefaultSizeClassMap SizeClassMap; typedef DefaultSizeClassMap SizeClassMap;
# elif SANITIZER_WINDOWS # elif SANITIZER_WINDOWS
const uptr kAllocatorSpace = ~(uptr)0; const uptr kAllocatorSpace = ~(uptr)0;
const uptr kAllocatorSize = 0x8000000000ULL; // 500G const uptr kAllocatorSize = 0x8000000000ULL; // 500G
typedef DefaultSizeClassMap SizeClassMap; typedef DefaultSizeClassMap SizeClassMap;
# else # else
const uptr kAllocatorSpace = 0x600000000000ULL; // Use LSan's allocator configs.
const uptr kAllocatorSize = 0x40000000000ULL; // 4T. const uptr kAllocatorSpace = __lsan::kAllocatorSpace;
const uptr kAllocatorSize = __lsan::kAllocatorSize;
typedef DefaultSizeClassMap SizeClassMap; typedef DefaultSizeClassMap SizeClassMap;
# endif # endif
template <typename AddressSpaceViewTy> template <typename AddressSpaceViewTy>
struct AP64 { // Allocator64 parameters. Deliberately using a short name. struct AP64 { // Allocator64 parameters. Deliberately using a short name.
static const uptr kSpaceBeg = kAllocatorSpace; static const uptr kSpaceBeg = kAllocatorSpace;
static const uptr kSpaceSize = kAllocatorSize; static const uptr kSpaceSize = kAllocatorSize;
static const uptr kMetadataSize = 0; static const uptr kMetadataSize = 0;
typedef __asan::SizeClassMap SizeClassMap; typedef __asan::SizeClassMap SizeClassMap;
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

compiler-rt/lib/asan/asan_errors.cpp

Show First 20 Lines • Show All 273 Lines • ▼ Show 20 Linesvoid ErrorRssLimitExceeded::Print() {
stack->Print(); stack->Print();
PrintHintAllocatorCannotReturnNull(); PrintHintAllocatorCannotReturnNull();
ReportErrorSummary(scariness.GetDescription(), stack); ReportErrorSummary(scariness.GetDescription(), stack);
} }
void ErrorOutOfMemory::Print() { void ErrorOutOfMemory::Print() {
Decorator d; Decorator d;
Printf("%s", d.Error()); Printf("%s", d.Error());
Report( ERROR_OOM("allocator is trying to allocate 0x%zx bytes\n", requested_size);
"ERROR: AddressSanitizer: allocator is out of memory trying to allocate "
"0x%zx bytes\n", requested_size);
Printf("%s", d.Default()); Printf("%s", d.Default());
stack->Print(); stack->Print();
PrintHintAllocatorCannotReturnNull(); PrintHintAllocatorCannotReturnNull();
ReportErrorSummary(scariness.GetDescription(), stack); ReportErrorSummary(scariness.GetDescription(), stack);
} }
void ErrorStringFunctionMemoryRangesOverlap::Print() { void ErrorStringFunctionMemoryRangesOverlap::Print() {
Decorator d; Decorator d;
▲ Show 20 Lines • Show All 309 Lines • Show Last 20 Lines

compiler-rt/lib/lsan/lsan_allocator.h

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Lines#if SANITIZER_WORDSIZE == 64
uptr requested_size : 54; uptr requested_size : 54;
#else #else
uptr requested_size : 32; uptr requested_size : 32;
uptr padding : 22; uptr padding : 22;
#endif #endif
u32 stack_trace_id; u32 stack_trace_id;
}; };
#if defined(__mips64) || defined(__aarch64__) || defined(__i386__) || \ #if !SANITIZER_CAN_USE_ALLOCATOR64
defined(__arm__) || SANITIZER_RISCV64 || defined(__hexagon__)
template <typename AddressSpaceViewTy> template <typename AddressSpaceViewTy>
struct AP32 { struct AP32 {
static const uptr kSpaceBeg = 0; static const uptr kSpaceBeg = 0;
static const u64 kSpaceSize = SANITIZER_MMAP_RANGE_SIZE; static const u64 kSpaceSize = SANITIZER_MMAP_RANGE_SIZE;
static const uptr kMetadataSize = sizeof(ChunkMetadata); static const uptr kMetadataSize = sizeof(ChunkMetadata);
typedef __sanitizer::CompactSizeClassMap SizeClassMap; typedef __sanitizer::CompactSizeClassMap SizeClassMap;
static const uptr kRegionSizeLog = 20; static const uptr kRegionSizeLog = 20;
using AddressSpaceView = AddressSpaceViewTy; using AddressSpaceView = AddressSpaceViewTy;
typedef NoOpMapUnmapCallback MapUnmapCallback; typedef NoOpMapUnmapCallback MapUnmapCallback;
static const uptr kFlags = 0; static const uptr kFlags = 0;
}; };
template <typename AddressSpaceView> template <typename AddressSpaceView>
using PrimaryAllocatorASVT = SizeClassAllocator32<AP32<AddressSpaceView>>; using PrimaryAllocatorASVT = SizeClassAllocator32<AP32<AddressSpaceView>>;
using PrimaryAllocator = PrimaryAllocatorASVT<LocalAddressSpaceView>; using PrimaryAllocator = PrimaryAllocatorASVT<LocalAddressSpaceView>;
#elif defined(__x86_64__) || defined(__powerpc64__) || defined(__s390x__) #else
# if SANITIZER_FUCHSIA || defined(__powerpc64__) # if SANITIZER_FUCHSIA || defined(__powerpc64__)
const uptr kAllocatorSpace = ~(uptr)0; const uptr kAllocatorSpace = ~(uptr)0;
const uptr kAllocatorSize = 0x40000000000ULL; // 4T. const uptr kAllocatorSize = 0x40000000000ULL; // 4T.
#elif defined(__s390x__) #elif defined(__s390x__)
const uptr kAllocatorSpace = 0x40000000000ULL; const uptr kAllocatorSpace = 0x40000000000ULL;
const uptr kAllocatorSize = 0x40000000000ULL; // 4T. const uptr kAllocatorSize = 0x40000000000ULL; // 4T.
# else # else
const uptr kAllocatorSpace = 0x600000000000ULL; const uptr kAllocatorSpace = 0x600000000000ULL;
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

compiler-rt/lib/orc/c_api.h

/*===- c_api.h - C API for the ORC runtime ------------------------*- C -*-===*\ /*===- c_api.h - C API for the ORC runtime ------------------------*- C -*-===*\
|* *| |* *|
|* Part of the LLVM Project, under the Apache License v2.0 with LLVM *| |* Part of the LLVM Project, under the Apache License v2.0 with LLVM *|
|* Exceptions. *| |* 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 defines the C API for the ORC runtime *| |* This file defines the C API for the ORC runtime *|
|* *| |* *|
|* NOTE: The OrtRTWrapperFunctionResult type must be kept in sync with the *|
|* definition in llvm/include/llvm-c/OrcShared.h. *|
|* *|
\*===----------------------------------------------------------------------===*/ \*===----------------------------------------------------------------------===*/
#ifndef ORC_RT_C_API_H #ifndef ORC_RT_C_API_H
#define ORC_RT_C_API_H #define ORC_RT_C_API_H
#include <assert.h> #include <assert.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
▲ Show 20 Lines • Show All 186 Lines • Show Last 20 Lines

compiler-rt/lib/sanitizer_common/sanitizer_allocator_report.cpp

Show First 20 Lines • Show All 122 Lines • ▼ Show 20 Lines Report("ERROR: %s: requested allocation size 0x%zx exceeds maximum "
"supported size of 0x%zx\n", SanitizerToolName, user_size, max_size); "supported size of 0x%zx\n", SanitizerToolName, user_size, max_size);
} }
Die(); Die();
} }
void NORETURN ReportOutOfMemory(uptr requested_size, const StackTrace *stack) { void NORETURN ReportOutOfMemory(uptr requested_size, const StackTrace *stack) {
{ {
ScopedAllocatorErrorReport report("out-of-memory", stack); ScopedAllocatorErrorReport report("out-of-memory", stack);
Report("ERROR: %s: allocator is out of memory trying to allocate 0x%zx " ERROR_OOM("allocator is trying to allocate 0x%zx bytes\n", requested_size);
"bytes\n", SanitizerToolName, requested_size);
} }
Die(); Die();
} }
void NORETURN ReportRssLimitExceeded(const StackTrace *stack) { void NORETURN ReportRssLimitExceeded(const StackTrace *stack) {
{ {
ScopedAllocatorErrorReport report("rss-limit-exceeded", stack); ScopedAllocatorErrorReport report("rss-limit-exceeded", stack);
Report("ERROR: %s: allocator exceeded the RSS limit\n", SanitizerToolName); Report("ERROR: %s: allocator exceeded the RSS limit\n", SanitizerToolName);
} }
Die(); Die();
} }
} // namespace __sanitizer } // namespace __sanitizer

compiler-rt/lib/sanitizer_common/sanitizer_common.h

Show First 20 Lines • Show All 305 Lines • ▼ Show 20 Lines
void NORETURN Abort(); void NORETURN Abort();
void NORETURN Die(); void NORETURN Die();
void NORETURN void NORETURN
CheckFailed(const char *file, int line, const char *cond, u64 v1, u64 v2); CheckFailed(const char *file, int line, const char *cond, u64 v1, u64 v2);
void NORETURN ReportMmapFailureAndDie(uptr size, const char *mem_type, void NORETURN ReportMmapFailureAndDie(uptr size, const char *mem_type,
const char *mmap_type, error_t err, const char *mmap_type, error_t err,
bool raw_report = false); bool raw_report = false);
// Returns true if the platform-specific error reported is an OOM error.
bool ErrorIsOOM(error_t err);
// This reports an error in the form:
//
// `ERROR: {{SanitizerToolName}}: out of memory: {{err_msg}}`
//
// Downstream tools that read sanitizer output will know that errors starting
// in this format are specifically OOM errors.
#define ERROR_OOM(err_msg, ...) \
Report("ERROR: %s: out of memory: " err_msg, SanitizerToolName, __VA_ARGS__)
// Specific tools may override behavior of "Die" function to do tool-specific // Specific tools may override behavior of "Die" function to do tool-specific
// job. // job.
typedef void (*DieCallbackType)(void); typedef void (*DieCallbackType)(void);
// It's possible to add several callbacks that would be run when "Die" is // It's possible to add several callbacks that would be run when "Die" is
// called. The callbacks will be run in the opposite order. The tools are // called. The callbacks will be run in the opposite order. The tools are
// strongly recommended to setup all callbacks during initialization, when there // strongly recommended to setup all callbacks during initialization, when there
// is only a single thread. // is only a single thread.
▲ Show 20 Lines • Show All 760 Lines • Show Last 20 Lines

compiler-rt/lib/sanitizer_common/sanitizer_common.cpp

Show All 40 Linesvoid NORETURN ReportMmapFailureAndDie(uptr size, const char *mem_type,
static int recursion_count; static int recursion_count;
if (raw_report || recursion_count) { if (raw_report || recursion_count) {
// If raw report is requested or we went into recursion just die. The // If raw report is requested or we went into recursion just die. The
// Report() and CHECK calls below may call mmap recursively and fail. // Report() and CHECK calls below may call mmap recursively and fail.
RawWrite("ERROR: Failed to mmap\n"); RawWrite("ERROR: Failed to mmap\n");
Die(); Die();
} }
recursion_count++; recursion_count++;
Report("ERROR: %s failed to " if (ErrorIsOOM(err)) {
ERROR_OOM("failed to %s 0x%zx (%zd) bytes of %s (error code: %d)\n",
mmap_type, size, size, mem_type, err);
} else {
Report(
"ERROR: %s failed to "
"%s 0x%zx (%zd) bytes of %s (error code: %d)\n", "%s 0x%zx (%zd) bytes of %s (error code: %d)\n",
SanitizerToolName, mmap_type, size, size, mem_type, err); SanitizerToolName, mmap_type, size, size, mem_type, err);
}
#if !SANITIZER_GO #if !SANITIZER_GO
DumpProcessMap(); DumpProcessMap();
#endif #endif
UNREACHABLE("unable to mmap"); UNREACHABLE("unable to mmap");
} }
typedef bool UptrComparisonFunction(const uptr &a, const uptr &b); typedef bool UptrComparisonFunction(const uptr &a, const uptr &b);
typedef bool U32ComparisonFunction(const u32 &a, const u32 &b); typedef bool U32ComparisonFunction(const u32 &a, const u32 &b);
▲ Show 20 Lines • Show All 336 Lines • Show Last 20 Lines

compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors.inc

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 4,957 Lines • ▼ Show 20 Lines
} }
#define INIT_PTHREAD_ATTR_GETAFFINITY_NP \ #define INIT_PTHREAD_ATTR_GETAFFINITY_NP \
COMMON_INTERCEPT_FUNCTION(pthread_attr_getaffinity_np); COMMON_INTERCEPT_FUNCTION(pthread_attr_getaffinity_np);
#else #else
#define INIT_PTHREAD_ATTR_GETAFFINITY_NP #define INIT_PTHREAD_ATTR_GETAFFINITY_NP
#endif #endif
#if SANITIZER_INTERCEPT_PTHREAD_GETAFFINITY_NP
INTERCEPTOR(int, pthread_getaffinity_np, void *attr, SIZE_T cpusetsize,
void *cpuset) {
void *ctx;
COMMON_INTERCEPTOR_ENTER(ctx, pthread_getaffinity_np, attr, cpusetsize,
cpuset);
// FIXME: under ASan the call below may write to freed memory and corrupt
// its metadata. See
// https://github.com/google/sanitizers/issues/321.
int res = REAL(pthread_getaffinity_np)(attr, cpusetsize, cpuset);
if (!res && cpusetsize && cpuset)
COMMON_INTERCEPTOR_WRITE_RANGE(ctx, cpuset, cpusetsize);
return res;
}
#define INIT_PTHREAD_GETAFFINITY_NP \
COMMON_INTERCEPT_FUNCTION(pthread_getaffinity_np);
#else
#define INIT_PTHREAD_GETAFFINITY_NP
#endif
#if SANITIZER_INTERCEPT_PTHREAD_MUTEXATTR_GETPSHARED #if SANITIZER_INTERCEPT_PTHREAD_MUTEXATTR_GETPSHARED
INTERCEPTOR_PTHREAD_MUTEXATTR_GET(pshared, sizeof(int)) INTERCEPTOR_PTHREAD_MUTEXATTR_GET(pshared, sizeof(int))
#define INIT_PTHREAD_MUTEXATTR_GETPSHARED \ #define INIT_PTHREAD_MUTEXATTR_GETPSHARED \
COMMON_INTERCEPT_FUNCTION(pthread_mutexattr_getpshared); COMMON_INTERCEPT_FUNCTION(pthread_mutexattr_getpshared);
#else #else
#define INIT_PTHREAD_MUTEXATTR_GETPSHARED #define INIT_PTHREAD_MUTEXATTR_GETPSHARED
#endif #endif
▲ Show 20 Lines • Show All 5,349 Lines • ▼ Show 20 LinesINTERCEPTOR(int, sigaltstack, void *ss, void *oss) {
} }
return r; return r;
} }
#define INIT_SIGALTSTACK COMMON_INTERCEPT_FUNCTION(sigaltstack) #define INIT_SIGALTSTACK COMMON_INTERCEPT_FUNCTION(sigaltstack)
#else #else
#define INIT_SIGALTSTACK #define INIT_SIGALTSTACK
#endif #endif
#if SANITIZER_INTERCEPT_PROCCTL
INTERCEPTOR(int, procctl, int idtype, u64 id, int cmd, uptr data) {
void *ctx;
COMMON_INTERCEPTOR_ENTER(ctx, procctl, idtype, id, cmd, data);
static const int PROC_REAP_ACQUIRE = 2;
static const int PROC_REAP_RELEASE = 3;
static const int PROC_REAP_STATUS = 4;
static const int PROC_REAP_GETPIDS = 5;
static const int PROC_REAP_KILL = 6;
if (cmd < PROC_REAP_ACQUIRE || cmd > PROC_REAP_KILL) {
COMMON_INTERCEPTOR_READ_RANGE(ctx, (void *)data, sizeof(int));
} else {
// reap_acquire/reap_release bears no arguments.
if (cmd > PROC_REAP_RELEASE) {
unsigned int reapsz;
switch (cmd) {
case PROC_REAP_STATUS:
reapsz = struct_procctl_reaper_status_sz;
break;
case PROC_REAP_GETPIDS:
reapsz = struct_procctl_reaper_pids_sz;
break;
case PROC_REAP_KILL:
reapsz = struct_procctl_reaper_kill_sz;
break;
}
COMMON_INTERCEPTOR_READ_RANGE(ctx, (void *)data, reapsz);
}
}
return REAL(procctl)(idtype, id, cmd, data);
}
#define INIT_PROCCTL COMMON_INTERCEPT_FUNCTION(procctl)
#else
#define INIT_PROCCTL
#endif
#if SANITIZER_INTERCEPT_UNAME #if SANITIZER_INTERCEPT_UNAME
INTERCEPTOR(int, uname, struct utsname *utsname) { INTERCEPTOR(int, uname, struct utsname *utsname) {
#if SANITIZER_LINUX #if SANITIZER_LINUX
if (COMMON_INTERCEPTOR_NOTHING_IS_INITIALIZED) if (COMMON_INTERCEPTOR_NOTHING_IS_INITIALIZED)
return internal_uname(utsname); return internal_uname(utsname);
#endif #endif
void *ctx; void *ctx;
COMMON_INTERCEPTOR_ENTER(ctx, uname, utsname); COMMON_INTERCEPTOR_ENTER(ctx, uname, utsname);
▲ Show 20 Lines • Show All 191 Lines • ▼ Show 20 Lines#endif
INIT_ETHER_HOST; INIT_ETHER_HOST;
INIT_ETHER_R; INIT_ETHER_R;
INIT_SHMCTL; INIT_SHMCTL;
INIT_RANDOM_R; INIT_RANDOM_R;
INIT_PTHREAD_ATTR_GET; INIT_PTHREAD_ATTR_GET;
INIT_PTHREAD_ATTR_GET_SCHED; INIT_PTHREAD_ATTR_GET_SCHED;
INIT_PTHREAD_ATTR_GETINHERITSCHED; INIT_PTHREAD_ATTR_GETINHERITSCHED;
INIT_PTHREAD_ATTR_GETAFFINITY_NP; INIT_PTHREAD_ATTR_GETAFFINITY_NP;
INIT_PTHREAD_GETAFFINITY_NP;
INIT_PTHREAD_MUTEXATTR_GETPSHARED; INIT_PTHREAD_MUTEXATTR_GETPSHARED;
INIT_PTHREAD_MUTEXATTR_GETTYPE; INIT_PTHREAD_MUTEXATTR_GETTYPE;
INIT_PTHREAD_MUTEXATTR_GETPROTOCOL; INIT_PTHREAD_MUTEXATTR_GETPROTOCOL;
INIT_PTHREAD_MUTEXATTR_GETPRIOCEILING; INIT_PTHREAD_MUTEXATTR_GETPRIOCEILING;
INIT_PTHREAD_MUTEXATTR_GETROBUST; INIT_PTHREAD_MUTEXATTR_GETROBUST;
INIT_PTHREAD_MUTEXATTR_GETROBUST_NP; INIT_PTHREAD_MUTEXATTR_GETROBUST_NP;
INIT_PTHREAD_RWLOCKATTR_GETPSHARED; INIT_PTHREAD_RWLOCKATTR_GETPSHARED;
INIT_PTHREAD_RWLOCKATTR_GETKIND_NP; INIT_PTHREAD_RWLOCKATTR_GETKIND_NP;
▲ Show 20 Lines • Show All 135 Lines • ▼ Show 20 Lines#endif
INIT_GETRANDOM; INIT_GETRANDOM;
INIT_CRYPT; INIT_CRYPT;
INIT_CRYPT_R; INIT_CRYPT_R;
INIT_GETENTROPY; INIT_GETENTROPY;
INIT_QSORT; INIT_QSORT;
INIT_QSORT_R; INIT_QSORT_R;
INIT_BSEARCH; INIT_BSEARCH;
INIT_SIGALTSTACK; INIT_SIGALTSTACK;
INIT_PROCCTL
INIT_UNAME; INIT_UNAME;
INIT___XUNAME; INIT___XUNAME;
INIT___PRINTF_CHK; INIT___PRINTF_CHK;
} }

compiler-rt/lib/sanitizer_common/sanitizer_fuchsia.cpp

Show First 20 Lines • Show All 122 Lines • ▼ Show 20 Lines
uptr GetMaxUserVirtualAddress() { uptr GetMaxUserVirtualAddress() {
InitShadowBounds(); InitShadowBounds();
return ShadowBounds.memory_limit - 1; return ShadowBounds.memory_limit - 1;
} }
uptr GetMaxVirtualAddress() { return GetMaxUserVirtualAddress(); } uptr GetMaxVirtualAddress() { return GetMaxUserVirtualAddress(); }
bool ErrorIsOOM(error_t err) { return err == ZX_ERR_NO_MEMORY; }
static void *DoAnonymousMmapOrDie(uptr size, const char *mem_type, static void *DoAnonymousMmapOrDie(uptr size, const char *mem_type,
bool raw_report, bool die_for_nomem) { bool raw_report, bool die_for_nomem) {
size = RoundUpTo(size, GetPageSize()); size = RoundUpTo(size, GetPageSize());
zx_handle_t vmo; zx_handle_t vmo;
zx_status_t status = _zx_vmo_create(size, 0, &vmo); zx_status_t status = _zx_vmo_create(size, 0, &vmo);
if (status != ZX_OK) { if (status != ZX_OK) {
if (status != ZX_ERR_NO_MEMORY || die_for_nomem) if (status != ZX_ERR_NO_MEMORY || die_for_nomem)
▲ Show 20 Lines • Show All 362 Lines • Show Last 20 Lines

compiler-rt/lib/sanitizer_common/sanitizer_linux.h

Show First 20 Lines • Show All 76 Lines • ▼ Show 20 Lines
#if defined(__x86_64__) || defined(__mips__) || defined(__aarch64__) || \ #if defined(__x86_64__) || defined(__mips__) || defined(__aarch64__) || \
defined(__powerpc64__) || defined(__s390__) || defined(__i386__) || \ defined(__powerpc64__) || defined(__s390__) || defined(__i386__) || \
defined(__arm__) || SANITIZER_RISCV64 defined(__arm__) || SANITIZER_RISCV64
uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg, uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg,
int *parent_tidptr, void *newtls, int *child_tidptr); int *parent_tidptr, void *newtls, int *child_tidptr);
#endif #endif
int internal_uname(struct utsname *buf); int internal_uname(struct utsname *buf);
#elif SANITIZER_FREEBSD #elif SANITIZER_FREEBSD
uptr internal_procctl(int type, int id, int cmd, void *data);
void internal_sigdelset(__sanitizer_sigset_t *set, int signum); void internal_sigdelset(__sanitizer_sigset_t *set, int signum);
#elif SANITIZER_NETBSD #elif SANITIZER_NETBSD
void internal_sigdelset(__sanitizer_sigset_t *set, int signum); void internal_sigdelset(__sanitizer_sigset_t *set, int signum);
uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg); uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg);
#endif // SANITIZER_LINUX #endif // SANITIZER_LINUX
// This class reads thread IDs from /proc/<pid>/task using only syscalls. // This class reads thread IDs from /proc/<pid>/task using only syscalls.
class ThreadLister { class ThreadLister {
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

compiler-rt/lib/sanitizer_common/sanitizer_linux.cpp

Show First 20 Lines • Show All 895 Lines • ▼ Show 20 Linesbool internal_sigismember(__sanitizer_sigset_t *set, int signum) {
CHECK_GE(signum, 0); CHECK_GE(signum, 0);
CHECK_LT(signum, sizeof(*set) * 8); CHECK_LT(signum, sizeof(*set) * 8);
__sanitizer_kernel_sigset_t *k_set = (__sanitizer_kernel_sigset_t *)set; __sanitizer_kernel_sigset_t *k_set = (__sanitizer_kernel_sigset_t *)set;
const uptr idx = signum / (sizeof(k_set->sig[0]) * 8); const uptr idx = signum / (sizeof(k_set->sig[0]) * 8);
const uptr bit = signum % (sizeof(k_set->sig[0]) * 8); const uptr bit = signum % (sizeof(k_set->sig[0]) * 8);
return k_set->sig[idx] & ((uptr)1 << bit); return k_set->sig[idx] & ((uptr)1 << bit);
} }
#elif SANITIZER_FREEBSD #elif SANITIZER_FREEBSD
uptr internal_procctl(int type, int id, int cmd, void *data) {
return internal_syscall(SYSCALL(procctl), type, id, cmd, data);
}
void internal_sigdelset(__sanitizer_sigset_t *set, int signum) { void internal_sigdelset(__sanitizer_sigset_t *set, int signum) {
sigset_t *rset = reinterpret_cast<sigset_t *>(set); sigset_t *rset = reinterpret_cast<sigset_t *>(set);
sigdelset(rset, signum); sigdelset(rset, signum);
} }
bool internal_sigismember(__sanitizer_sigset_t *set, int signum) { bool internal_sigismember(__sanitizer_sigset_t *set, int signum) {
sigset_t *rset = reinterpret_cast<sigset_t *>(set); sigset_t *rset = reinterpret_cast<sigset_t *>(set);
return sigismember(rset, signum); return sigismember(rset, signum);
▲ Show 20 Lines • Show All 1,269 Lines • ▼ Show 20 Lines#if SANITIZER_NETBSD
if (UNLIKELY(paxflags & CTL_PROC_PAXFLAGS_ASLR)) { if (UNLIKELY(paxflags & CTL_PROC_PAXFLAGS_ASLR)) {
Printf("This sanitizer is not compatible with enabled ASLR.\n" Printf("This sanitizer is not compatible with enabled ASLR.\n"
"To disable ASLR, please run \"paxctl +a %s\" and try again.\n", "To disable ASLR, please run \"paxctl +a %s\" and try again.\n",
GetArgv()[0]); GetArgv()[0]);
Die(); Die();
} }
#elif SANITIZER_FREEBSD #elif SANITIZER_FREEBSD
int aslr_status; int aslr_status;
if (UNLIKELY(procctl(P_PID, 0, PROC_ASLR_STATUS, &aslr_status) == -1)) { int r = internal_procctl(P_PID, 0, PROC_ASLR_STATUS, &aslr_status);
if (UNLIKELY(r == -1)) {
// We're making things less 'dramatic' here since // We're making things less 'dramatic' here since
// the cmd is not necessarily guaranteed to be here // the cmd is not necessarily guaranteed to be here
// just yet regarding FreeBSD release // just yet regarding FreeBSD release
return; return;
} }
if ((aslr_status & PROC_ASLR_ACTIVE) != 0) { if ((aslr_status & PROC_ASLR_ACTIVE) != 0) {
Printf("This sanitizer is not compatible with enabled ASLR " Printf("This sanitizer is not compatible with enabled ASLR "
"and binaries compiled with PIE\n"); "and binaries compiled with PIE\n");
▲ Show 20 Lines • Show All 105 Lines • Show Last 20 Lines

compiler-rt/lib/sanitizer_common/sanitizer_platform.h

Show First 20 Lines • Show All 279 Lines • ▼ Show 20 Lines
// By default we allow to use SizeClassAllocator64 on 64-bit platform. // By default we allow to use SizeClassAllocator64 on 64-bit platform.
// But in some cases (e.g. AArch64's 39-bit address space) SizeClassAllocator64 // But in some cases (e.g. AArch64's 39-bit address space) SizeClassAllocator64
// does not work well and we need to fallback to SizeClassAllocator32. // does not work well and we need to fallback to SizeClassAllocator32.
// For such platforms build this code with -DSANITIZER_CAN_USE_ALLOCATOR64=0 or // For such platforms build this code with -DSANITIZER_CAN_USE_ALLOCATOR64=0 or
// change the definition of SANITIZER_CAN_USE_ALLOCATOR64 here. // change the definition of SANITIZER_CAN_USE_ALLOCATOR64 here.
#ifndef SANITIZER_CAN_USE_ALLOCATOR64 #ifndef SANITIZER_CAN_USE_ALLOCATOR64
# if (SANITIZER_ANDROID && defined(__aarch64__)) || SANITIZER_FUCHSIA # if (SANITIZER_ANDROID && defined(__aarch64__)) || SANITIZER_FUCHSIA
# define SANITIZER_CAN_USE_ALLOCATOR64 1 # define SANITIZER_CAN_USE_ALLOCATOR64 1
# elif defined(__mips64) || defined(__aarch64__) # elif defined(__mips64) || defined(__aarch64__) || defined(__i386__) || \
defined(__arm__) || SANITIZER_RISCV64 || defined(__hexagon__)
# define SANITIZER_CAN_USE_ALLOCATOR64 0 # define SANITIZER_CAN_USE_ALLOCATOR64 0
# else # else
# define SANITIZER_CAN_USE_ALLOCATOR64 (SANITIZER_WORDSIZE == 64) # define SANITIZER_CAN_USE_ALLOCATOR64 (SANITIZER_WORDSIZE == 64)
# endif # endif
#endif #endif
// The range of addresses which can be returned my mmap. // The range of addresses which can be returned my mmap.
// FIXME: this value should be different on different platforms. Larger values // FIXME: this value should be different on different platforms. Larger values
▲ Show 20 Lines • Show All 151 Lines • Show Last 20 Lines

compiler-rt/lib/sanitizer_common/sanitizer_platform_interceptors.h

Show First 20 Lines • Show All 342 Lines • ▼ Show 20 Lines
#define SANITIZER_INTERCEPT_SHMCTL \ #define SANITIZER_INTERCEPT_SHMCTL \
(((SI_FREEBSD || SI_LINUX_NOT_ANDROID) && SANITIZER_WORDSIZE == 64) || \ (((SI_FREEBSD || SI_LINUX_NOT_ANDROID) && SANITIZER_WORDSIZE == 64) || \
SI_NETBSD || SI_SOLARIS) SI_NETBSD || SI_SOLARIS)
#define SANITIZER_INTERCEPT_RANDOM_R SI_GLIBC #define SANITIZER_INTERCEPT_RANDOM_R SI_GLIBC
#define SANITIZER_INTERCEPT_PTHREAD_ATTR_GET SI_POSIX #define SANITIZER_INTERCEPT_PTHREAD_ATTR_GET SI_POSIX
#define SANITIZER_INTERCEPT_PTHREAD_ATTR_GETINHERITSCHED \ #define SANITIZER_INTERCEPT_PTHREAD_ATTR_GETINHERITSCHED \
(SI_FREEBSD || SI_NETBSD || SI_MAC || SI_LINUX_NOT_ANDROID || SI_SOLARIS) (SI_FREEBSD || SI_NETBSD || SI_MAC || SI_LINUX_NOT_ANDROID || SI_SOLARIS)
#define SANITIZER_INTERCEPT_PTHREAD_ATTR_GETAFFINITY_NP SI_GLIBC #define SANITIZER_INTERCEPT_PTHREAD_ATTR_GETAFFINITY_NP SI_GLIBC
#define SANITIZER_INTERCEPT_PTHREAD_GETAFFINITY_NP SI_LINUX_NOT_ANDROID
#define SANITIZER_INTERCEPT_PTHREAD_ATTR_GET_SCHED SI_POSIX #define SANITIZER_INTERCEPT_PTHREAD_ATTR_GET_SCHED SI_POSIX
#define SANITIZER_INTERCEPT_PTHREAD_MUTEXATTR_GETPSHARED \ #define SANITIZER_INTERCEPT_PTHREAD_MUTEXATTR_GETPSHARED \
(SI_POSIX && !SI_NETBSD) (SI_POSIX && !SI_NETBSD)
#define SANITIZER_INTERCEPT_PTHREAD_MUTEXATTR_GETTYPE SI_POSIX #define SANITIZER_INTERCEPT_PTHREAD_MUTEXATTR_GETTYPE SI_POSIX
#define SANITIZER_INTERCEPT_PTHREAD_MUTEXATTR_GETPROTOCOL \ #define SANITIZER_INTERCEPT_PTHREAD_MUTEXATTR_GETPROTOCOL \
(SI_MAC || SI_NETBSD || SI_LINUX_NOT_ANDROID || SI_SOLARIS) (SI_MAC || SI_NETBSD || SI_LINUX_NOT_ANDROID || SI_SOLARIS)
#define SANITIZER_INTERCEPT_PTHREAD_MUTEXATTR_GETPRIOCEILING \ #define SANITIZER_INTERCEPT_PTHREAD_MUTEXATTR_GETPRIOCEILING \
(SI_MAC || SI_NETBSD || SI_LINUX_NOT_ANDROID || SI_SOLARIS) (SI_MAC || SI_NETBSD || SI_LINUX_NOT_ANDROID || SI_SOLARIS)
▲ Show 20 Lines • Show All 228 Lines • ▼ Show 20 Lines#define SANITIZER_INTERCEPT_BSEARCH \
(SI_POSIX && !SI_IOSSIM && !SI_WATCHOS && !SI_TVOS && !SI_ANDROID) (SI_POSIX && !SI_IOSSIM && !SI_WATCHOS && !SI_TVOS && !SI_ANDROID)
// sigaltstack on i386 macOS cannot be intercepted due to setjmp() // sigaltstack on i386 macOS cannot be intercepted due to setjmp()
// calling it and assuming that it does not clobber registers. // calling it and assuming that it does not clobber registers.
#define SANITIZER_INTERCEPT_SIGALTSTACK \ #define SANITIZER_INTERCEPT_SIGALTSTACK \
(SI_POSIX && !(SANITIZER_APPLE && SANITIZER_I386)) (SI_POSIX && !(SANITIZER_APPLE && SANITIZER_I386))
#define SANITIZER_INTERCEPT_UNAME (SI_POSIX && !SI_FREEBSD) #define SANITIZER_INTERCEPT_UNAME (SI_POSIX && !SI_FREEBSD)
#define SANITIZER_INTERCEPT___XUNAME SI_FREEBSD #define SANITIZER_INTERCEPT___XUNAME SI_FREEBSD
#define SANITIZER_INTERCEPT_FLOPEN SI_FREEBSD #define SANITIZER_INTERCEPT_FLOPEN SI_FREEBSD
#define SANITIZER_INTERCEPT_PROCCTL SI_FREEBSD
// This macro gives a way for downstream users to override the above // This macro gives a way for downstream users to override the above
// interceptor macros irrespective of the platform they are on. They have // interceptor macros irrespective of the platform they are on. They have
// to do two things: // to do two things:
// 1. Build compiler-rt with -DSANITIZER_OVERRIDE_INTERCEPTORS. // 1. Build compiler-rt with -DSANITIZER_OVERRIDE_INTERCEPTORS.
// 2. Provide a header file named sanitizer_intercept_overriders.h in the // 2. Provide a header file named sanitizer_intercept_overriders.h in the
// include path for their compiler-rt build. // include path for their compiler-rt build.
// An example of an overrider for strlen interceptor that one can list in // An example of an overrider for strlen interceptor that one can list in
Show All 15 Lines

compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_freebsd.h

Show First 20 Lines • Show All 418 Lines • ▼ Show 20 Linesstruct __sanitizer__ttyent {
char *ty_getty; char *ty_getty;
char *ty_type; char *ty_type;
int ty_status; int ty_status;
char *ty_window; char *ty_window;
char *ty_comment; char *ty_comment;
char *ty_group; char *ty_group;
}; };
// procctl reaper data for PROCCTL_REAPER flags
struct __sanitizer_procctl_reaper_status {
unsigned int rs_flags;
unsigned int rs_children;
unsigned int rs_descendants;
pid_t rs_reaper;
pid_t rs_pid;
unsigned int rs_pad0[15];
};
struct __sanitizer_procctl_reaper_pidinfo {
pid_t pi_pid;
pid_t pi_subtree;
unsigned int pi_flags;
unsigned int pi_pad0[15];
};
struct __sanitizer_procctl_reaper_pids {
unsigned int rp_count;
unsigned int rp_pad0[15];
struct __sanitize_procctl_reapper_pidinfo *rp_pids;
};
struct __sanitizer_procctl_reaper_kill {
int rk_sig;
unsigned int rk_flags;
pid_t rk_subtree;
unsigned int rk_killed;
pid_t rk_fpid;
unsigned int rk_pad[15];
};
# define IOC_NRBITS 8 # define IOC_NRBITS 8
# define IOC_TYPEBITS 8 # define IOC_TYPEBITS 8
# if defined(__powerpc__) || defined(__powerpc64__) || defined(__mips__) # if defined(__powerpc__) || defined(__powerpc64__) || defined(__mips__)
# define IOC_SIZEBITS 13 # define IOC_SIZEBITS 13
# define IOC_DIRBITS 3 # define IOC_DIRBITS 3
# define IOC_NONE 1U # define IOC_NONE 1U
# define IOC_WRITE 4U # define IOC_WRITE 4U
# define IOC_READ 2U # define IOC_READ 2U
Show All 40 Lines
extern unsigned struct_vt_mode_sz; extern unsigned struct_vt_mode_sz;
extern const unsigned long __sanitizer_bufsiz; extern const unsigned long __sanitizer_bufsiz;
extern unsigned struct_audio_buf_info_sz; extern unsigned struct_audio_buf_info_sz;
extern unsigned struct_ppp_stats_sz; extern unsigned struct_ppp_stats_sz;
extern unsigned struct_sioc_sg_req_sz; extern unsigned struct_sioc_sg_req_sz;
extern unsigned struct_sioc_vif_req_sz; extern unsigned struct_sioc_vif_req_sz;
extern unsigned struct_procctl_reaper_status_sz;
extern unsigned struct_procctl_reaper_pidinfo_sz;
extern unsigned struct_procctl_reaper_pids_sz;
extern unsigned struct_procctl_reaper_kill_sz;
// ioctl request identifiers // ioctl request identifiers
// A special value to mark ioctls that are not present on the target platform, // A special value to mark ioctls that are not present on the target platform,
// when it can not be determined without including any system headers. // when it can not be determined without including any system headers.
extern const unsigned IOCTL_NOT_PRESENT; extern const unsigned IOCTL_NOT_PRESENT;
extern unsigned IOCTL_FIOASYNC; extern unsigned IOCTL_FIOASYNC;
extern unsigned IOCTL_FIOCLEX; extern unsigned IOCTL_FIOCLEX;
▲ Show 20 Lines • Show All 208 Lines • Show Last 20 Lines

compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_freebsd.cpp

Show First 20 Lines • Show All 199 Lines • ▼ Show 20 Lines
unsigned struct_mtop_sz = sizeof(struct mtop); unsigned struct_mtop_sz = sizeof(struct mtop);
unsigned struct_sbi_instrument_sz = sizeof(struct sbi_instrument); unsigned struct_sbi_instrument_sz = sizeof(struct sbi_instrument);
unsigned struct_seq_event_rec_sz = sizeof(struct seq_event_rec); unsigned struct_seq_event_rec_sz = sizeof(struct seq_event_rec);
unsigned struct_synth_info_sz = sizeof(struct synth_info); unsigned struct_synth_info_sz = sizeof(struct synth_info);
unsigned struct_audio_buf_info_sz = sizeof(struct audio_buf_info); unsigned struct_audio_buf_info_sz = sizeof(struct audio_buf_info);
unsigned struct_ppp_stats_sz = sizeof(struct ppp_stats); unsigned struct_ppp_stats_sz = sizeof(struct ppp_stats);
unsigned struct_sioc_sg_req_sz = sizeof(struct sioc_sg_req); unsigned struct_sioc_sg_req_sz = sizeof(struct sioc_sg_req);
unsigned struct_sioc_vif_req_sz = sizeof(struct sioc_vif_req); unsigned struct_sioc_vif_req_sz = sizeof(struct sioc_vif_req);
unsigned struct_procctl_reaper_status_sz = sizeof(struct __sanitizer_procctl_reaper_status);
unsigned struct_procctl_reaper_pidinfo_sz = sizeof(struct __sanitizer_procctl_reaper_pidinfo);
unsigned struct_procctl_reaper_pids_sz = sizeof(struct __sanitizer_procctl_reaper_pids);
unsigned struct_procctl_reaper_kill_sz = sizeof(struct __sanitizer_procctl_reaper_kill);
const unsigned long __sanitizer_bufsiz = BUFSIZ; const unsigned long __sanitizer_bufsiz = BUFSIZ;
const unsigned IOCTL_NOT_PRESENT = 0; const unsigned IOCTL_NOT_PRESENT = 0;
unsigned IOCTL_FIOASYNC = FIOASYNC; unsigned IOCTL_FIOASYNC = FIOASYNC;
unsigned IOCTL_FIOCLEX = FIOCLEX; unsigned IOCTL_FIOCLEX = FIOCLEX;
unsigned IOCTL_FIOGETOWN = FIOGETOWN; unsigned IOCTL_FIOGETOWN = FIOGETOWN;
unsigned IOCTL_FIONBIO = FIONBIO; unsigned IOCTL_FIONBIO = FIONBIO;
▲ Show 20 Lines • Show All 342 Lines • Show Last 20 Lines

compiler-rt/lib/sanitizer_common/sanitizer_posix.cpp

Show All 35 Lines
namespace __sanitizer { namespace __sanitizer {
// ------------- sanitizer_common.h // ------------- sanitizer_common.h
uptr GetMmapGranularity() { uptr GetMmapGranularity() {
return GetPageSize(); return GetPageSize();
} }
bool ErrorIsOOM(error_t err) { return err == ENOMEM; }
void *MmapOrDie(uptr size, const char *mem_type, bool raw_report) { void *MmapOrDie(uptr size, const char *mem_type, bool raw_report) {
size = RoundUpTo(size, GetPageSizeCached()); size = RoundUpTo(size, GetPageSizeCached());
uptr res = MmapNamed(nullptr, size, PROT_READ | PROT_WRITE, uptr res = MmapNamed(nullptr, size, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANON, mem_type); MAP_PRIVATE | MAP_ANON, mem_type);
int reserrno; int reserrno;
if (UNLIKELY(internal_iserror(res, &reserrno))) if (UNLIKELY(internal_iserror(res, &reserrno)))
ReportMmapFailureAndDie(size, mem_type, "allocate", reserrno, raw_report); ReportMmapFailureAndDie(size, mem_type, "allocate", reserrno, raw_report);
IncreaseTotalMmap(size); IncreaseTotalMmap(size);
▲ Show 20 Lines • Show All 350 Lines • Show Last 20 Lines

compiler-rt/lib/sanitizer_common/sanitizer_win.cpp

Show First 20 Lines • Show All 125 Lines • ▼ Show 20 Linesvoid GetThreadStackTopAndBottom(bool at_initialization, uptr *stack_top,
// FIXME: is it possible for the stack to not be a single allocation? // FIXME: is it possible for the stack to not be a single allocation?
// Are these values what ASan expects to get (reserved, not committed; // Are these values what ASan expects to get (reserved, not committed;
// including stack guard page) ? // including stack guard page) ?
*stack_top = (uptr)mbi.BaseAddress + mbi.RegionSize; *stack_top = (uptr)mbi.BaseAddress + mbi.RegionSize;
*stack_bottom = (uptr)mbi.AllocationBase; *stack_bottom = (uptr)mbi.AllocationBase;
} }
#endif // #if !SANITIZER_GO #endif // #if !SANITIZER_GO
bool ErrorIsOOM(error_t err) {
// TODO: This should check which `err`s correspond to OOM.
return false;
}
void *MmapOrDie(uptr size, const char *mem_type, bool raw_report) { void *MmapOrDie(uptr size, const char *mem_type, bool raw_report) {
void *rv = VirtualAlloc(0, size, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE); void *rv = VirtualAlloc(0, size, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
if (rv == 0) if (rv == 0)
ReportMmapFailureAndDie(size, mem_type, "allocate", ReportMmapFailureAndDie(size, mem_type, "allocate",
GetLastError(), raw_report); GetLastError(), raw_report);
return rv; return rv;
} }
▲ Show 20 Lines • Show All 1,038 Lines • Show Last 20 Lines

compiler-rt/test/hwasan/TestCases/sizes.cpp

Show First 20 Lines • Show All 78 Lines • ▼ Show 20 Linesint main(int argc, char **argv) {
} else { } else {
assert(0); assert(0);
} }
return 0; return 0;
} }
// CHECK-max: {{ERROR: HWAddressSanitizer: requested allocation size .* exceeds maximum supported size}} // CHECK-max: {{ERROR: HWAddressSanitizer: requested allocation size .* exceeds maximum supported size}}
// CHECK-oom: ERROR: HWAddressSanitizer: allocator is out of memory // CHECK-oom: ERROR: HWAddressSanitizer: out of memory: allocator is trying to allocate
// CHECK-calloc: ERROR: HWAddressSanitizer: calloc parameters overflow // CHECK-calloc: ERROR: HWAddressSanitizer: calloc parameters overflow
// CHECK-reallocarray: ERROR: HWAddressSanitizer: reallocarray parameters overflow // CHECK-reallocarray: ERROR: HWAddressSanitizer: reallocarray parameters overflow

compiler-rt/test/msan/Linux/pthread_getaffinity_np.cpp

  • This file was added.
// RUN: %clangxx_msan -O0 %s -o %t && %run %t
#include <assert.h>
#include <pthread.h>
#include <sanitizer/msan_interface.h>
int main() {
cpu_set_t set_x;
int res = pthread_getaffinity_np(pthread_self(), sizeof(set_x), &set_x);
assert(res == 0);
__msan_check_mem_is_initialized(&set_x, sizeof(set_x));
return 0;
}

compiler-rt/test/sanitizer_common/TestCases/FreeBSD/procctl.cpp

  • This file was added.
// RUN: %clangxx %s -o %t && %run %t %p
#include <assert.h>
#include <errno.h>
#include <unistd.h>
#include <sys/procctl.h>
int main() {
struct procctl_reaper_status status = {0};
int res, aslr;
res = procctl(P_PID, getpid(), PROC_REAP_STATUS, &status);
if (res < 0) {
assert(errno == EPERM);
return 0;
}
assert(status.rs_flags >= REAPER_STATUS_OWNED);
res = procctl(P_PID, getpid(), PROC_ASLR_STATUS, &aslr);
if (res < 0) {
assert(errno == EPERM);
return 0;
}
assert(aslr >= PROC_ASLR_FORCE_ENABLE);
return 0;
}

compiler-rt/test/sanitizer_common/TestCases/Linux/pthread_getaffinity_np.cpp

  • This file was added.
// RUN: %clangxx -O0 %s -o %t && %run %t
// UNSUPPORTED: android
#include <assert.h>
#include <pthread.h>
#include <sys/sysinfo.h>
#include <sanitizer/msan_interface.h>
int main() {
cpu_set_t set_x;
int res = pthread_getaffinity_np(pthread_self(), sizeof(set_x), &set_x);
assert(res == 0);
assert(CPU_COUNT_S(sizeof(set_x), &set_x) == get_nprocs());
return 0;
}

libcxx/docs/ReleaseNotes.rst

Show All 40 Lines
- Implemented P0627R6 (Function to mark unreachable code) - Implemented P0627R6 (Function to mark unreachable code)
- Implemented P1165R1 (Make stateful allocator propagation more consistent for ``operator+(basic_string)``) - Implemented P1165R1 (Make stateful allocator propagation more consistent for ``operator+(basic_string)``)
- Implemented P0674R1 (Support arrays in ``make_shared`` and ``allocate_shared``) - Implemented P0674R1 (Support arrays in ``make_shared`` and ``allocate_shared``)
- Implemented P0980R1 (Making ``std::string`` constexpr) - Implemented P0980R1 (Making ``std::string`` constexpr)
- Implemented P0618R0 (Deprecating <codecvt>)
- Marked the following papers as "Complete" (note that some of those might have - Marked the following papers as "Complete" (note that some of those might have
been implemented in a previous release but not marked as such): been implemented in a previous release but not marked as such):
- P1207R4 (Movability of Single-pass Iterators); - P1207R4 (Movability of Single-pass Iterators);
- P1474R1 (Helpful pointers for ``ContiguousIterator``); - P1474R1 (Helpful pointers for ``ContiguousIterator``);
- P1522R1 (Iterator Difference Type and Integer Overflow); - P1522R1 (Iterator Difference Type and Integer Overflow);
- P1523R1 (Views and Size Types); - P1523R1 (Views and Size Types);
- P1456R1 (Move-only views); - P1456R1 (Move-only views);
▲ Show 20 Lines • Show All 82 Lines • ▼ Show 20 Lines- ``std::valarray``'s unary operators ``!``, ``+``, ``~`` and ``-`` now return an expression
reference. This is a potential ABI break for code that exposes ``std::valarray`` on an ABI reference. This is a potential ABI break for code that exposes ``std::valarray`` on an ABI
boundary, specifically if the return type of an ABI-boundary function is ``auto``-deduced boundary, specifically if the return type of an ABI-boundary function is ``auto``-deduced
from an expression involving unary operators on ``valarray``. If you are concerned by this, from an expression involving unary operators on ``valarray``. If you are concerned by this,
you can audit whether your executable or library exports any function that returns a you can audit whether your executable or library exports any function that returns a
``valarray``, and if so ensure that any such function uses ``std::valarray`` directly ``valarray``, and if so ensure that any such function uses ``std::valarray`` directly
as a return type instead of relying on the type of ``valarray``-expressions, which is as a return type instead of relying on the type of ``valarray``-expressions, which is
not guaranteed by the Standard anyway. not guaranteed by the Standard anyway.
- The contents of ``<codecvt>``, ``wstring_convert`` and ``wbuffer_convert`` have been marked as deprecated.
To disable deprecation warnings you have to define ``_LIBCPP_DISABLE_DEPRECATION_WARNINGS``. Note that this
disables all deprecation warnings.
ldionneUnsubmitted
Done
ReplyInline Actions

This should be under API Changes, not ABI Changes

ldionne: This should be under `API Changes`, not `ABI Changes`
Build System Changes Build System Changes
-------------------- --------------------
- Support for standalone builds have been entirely removed from libc++, libc++abi and - Support for standalone builds have been entirely removed from libc++, libc++abi and
libunwind. Please use :ref:`these instructions <build instructions>` for building libunwind. Please use :ref:`these instructions <build instructions>` for building
libc++, libc++abi and/or libunwind. libc++, libc++abi and/or libunwind.
- The ``{LIBCXX,LIBCXXABI,LIBUNWIND}_TARGET_TRIPLE``, ``{LIBCXX,LIBCXXABI,LIBUNWIND}_SYSROOT`` and - The ``{LIBCXX,LIBCXXABI,LIBUNWIND}_TARGET_TRIPLE``, ``{LIBCXX,LIBCXXABI,LIBUNWIND}_SYSROOT`` and
Show All 27 Lines

libcxx/docs/Status/Cxx17Papers.csv

Show First 20 Lines • Show All 100 Lines • ▼ Show 20 Lines
"`P0518R1 <https://wg21.link/P0518R1>`__","LWG","Allowing copies as arguments to function objects given to parallel algorithms in response to CH11","Kona","","" "`P0518R1 <https://wg21.link/P0518R1>`__","LWG","Allowing copies as arguments to function objects given to parallel algorithms in response to CH11","Kona","",""
"`P0523R1 <https://wg21.link/P0523R1>`__","LWG","Wording for CH 10: Complexity of parallel algorithms","Kona","","" "`P0523R1 <https://wg21.link/P0523R1>`__","LWG","Wording for CH 10: Complexity of parallel algorithms","Kona","",""
"`P0548R1 <https://wg21.link/P0548R1>`__","LWG","common_type and duration","Kona","|Complete|","5.0" "`P0548R1 <https://wg21.link/P0548R1>`__","LWG","common_type and duration","Kona","|Complete|","5.0"
"`P0558R1 <https://wg21.link/P0558R1>`__","LWG","Resolving atomic<T> named base class inconsistencies","Kona","|Complete|","" "`P0558R1 <https://wg21.link/P0558R1>`__","LWG","Resolving atomic<T> named base class inconsistencies","Kona","|Complete|",""
"`P0574R1 <https://wg21.link/P0574R1>`__","LWG","Algorithm Complexity Constraints and Parallel Overloads","Kona","","" "`P0574R1 <https://wg21.link/P0574R1>`__","LWG","Algorithm Complexity Constraints and Parallel Overloads","Kona","",""
"`P0599R1 <https://wg21.link/P0599R1>`__","LWG","noexcept for hash functions","Kona","|Complete|","5.0" "`P0599R1 <https://wg21.link/P0599R1>`__","LWG","noexcept for hash functions","Kona","|Complete|","5.0"
"`P0604R0 <https://wg21.link/P0604R0>`__","LWG","Resolving GB 55, US 84, US 85, US 86","Kona","|Complete|","" "`P0604R0 <https://wg21.link/P0604R0>`__","LWG","Resolving GB 55, US 84, US 85, US 86","Kona","|Complete|",""
"`P0607R0 <https://wg21.link/P0607R0>`__","LWG","Inline Variables for the Standard Library","Kona","|In Progress| [#note-P0607]_","6.0" "`P0607R0 <https://wg21.link/P0607R0>`__","LWG","Inline Variables for the Standard Library","Kona","|In Progress| [#note-P0607]_","6.0"
"`P0618R0 <https://wg21.link/P0618R0>`__","LWG","Deprecating <codecvt>","Kona","","" "`P0618R0 <https://wg21.link/P0618R0>`__","LWG","Deprecating <codecvt>","Kona","|Complete|","15.0"
"`P0623R0 <https://wg21.link/P0623R0>`__","LWG","Final C++17 Parallel Algorithms Fixes","Kona","","" "`P0623R0 <https://wg21.link/P0623R0>`__","LWG","Final C++17 Parallel Algorithms Fixes","Kona","",""
"","","","","","" "","","","","",""
"`P0682R1 <https://wg21.link/P0682R1>`__","LWG","Repairing elementary string conversions","Toronto","","" "`P0682R1 <https://wg21.link/P0682R1>`__","LWG","Repairing elementary string conversions","Toronto","",""
"`P0739R0 <https://wg21.link/P0739R0>`__","LWG","Some improvements to class template argument deduction integration into the standard library","Toronto","|Complete|","5.0" "`P0739R0 <https://wg21.link/P0739R0>`__","LWG","Some improvements to class template argument deduction integration into the standard library","Toronto","|Complete|","5.0"

libcxx/include/CMakeLists.txt

Show First 20 Lines • Show All 60 Lines • ▼ Show 20 Linesset(files
__algorithm/partial_sort.h __algorithm/partial_sort.h
__algorithm/partial_sort_copy.h __algorithm/partial_sort_copy.h
__algorithm/partition.h __algorithm/partition.h
__algorithm/partition_copy.h __algorithm/partition_copy.h
__algorithm/partition_point.h __algorithm/partition_point.h
__algorithm/pop_heap.h __algorithm/pop_heap.h
__algorithm/prev_permutation.h __algorithm/prev_permutation.h
__algorithm/push_heap.h __algorithm/push_heap.h
__algorithm/ranges_adjacent_find.h
__algorithm/ranges_all_of.h __algorithm/ranges_all_of.h
__algorithm/ranges_any_of.h __algorithm/ranges_any_of.h
__algorithm/ranges_binary_search.h __algorithm/ranges_binary_search.h
__algorithm/ranges_copy.h __algorithm/ranges_copy.h
__algorithm/ranges_copy_backward.h __algorithm/ranges_copy_backward.h
__algorithm/ranges_copy_if.h __algorithm/ranges_copy_if.h
__algorithm/ranges_copy_n.h __algorithm/ranges_copy_n.h
__algorithm/ranges_count.h __algorithm/ranges_count.h
▲ Show 20 Lines • Show All 647 Lines • Show Last 20 Lines

libcxx/include/__algorithm/ranges_adjacent_find.h

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___ALGORITHM_RANGES_ADJACENT_FIND_H
#define _LIBCPP___ALGORITHM_RANGES_ADJACENT_FIND_H
#include <__config>
#include <__functional/identity.h>
#include <__functional/invoke.h>
#include <__functional/ranges_operations.h>
#include <__iterator/concepts.h>
#include <__iterator/projected.h>
#include <__ranges/access.h>
#include <__ranges/concepts.h>
#include <__ranges/dangling.h>
#include <__utility/move.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
#endif
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
_LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges {
namespace __adjacent_find {
struct __fn {
template <class _Iter, class _Sent, class _Proj, class _Pred>
_LIBCPP_HIDE_FROM_ABI constexpr static
_Iter __adjacent_find_impl(_Iter __first, _Sent __last, _Pred& __pred, _Proj& __proj) {
if (__first == __last)
return __first;
auto __i = __first;
while (++__i != __last) {
if (std::invoke(__pred, std::invoke(__proj, *__first), std::invoke(__proj, *__i)))
return __first;
__first = __i;
}
return __i;
}
template <forward_iterator _Iter, sentinel_for<_Iter> _Sent,
class _Proj = identity,
indirect_binary_predicate<projected<_Iter, _Proj>, projected<_Iter, _Proj>> _Pred = ranges::equal_to>
_LIBCPP_HIDE_FROM_ABI constexpr
_Iter operator()(_Iter __first, _Sent __last, _Pred __pred = {}, _Proj __proj = {}) const {
return __adjacent_find_impl(std::move(__first), std::move(__last), __pred, __proj);
}
template <forward_range _Range,
class _Proj = identity,
indirect_binary_predicate<projected<iterator_t<_Range>, _Proj>,
projected<iterator_t<_Range>, _Proj>> _Pred = ranges::equal_to>
_LIBCPP_HIDE_FROM_ABI constexpr
borrowed_iterator_t<_Range> operator()(_Range&& __range, _Pred __pred = {}, _Proj __proj = {}) const {
return __adjacent_find_impl(ranges::begin(__range), ranges::end(__range), __pred, __proj);
}
};
} // namespace __adjacent_find
inline namespace __cpo {
inline constexpr auto adjacent_find = __adjacent_find::__fn{};
} // namespace __cpo
} // namespace ranges
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
#endif // _LIBCPP___ALGORITHM_RANGES_ADJACENT_FIND_H

libcxx/include/algorithm

Show First 20 Lines • Show All 385 Lines • ▼ Show 20 Lines template<input_range R1, input_range R2, class Pred = ranges::equal_to,
template<input_range R1, forward_range R2, template<input_range R1, forward_range R2,
class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity> class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2> requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
constexpr borrowed_iterator_t<R1> constexpr borrowed_iterator_t<R1>
ranges::find_first_of(R1&& r1, R2&& r2, ranges::find_first_of(R1&& r1, R2&& r2,
Pred pred = {}, Pred pred = {},
Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20 Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20
template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
indirect_binary_predicate<projected<I, Proj>,
projected<I, Proj>> Pred = ranges::equal_to>
constexpr I ranges::adjacent_find(I first, S last, Pred pred = {}, Proj proj = {}); // since C+20
template<forward_range R, class Proj = identity,
indirect_binary_predicate<projected<iterator_t<R>, Proj>,
projected<iterator_t<R>, Proj>> Pred = ranges::equal_to>
constexpr borrowed_iterator_t<R> ranges::adjacent_find(R&& r, Pred pred = {}, Proj proj = {}); // since C++20
} }
constexpr bool // constexpr in C++20 constexpr bool // constexpr in C++20
all_of(InputIterator first, InputIterator last, Predicate pred); all_of(InputIterator first, InputIterator last, Predicate pred);
template <class InputIterator, class Predicate> template <class InputIterator, class Predicate>
constexpr bool // constexpr in C++20 constexpr bool // constexpr in C++20
any_of(InputIterator first, InputIterator last, Predicate pred); any_of(InputIterator first, InputIterator last, Predicate pred);
▲ Show 20 Lines • Show All 700 Lines • ▼ Show 20 Lines
#include <__algorithm/partial_sort.h> #include <__algorithm/partial_sort.h>
#include <__algorithm/partial_sort_copy.h> #include <__algorithm/partial_sort_copy.h>
#include <__algorithm/partition.h> #include <__algorithm/partition.h>
#include <__algorithm/partition_copy.h> #include <__algorithm/partition_copy.h>
#include <__algorithm/partition_point.h> #include <__algorithm/partition_point.h>
#include <__algorithm/pop_heap.h> #include <__algorithm/pop_heap.h>
#include <__algorithm/prev_permutation.h> #include <__algorithm/prev_permutation.h>
#include <__algorithm/push_heap.h> #include <__algorithm/push_heap.h>
#include <__algorithm/ranges_adjacent_find.h>
#include <__algorithm/ranges_all_of.h> #include <__algorithm/ranges_all_of.h>
#include <__algorithm/ranges_any_of.h> #include <__algorithm/ranges_any_of.h>
#include <__algorithm/ranges_binary_search.h> #include <__algorithm/ranges_binary_search.h>
#include <__algorithm/ranges_copy.h> #include <__algorithm/ranges_copy.h>
#include <__algorithm/ranges_copy_backward.h> #include <__algorithm/ranges_copy_backward.h>
#include <__algorithm/ranges_copy_if.h> #include <__algorithm/ranges_copy_if.h>
#include <__algorithm/ranges_copy_n.h> #include <__algorithm/ranges_copy_n.h>
#include <__algorithm/ranges_count.h> #include <__algorithm/ranges_count.h>
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

libcxx/include/codecvt

Show First 20 Lines • Show All 59 Lines • ▼ Show 20 Lines
#include <version> #include <version>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
enum codecvt_mode enum _LIBCPP_DEPRECATED_IN_CXX17 codecvt_mode
{ {
consume_header = 4, consume_header = 4,
generate_header = 2, generate_header = 2,
little_endian = 1 little_endian = 1
}; };
// codecvt_utf8 // codecvt_utf8
template <class _Elem> class __codecvt_utf8; template <class _Elem> class __codecvt_utf8;
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
template <> template <>
class _LIBCPP_TYPE_VIS __codecvt_utf8<wchar_t> class _LIBCPP_TYPE_VIS __codecvt_utf8<wchar_t>
: public codecvt<wchar_t, char, mbstate_t> : public codecvt<wchar_t, char, mbstate_t>
{ {
unsigned long _Maxcode_; unsigned long _Maxcode_;
_LIBCPP_DIAGNOSTIC_PUSH
_LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wdeprecated-declarations")
codecvt_mode _Mode_; codecvt_mode _Mode_;
_LIBCPP_DIAGNOSTIC_POP
public: public:
typedef wchar_t intern_type; typedef wchar_t intern_type;
typedef char extern_type; typedef char extern_type;
typedef mbstate_t state_type; typedef mbstate_t state_type;
_LIBCPP_DIAGNOSTIC_PUSH
_LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wdeprecated-declarations")
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit __codecvt_utf8(size_t __refs, unsigned long _Maxcode, explicit __codecvt_utf8(size_t __refs, unsigned long _Maxcode,
codecvt_mode _Mode) codecvt_mode _Mode)
: codecvt<wchar_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode), : codecvt<wchar_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
_Mode_(_Mode) {} _Mode_(_Mode) {}
_LIBCPP_DIAGNOSTIC_POP
protected: protected:
virtual result virtual result
do_out(state_type& __st, do_out(state_type& __st,
const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt, const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const; extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
virtual result virtual result
do_in(state_type& __st, do_in(state_type& __st,
const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt, const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
▲ Show 20 Lines • Show All 80 Lines • ▼ Show 20 Lines virtual result
extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const; extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
virtual int do_encoding() const _NOEXCEPT; virtual int do_encoding() const _NOEXCEPT;
virtual bool do_always_noconv() const _NOEXCEPT; virtual bool do_always_noconv() const _NOEXCEPT;
virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end, virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,
size_t __mx) const; size_t __mx) const;
virtual int do_max_length() const _NOEXCEPT; virtual int do_max_length() const _NOEXCEPT;
}; };
_LIBCPP_DIAGNOSTIC_PUSH
_LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wdeprecated-declarations")
template <class _Elem, unsigned long _Maxcode = 0x10ffff, template <class _Elem, unsigned long _Maxcode = 0x10ffff,
codecvt_mode _Mode = (codecvt_mode)0> codecvt_mode _Mode = (codecvt_mode)0>
class _LIBCPP_TEMPLATE_VIS codecvt_utf8 class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 codecvt_utf8
: public __codecvt_utf8<_Elem> : public __codecvt_utf8<_Elem>
{ {
public: public:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit codecvt_utf8(size_t __refs = 0) explicit codecvt_utf8(size_t __refs = 0)
: __codecvt_utf8<_Elem>(__refs, _Maxcode, _Mode) {} : __codecvt_utf8<_Elem>(__refs, _Maxcode, _Mode) {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
~codecvt_utf8() {} ~codecvt_utf8() {}
}; };
_LIBCPP_DIAGNOSTIC_POP
// codecvt_utf16 // codecvt_utf16
template <class _Elem, bool _LittleEndian> class __codecvt_utf16; template <class _Elem, bool _LittleEndian> class __codecvt_utf16;
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
template <> template <>
class _LIBCPP_TYPE_VIS __codecvt_utf16<wchar_t, false> class _LIBCPP_TYPE_VIS __codecvt_utf16<wchar_t, false>
: public codecvt<wchar_t, char, mbstate_t> : public codecvt<wchar_t, char, mbstate_t>
{ {
unsigned long _Maxcode_; unsigned long _Maxcode_;
_LIBCPP_DIAGNOSTIC_PUSH
_LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wdeprecated-declarations")
codecvt_mode _Mode_; codecvt_mode _Mode_;
_LIBCPP_DIAGNOSTIC_POP
public: public:
typedef wchar_t intern_type; typedef wchar_t intern_type;
typedef char extern_type; typedef char extern_type;
typedef mbstate_t state_type; typedef mbstate_t state_type;
_LIBCPP_DIAGNOSTIC_PUSH
_LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wdeprecated-declarations")
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit __codecvt_utf16(size_t __refs, unsigned long _Maxcode, explicit __codecvt_utf16(size_t __refs, unsigned long _Maxcode,
codecvt_mode _Mode) codecvt_mode _Mode)
: codecvt<wchar_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode), : codecvt<wchar_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
_Mode_(_Mode) {} _Mode_(_Mode) {}
_LIBCPP_DIAGNOSTIC_POP
protected: protected:
virtual result virtual result
do_out(state_type& __st, do_out(state_type& __st,
const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt, const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const; extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
virtual result virtual result
do_in(state_type& __st, do_in(state_type& __st,
const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt, const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const; intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
virtual result virtual result
do_unshift(state_type& __st, do_unshift(state_type& __st,
extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const; extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
virtual int do_encoding() const _NOEXCEPT; virtual int do_encoding() const _NOEXCEPT;
virtual bool do_always_noconv() const _NOEXCEPT; virtual bool do_always_noconv() const _NOEXCEPT;
virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end, virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,
size_t __mx) const; size_t __mx) const;
virtual int do_max_length() const _NOEXCEPT; virtual int do_max_length() const _NOEXCEPT;
}; };
template <> template <>
class _LIBCPP_TYPE_VIS __codecvt_utf16<wchar_t, true> class _LIBCPP_TYPE_VIS __codecvt_utf16<wchar_t, true>
: public codecvt<wchar_t, char, mbstate_t> : public codecvt<wchar_t, char, mbstate_t>
{ {
unsigned long _Maxcode_; unsigned long _Maxcode_;
_LIBCPP_DIAGNOSTIC_PUSH
_LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wdeprecated-declarations")
ldionneUnsubmitted
Done
ReplyInline Actions

Here and elsewhere, let's use _LIBCPP_SUPPRESS_DEPRECATED_PUSH and _LIBCPP_SUPPRESS_DEPRECATED_POP instead.

ldionne: Here and elsewhere, let's use `_LIBCPP_SUPPRESS_DEPRECATED_PUSH` and…
codecvt_mode _Mode_; codecvt_mode _Mode_;
_LIBCPP_DIAGNOSTIC_POP
public: public:
typedef wchar_t intern_type; typedef wchar_t intern_type;
typedef char extern_type; typedef char extern_type;
typedef mbstate_t state_type; typedef mbstate_t state_type;
_LIBCPP_DIAGNOSTIC_PUSH
_LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wdeprecated-declarations")
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit __codecvt_utf16(size_t __refs, unsigned long _Maxcode, explicit __codecvt_utf16(size_t __refs, unsigned long _Maxcode,
codecvt_mode _Mode) codecvt_mode _Mode)
: codecvt<wchar_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode), : codecvt<wchar_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
_Mode_(_Mode) {} _Mode_(_Mode) {}
_LIBCPP_DIAGNOSTIC_POP
protected: protected:
virtual result virtual result
do_out(state_type& __st, do_out(state_type& __st,
const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt, const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const; extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
virtual result virtual result
do_in(state_type& __st, do_in(state_type& __st,
const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt, const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
▲ Show 20 Lines • Show All 156 Lines • ▼ Show 20 Lines virtual result
extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const; extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
virtual int do_encoding() const _NOEXCEPT; virtual int do_encoding() const _NOEXCEPT;
virtual bool do_always_noconv() const _NOEXCEPT; virtual bool do_always_noconv() const _NOEXCEPT;
virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end, virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,
size_t __mx) const; size_t __mx) const;
virtual int do_max_length() const _NOEXCEPT; virtual int do_max_length() const _NOEXCEPT;
}; };
_LIBCPP_DIAGNOSTIC_PUSH
_LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wdeprecated-declarations")
template <class _Elem, unsigned long _Maxcode = 0x10ffff, template <class _Elem, unsigned long _Maxcode = 0x10ffff,
codecvt_mode _Mode = (codecvt_mode)0> codecvt_mode _Mode = (codecvt_mode)0>
class _LIBCPP_TEMPLATE_VIS codecvt_utf16 class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 codecvt_utf16
: public __codecvt_utf16<_Elem, _Mode & little_endian> : public __codecvt_utf16<_Elem, _Mode & little_endian>
{ {
public: public:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit codecvt_utf16(size_t __refs = 0) explicit codecvt_utf16(size_t __refs = 0)
: __codecvt_utf16<_Elem, _Mode & little_endian>(__refs, _Maxcode, _Mode) {} : __codecvt_utf16<_Elem, _Mode & little_endian>(__refs, _Maxcode, _Mode) {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
~codecvt_utf16() {} ~codecvt_utf16() {}
}; };
_LIBCPP_DIAGNOSTIC_POP
// codecvt_utf8_utf16 // codecvt_utf8_utf16
template <class _Elem> class __codecvt_utf8_utf16; template <class _Elem> class __codecvt_utf8_utf16;
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
template <> template <>
class _LIBCPP_TYPE_VIS __codecvt_utf8_utf16<wchar_t> class _LIBCPP_TYPE_VIS __codecvt_utf8_utf16<wchar_t>
: public codecvt<wchar_t, char, mbstate_t> : public codecvt<wchar_t, char, mbstate_t>
{ {
unsigned long _Maxcode_; unsigned long _Maxcode_;
_LIBCPP_DIAGNOSTIC_PUSH
_LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wdeprecated-declarations")
codecvt_mode _Mode_; codecvt_mode _Mode_;
_LIBCPP_DIAGNOSTIC_POP
public: public:
typedef wchar_t intern_type; typedef wchar_t intern_type;
typedef char extern_type; typedef char extern_type;
typedef mbstate_t state_type; typedef mbstate_t state_type;
_LIBCPP_DIAGNOSTIC_PUSH
_LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wdeprecated-declarations")
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit __codecvt_utf8_utf16(size_t __refs, unsigned long _Maxcode, explicit __codecvt_utf8_utf16(size_t __refs, unsigned long _Maxcode,
codecvt_mode _Mode) codecvt_mode _Mode)
: codecvt<wchar_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode), : codecvt<wchar_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
_Mode_(_Mode) {} _Mode_(_Mode) {}
_LIBCPP_DIAGNOSTIC_POP
protected: protected:
virtual result virtual result
do_out(state_type& __st, do_out(state_type& __st,
const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt, const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const; extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
virtual result virtual result
do_in(state_type& __st, do_in(state_type& __st,
const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt, const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
▲ Show 20 Lines • Show All 80 Lines • ▼ Show 20 Lines virtual result
extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const; extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
virtual int do_encoding() const _NOEXCEPT; virtual int do_encoding() const _NOEXCEPT;
virtual bool do_always_noconv() const _NOEXCEPT; virtual bool do_always_noconv() const _NOEXCEPT;
virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end, virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,
size_t __mx) const; size_t __mx) const;
virtual int do_max_length() const _NOEXCEPT; virtual int do_max_length() const _NOEXCEPT;
}; };
_LIBCPP_DIAGNOSTIC_PUSH
_LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wdeprecated-declarations")
template <class _Elem, unsigned long _Maxcode = 0x10ffff, template <class _Elem, unsigned long _Maxcode = 0x10ffff,
codecvt_mode _Mode = (codecvt_mode)0> codecvt_mode _Mode = (codecvt_mode)0>
class _LIBCPP_TEMPLATE_VIS codecvt_utf8_utf16 class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 codecvt_utf8_utf16
: public __codecvt_utf8_utf16<_Elem> : public __codecvt_utf8_utf16<_Elem>
{ {
public: public:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit codecvt_utf8_utf16(size_t __refs = 0) explicit codecvt_utf8_utf16(size_t __refs = 0)
: __codecvt_utf8_utf16<_Elem>(__refs, _Maxcode, _Mode) {} : __codecvt_utf8_utf16<_Elem>(__refs, _Maxcode, _Mode) {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
~codecvt_utf8_utf16() {} ~codecvt_utf8_utf16() {}
}; };
_LIBCPP_DIAGNOSTIC_POP
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_CODECVT #endif // _LIBCPP_CODECVT

libcxx/include/locale

Show First 20 Lines • Show All 3,606 Lines • ▼ Show 20 Lines
_LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS messages_byname<char>) _LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS messages_byname<char>)
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
_LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS messages_byname<wchar_t>) _LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS messages_byname<wchar_t>)
#endif #endif
template<class _Codecvt, class _Elem = wchar_t, template<class _Codecvt, class _Elem = wchar_t,
class _Wide_alloc = allocator<_Elem>, class _Wide_alloc = allocator<_Elem>,
class _Byte_alloc = allocator<char> > class _Byte_alloc = allocator<char> >
class _LIBCPP_TEMPLATE_VIS wstring_convert class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 wstring_convert
{ {
public: public:
typedef basic_string<char, char_traits<char>, _Byte_alloc> byte_string; typedef basic_string<char, char_traits<char>, _Byte_alloc> byte_string;
typedef basic_string<_Elem, char_traits<_Elem>, _Wide_alloc> wide_string; typedef basic_string<_Elem, char_traits<_Elem>, _Wide_alloc> wide_string;
typedef typename _Codecvt::state_type state_type; typedef typename _Codecvt::state_type state_type;
typedef typename wide_string::traits_type::int_type int_type; typedef typename wide_string::traits_type::int_type int_type;
private: private:
▲ Show 20 Lines • Show All 248 Lines • ▼ Show 20 Lineswstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::
if (__byte_err_string_.empty()) if (__byte_err_string_.empty())
__throw_range_error("wstring_convert: to_bytes error"); __throw_range_error("wstring_convert: to_bytes error");
return __byte_err_string_; return __byte_err_string_;
} }
template <class _Codecvt, class _Elem = wchar_t, class _Tr = char_traits<_Elem> > template <class _Codecvt, class _Elem = wchar_t, class _Tr = char_traits<_Elem> >
class _LIBCPP_TEMPLATE_VIS wbuffer_convert class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 wbuffer_convert
: public basic_streambuf<_Elem, _Tr> : public basic_streambuf<_Elem, _Tr>
{ {
public: public:
// types: // types:
typedef _Elem char_type; typedef _Elem char_type;
typedef _Tr traits_type; typedef _Tr traits_type;
typedef typename traits_type::int_type int_type; typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type; typedef typename traits_type::pos_type pos_type;
▲ Show 20 Lines • Show All 461 Lines • Show Last 20 Lines

libcxx/include/module.modulemap

Show First 20 Lines • Show All 292 Lines • ▼ Show 20 Lines module __algorithm {
module partial_sort { private header "__algorithm/partial_sort.h" } module partial_sort { private header "__algorithm/partial_sort.h" }
module partial_sort_copy { private header "__algorithm/partial_sort_copy.h" } module partial_sort_copy { private header "__algorithm/partial_sort_copy.h" }
module partition { private header "__algorithm/partition.h" } module partition { private header "__algorithm/partition.h" }
module partition_copy { private header "__algorithm/partition_copy.h" } module partition_copy { private header "__algorithm/partition_copy.h" }
module partition_point { private header "__algorithm/partition_point.h" } module partition_point { private header "__algorithm/partition_point.h" }
module pop_heap { private header "__algorithm/pop_heap.h" } module pop_heap { private header "__algorithm/pop_heap.h" }
module prev_permutation { private header "__algorithm/prev_permutation.h" } module prev_permutation { private header "__algorithm/prev_permutation.h" }
module push_heap { private header "__algorithm/push_heap.h" } module push_heap { private header "__algorithm/push_heap.h" }
module ranges_adjacent_find { private header "__algorithm/ranges_adjacent_find.h" }
module ranges_all_of { private header "__algorithm/ranges_all_of.h" } module ranges_all_of { private header "__algorithm/ranges_all_of.h" }
module ranges_any_of { private header "__algorithm/ranges_any_of.h" } module ranges_any_of { private header "__algorithm/ranges_any_of.h" }
module ranges_binary_search { private header "__algorithm/ranges_binary_search.h" } module ranges_binary_search { private header "__algorithm/ranges_binary_search.h" }
module ranges_copy { private header "__algorithm/ranges_copy.h" } module ranges_copy { private header "__algorithm/ranges_copy.h" }
module ranges_copy_backward { private header "__algorithm/ranges_copy_backward.h" } module ranges_copy_backward { private header "__algorithm/ranges_copy_backward.h" }
module ranges_copy_if { private header "__algorithm/ranges_copy_if.h" } module ranges_copy_if { private header "__algorithm/ranges_copy_if.h" }
module ranges_copy_n { private header "__algorithm/ranges_copy_n.h" } module ranges_copy_n { private header "__algorithm/ranges_copy_n.h" }
module ranges_count { private header "__algorithm/ranges_count.h" } module ranges_count { private header "__algorithm/ranges_count.h" }
▲ Show 20 Lines • Show All 923 Lines • Show Last 20 Lines

libcxx/src/locale.cpp

Show First 20 Lines • Show All 1,825 Lines • ▼ Show 20 Lines
// 001000 - 00CFFF 1000 - CFFF E1 - EC, 80 - BF, 80 - BF 49152 // 001000 - 00CFFF 1000 - CFFF E1 - EC, 80 - BF, 80 - BF 49152
// 00D000 - 00D7FF D000 - D7FF ED - ED, 80 - 9F, 80 - BF 2048 // 00D000 - 00D7FF D000 - D7FF ED - ED, 80 - 9F, 80 - BF 2048
// 00D800 - 00DFFF invalid // 00D800 - 00DFFF invalid
// 00E000 - 00FFFF E000 - FFFF EE - EF, 80 - BF, 80 - BF 8192 // 00E000 - 00FFFF E000 - FFFF EE - EF, 80 - BF, 80 - BF 8192
// 010000 - 03FFFF D800 - D8BF, DC00 - DFFF F0 - F0, 90 - BF, 80 - BF, 80 - BF 196608 // 010000 - 03FFFF D800 - D8BF, DC00 - DFFF F0 - F0, 90 - BF, 80 - BF, 80 - BF 196608
// 040000 - 0FFFFF D8C0 - DBBF, DC00 - DFFF F1 - F3, 80 - BF, 80 - BF, 80 - BF 786432 // 040000 - 0FFFFF D8C0 - DBBF, DC00 - DFFF F1 - F3, 80 - BF, 80 - BF, 80 - BF 786432
// 100000 - 10FFFF DBC0 - DBFF, DC00 - DFFF F4 - F4, 80 - 8F, 80 - BF, 80 - BF 65536 // 100000 - 10FFFF DBC0 - DBFF, DC00 - DFFF F4 - F4, 80 - 8F, 80 - BF, 80 - BF 65536
_LIBCPP_DIAGNOSTIC_PUSH
_LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wdeprecated-declarations")
ldionneUnsubmitted
Done
ReplyInline Actions

_LIBCPP_SUPPRESS_DEPRECATED_PUSH

ldionne: `_LIBCPP_SUPPRESS_DEPRECATED_PUSH`
static static
codecvt_base::result codecvt_base::result
utf16_to_utf8(const uint16_t* frm, const uint16_t* frm_end, const uint16_t*& frm_nxt, utf16_to_utf8(const uint16_t* frm, const uint16_t* frm_end, const uint16_t*& frm_nxt,
uint8_t* to, uint8_t* to_end, uint8_t*& to_nxt, uint8_t* to, uint8_t* to_end, uint8_t*& to_nxt,
unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0)) unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
{ {
frm_nxt = frm; frm_nxt = frm;
to_nxt = to; to_nxt = to;
▲ Show 20 Lines • Show All 1,357 Lines • ▼ Show 20 Lines for (size_t nchar16_t = 0; frm_nxt < frm_end - 1 && nchar16_t < mx; ++nchar16_t)
uint16_t c1 = static_cast<uint16_t>(frm_nxt[1] << 8 | frm_nxt[0]); uint16_t c1 = static_cast<uint16_t>(frm_nxt[1] << 8 | frm_nxt[0]);
if ((c1 & 0xF800) == 0xD800 || c1 > Maxcode) if ((c1 & 0xF800) == 0xD800 || c1 > Maxcode)
break; break;
frm_nxt += 2; frm_nxt += 2;
} }
return static_cast<int>(frm_nxt - frm); return static_cast<int>(frm_nxt - frm);
} }
_LIBCPP_DIAGNOSTIC_POP
// template <> class codecvt<char16_t, char, mbstate_t> // template <> class codecvt<char16_t, char, mbstate_t>
locale::id codecvt<char16_t, char, mbstate_t>::id; locale::id codecvt<char16_t, char, mbstate_t>::id;
codecvt<char16_t, char, mbstate_t>::~codecvt() codecvt<char16_t, char, mbstate_t>::~codecvt()
{ {
} }
▲ Show 20 Lines • Show All 391 Lines • ▼ Show 20 Lines__codecvt_utf8<wchar_t>::do_length(state_type&,
const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end); const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
#if defined(_LIBCPP_SHORT_WCHAR) #if defined(_LIBCPP_SHORT_WCHAR)
return utf8_to_ucs2_length(_frm, _frm_end, mx, _Maxcode_, _Mode_); return utf8_to_ucs2_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
#else #else
return utf8_to_ucs4_length(_frm, _frm_end, mx, _Maxcode_, _Mode_); return utf8_to_ucs4_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
#endif #endif
} }
_LIBCPP_DIAGNOSTIC_PUSH
_LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wdeprecated-declarations")
int int
__codecvt_utf8<wchar_t>::do_max_length() const noexcept __codecvt_utf8<wchar_t>::do_max_length() const noexcept
{ {
#if defined(_LIBCPP_SHORT_WCHAR) #if defined(_LIBCPP_SHORT_WCHAR)
if (_Mode_ & consume_header) if (_Mode_ & consume_header)
return 6; return 6;
return 3; return 3;
#else #else
▲ Show 20 Lines • Show All 897 Lines • ▼ Show 20 Lines
int int
__codecvt_utf8_utf16<char32_t>::do_max_length() const noexcept __codecvt_utf8_utf16<char32_t>::do_max_length() const noexcept
{ {
if (_Mode_ & consume_header) if (_Mode_ & consume_header)
return 7; return 7;
return 4; return 4;
} }
_LIBCPP_DIAGNOSTIC_POP
// __narrow_to_utf8<16> // __narrow_to_utf8<16>
__narrow_to_utf8<16>::~__narrow_to_utf8() __narrow_to_utf8<16>::~__narrow_to_utf8()
{ {
} }
// __narrow_to_utf8<32> // __narrow_to_utf8<32>
▲ Show 20 Lines • Show All 2,059 Lines • Show Last 20 Lines

libcxx/test/libcxx/algorithms/ranges_robust_against_copying_comparators.pass.cpp

Show First 20 Lines • Show All 84 Lines • ▼ Show 20 Linesconstexpr bool all_the_algorithms()
void **last = a+10; void **last = a+10;
void **first2 = b; void **first2 = b;
//void **mid2 = b+5; //void **mid2 = b+5;
void **last2 = b+10; void **last2 = b+10;
void *value = nullptr; void *value = nullptr;
int count = 1; int count = 1;
int copies = 0; int copies = 0;
//(void)std::ranges::adjacent_find(first, last, Equal(&copies)); assert(copies == 0); (void)std::ranges::adjacent_find(first, last, Equal(&copies)); assert(copies == 0);
//(void)std::ranges::adjacent_find(a, Equal(&copies)); assert(copies == 0); (void)std::ranges::adjacent_find(a, Equal(&copies)); assert(copies == 0);
(void)std::ranges::all_of(first, last, UnaryTrue(&copies)); assert(copies == 0); (void)std::ranges::all_of(first, last, UnaryTrue(&copies)); assert(copies == 0);
(void)std::ranges::all_of(a, UnaryTrue(&copies)); assert(copies == 0); (void)std::ranges::all_of(a, UnaryTrue(&copies)); assert(copies == 0);
(void)std::ranges::any_of(first, last, UnaryTrue(&copies)); assert(copies == 0); (void)std::ranges::any_of(first, last, UnaryTrue(&copies)); assert(copies == 0);
(void)std::ranges::any_of(a, UnaryTrue(&copies)); assert(copies == 0); (void)std::ranges::any_of(a, UnaryTrue(&copies)); assert(copies == 0);
(void)std::ranges::binary_search(first, last, value, Less(&copies)); assert(copies == 0); (void)std::ranges::binary_search(first, last, value, Less(&copies)); assert(copies == 0);
(void)std::ranges::binary_search(a, value, Less(&copies)); assert(copies == 0); (void)std::ranges::binary_search(a, value, Less(&copies)); assert(copies == 0);
//(void)std::ranges::clamp(value, value, value, Less(&copies)); assert(copies == 0); //(void)std::ranges::clamp(value, value, value, Less(&copies)); assert(copies == 0);
(void)std::ranges::count_if(first, last, UnaryTrue(&copies)); assert(copies == 0); (void)std::ranges::count_if(first, last, UnaryTrue(&copies)); assert(copies == 0);
▲ Show 20 Lines • Show All 139 Lines • Show Last 20 Lines

libcxx/test/libcxx/algorithms/ranges_robust_against_copying_projections.pass.cpp

Show First 20 Lines • Show All 66 Lines • ▼ Show 20 Linesconstexpr bool all_the_algorithms()
T *last = a+10; T *last = a+10;
T *first2 = b; T *first2 = b;
//T *mid2 = b+5; //T *mid2 = b+5;
T *last2 = b+10; T *last2 = b+10;
void *value = nullptr; void *value = nullptr;
int count = 1; int count = 1;
int copies = 0; int copies = 0;
//(void)std::ranges::adjacent_find(first, last, Equal(), Proj(&copies)); assert(copies == 0); (void)std::ranges::adjacent_find(first, last, Equal(), Proj(&copies)); assert(copies == 0);
//(void)std::ranges::adjacent_find(a, Equal(), Proj(&copies)); assert(copies == 0); (void)std::ranges::adjacent_find(a, Equal(), Proj(&copies)); assert(copies == 0);
(void)std::ranges::all_of(first, last, UnaryTrue(), Proj(&copies)); assert(copies == 0); (void)std::ranges::all_of(first, last, UnaryTrue(), Proj(&copies)); assert(copies == 0);
(void)std::ranges::all_of(a, UnaryTrue(), Proj(&copies)); assert(copies == 0); (void)std::ranges::all_of(a, UnaryTrue(), Proj(&copies)); assert(copies == 0);
(void)std::ranges::any_of(first, last, UnaryTrue(), Proj(&copies)); assert(copies == 0); (void)std::ranges::any_of(first, last, UnaryTrue(), Proj(&copies)); assert(copies == 0);
(void)std::ranges::any_of(a, UnaryTrue(), Proj(&copies)); assert(copies == 0); (void)std::ranges::any_of(a, UnaryTrue(), Proj(&copies)); assert(copies == 0);
//(void)std::ranges::binary_search(first, last, value, Less(), Proj(&copies)); assert(copies == 0); //(void)std::ranges::binary_search(first, last, value, Less(), Proj(&copies)); assert(copies == 0);
//(void)std::ranges::binary_search(a, value, Less(), Proj(&copies)); assert(copies == 0); //(void)std::ranges::binary_search(a, value, Less(), Proj(&copies)); assert(copies == 0);
//(void)std::ranges::clamp(T(), T(), T(), Less(), Proj(&copies)); assert(copies == 0); //(void)std::ranges::clamp(T(), T(), T(), Less(), Proj(&copies)); assert(copies == 0);
(void)std::ranges::count(first, last, value, Proj(&copies)); assert(copies == 0); (void)std::ranges::count(first, last, value, Proj(&copies)); assert(copies == 0);
▲ Show 20 Lines • Show All 148 Lines • Show Last 20 Lines

libcxx/test/libcxx/localization/locales/locale.convenience/conversions/conversions.string/ctor_move.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// XFAIL: no-wide-characters // XFAIL: no-wide-characters
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
// <locale> // <locale>
// wstring_convert<Codecvt, Elem, Wide_alloc, Byte_alloc> // wstring_convert<Codecvt, Elem, Wide_alloc, Byte_alloc>
// wstring_convert(wstring_convert&& other); // EXTENSION // wstring_convert(wstring_convert&& other); // EXTENSION
#include <locale> #include <locale>
#include <codecvt> #include <codecvt>
Show All 20 Lines

libcxx/test/libcxx/private_headers.verify.cpp

Show First 20 Lines • Show All 97 Lines • ▼ Show 20 Lines
#include <__algorithm/partial_sort.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/partial_sort.h'}} #include <__algorithm/partial_sort.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/partial_sort.h'}}
#include <__algorithm/partial_sort_copy.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/partial_sort_copy.h'}} #include <__algorithm/partial_sort_copy.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/partial_sort_copy.h'}}
#include <__algorithm/partition.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/partition.h'}} #include <__algorithm/partition.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/partition.h'}}
#include <__algorithm/partition_copy.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/partition_copy.h'}} #include <__algorithm/partition_copy.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/partition_copy.h'}}
#include <__algorithm/partition_point.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/partition_point.h'}} #include <__algorithm/partition_point.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/partition_point.h'}}
#include <__algorithm/pop_heap.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/pop_heap.h'}} #include <__algorithm/pop_heap.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/pop_heap.h'}}
#include <__algorithm/prev_permutation.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/prev_permutation.h'}} #include <__algorithm/prev_permutation.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/prev_permutation.h'}}
#include <__algorithm/push_heap.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/push_heap.h'}} #include <__algorithm/push_heap.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/push_heap.h'}}
#include <__algorithm/ranges_adjacent_find.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_adjacent_find.h'}}
#include <__algorithm/ranges_all_of.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_all_of.h'}} #include <__algorithm/ranges_all_of.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_all_of.h'}}
#include <__algorithm/ranges_any_of.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_any_of.h'}} #include <__algorithm/ranges_any_of.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_any_of.h'}}
#include <__algorithm/ranges_binary_search.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_binary_search.h'}} #include <__algorithm/ranges_binary_search.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_binary_search.h'}}
#include <__algorithm/ranges_copy.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_copy.h'}} #include <__algorithm/ranges_copy.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_copy.h'}}
#include <__algorithm/ranges_copy_backward.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_copy_backward.h'}} #include <__algorithm/ranges_copy_backward.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_copy_backward.h'}}
#include <__algorithm/ranges_copy_if.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_copy_if.h'}} #include <__algorithm/ranges_copy_if.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_copy_if.h'}}
#include <__algorithm/ranges_copy_n.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_copy_n.h'}} #include <__algorithm/ranges_copy_n.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_copy_n.h'}}
#include <__algorithm/ranges_count.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_count.h'}} #include <__algorithm/ranges_count.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_count.h'}}
▲ Show 20 Lines • Show All 421 Lines • Show Last 20 Lines

libcxx/test/std/algorithms/alg.modifying.operations/alg.transform/ranges.transform.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, c++11, c++14, c++17 // UNSUPPORTED: c++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-has-no-incomplete-ranges // UNSUPPORTED: libcpp-has-no-incomplete-ranges
// On AIX the test takes a long time, leading to frequent CI timeouts.
// UNSUPPORTED: LIBCXX-AIX-FIXME
// <algorithm> // <algorithm>
// template<input_iterator I, sentinel_for<I> S, weakly_incrementable O, // template<input_iterator I, sentinel_for<I> S, weakly_incrementable O,
// copy_constructible F, class Proj = identity> // copy_constructible F, class Proj = identity>
// requires indirectly_writable<O, indirect_result_t<F&, projected<I, Proj>>> // requires indirectly_writable<O, indirect_result_t<F&, projected<I, Proj>>>
// constexpr ranges::unary_transform_result<I, O> // constexpr ranges::unary_transform_result<I, O>
// ranges::transform(I first1, S last1, O result, F op, Proj proj = {}); // ranges::transform(I first1, S last1, O result, F op, Proj proj = {});
▲ Show 20 Lines • Show All 567 Lines • Show Last 20 Lines

libcxx/test/std/algorithms/alg.nonmodifying/alg.adjacent.find/ranges.adjacent_find.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <algorithm>
// UNSUPPORTED: c++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-has-no-incomplete-ranges
// template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
// indirect_binary_predicate<projected<I, Proj>,
// projected<I, Proj>> Pred = ranges::equal_to>
// constexpr I ranges::adjacent_find(I first, S last, Pred pred = {}, Proj proj = {});
// template<forward_range R, class Proj = identity,
// indirect_binary_predicate<projected<iterator_t<R>, Proj>,
// projected<iterator_t<R>, Proj>> Pred = ranges::equal_to>
// constexpr borrowed_iterator_t<R> ranges::adjacent_find(R&& r, Pred pred = {}, Proj proj = {});
#include <algorithm>
#include <array>
#include <cassert>
#include <cstddef>
#include <ranges>
#include "almost_satisfies_types.h"
#include "boolean_testable.h"
#include "test_iterators.h"
template <class Iter, class Sent = Iter>
concept HasAdjacentFindIt = requires (Iter iter, Sent sent) { std::ranges::adjacent_find(iter, sent); };
struct NotComparable {};
static_assert(HasAdjacentFindIt<int*>);
static_assert(!HasAdjacentFindIt<ForwardIteratorNotDerivedFrom>);
static_assert(!HasAdjacentFindIt<ForwardIteratorNotIncrementable>);
static_assert(!HasAdjacentFindIt<int*, SentinelForNotSemiregular>);
static_assert(!HasAdjacentFindIt<int*, SentinelForNotWeaklyEqualityComparableWith>);
static_assert(!HasAdjacentFindIt<NotComparable*>);
template <class Range>
concept HasAdjacentFindR = requires (Range range) { std::ranges::adjacent_find(range); };
static_assert(HasAdjacentFindR<UncheckedRange<int*>>);
static_assert(!HasAdjacentFindR<ForwardRangeNotDerivedFrom>);
static_assert(!HasAdjacentFindR<ForwardRangeNotIncrementable>);
static_assert(!HasAdjacentFindR<ForwardRangeNotSentinelSemiregular>);
static_assert(!HasAdjacentFindR<ForwardRangeNotSentinelEqualityComparableWith>);
static_assert(!HasAdjacentFindR<UncheckedRange<NotComparable>>);
template <size_t N>
struct Data {
std::array<int, N> input;
int expected;
};
template <class Iter, class Sent, size_t N>
constexpr void test(Data<N> d) {
{
std::same_as<Iter> decltype(auto) ret =
std::ranges::adjacent_find(Iter(d.input.data()), Sent(Iter(d.input.data() + d.input.size())));
assert(base(ret) == d.input.data() + d.expected);
}
{
auto range = std::ranges::subrange(Iter(d.input.data()), Sent(Iter(d.input.data() + d.input.size())));
std::same_as<Iter> decltype(auto) ret = std::ranges::adjacent_find(range);
assert(base(ret) == d.input.data() + d.expected);
}
}
template <class Iter, class Sent = Iter>
constexpr void test_iterators() {
// simple test
test<Iter, Sent, 4>({.input = {1, 2, 2, 4}, .expected = 1});
// last is returned with no match
test<Iter, Sent, 4>({.input = {1, 2, 3, 4}, .expected = 4});
// first elements match
test<Iter, Sent, 4>({.input = {1, 1, 3, 4}, .expected = 0});
// the first match is returned
test<Iter, Sent, 7>({.input = {1, 1, 3, 4, 4, 4, 4}, .expected = 0});
// two element range works
test<Iter, Sent, 2>({.input = {3, 3}, .expected = 0});
// single element range works
test<Iter, Sent, 1>({.input = {1}, .expected = 1});
// empty range works
test<Iter, Sent, 0>({.input = {}, .expected = 0});
}
constexpr bool test() {
test_iterators<forward_iterator<int*>, sentinel_wrapper<forward_iterator<int*>>>();
test_iterators<forward_iterator<int*>>();
test_iterators<bidirectional_iterator<int*>>();
test_iterators<random_access_iterator<int*>>();
test_iterators<contiguous_iterator<int*>>();
test_iterators<int*>();
test_iterators<const int*>();
{ // check that ranges::dangling is returned
[[maybe_unused]] std::same_as<std::ranges::dangling> decltype(auto) ret =
std::ranges::adjacent_find(std::array{1, 2, 3, 4});
}
{ // check that the complexity requirements are met with no match
{
int predicateCount = 0;
auto pred = [&](int, int) { ++predicateCount; return false; };
auto projectionCount = 0;
auto proj = [&](int i) { ++projectionCount; return i; };
int a[] = {1, 2, 3, 4, 5};
auto ret = std::ranges::adjacent_find(a, a + 5, pred, proj);
assert(ret == a + 5);
assert(predicateCount == 4);
assert(projectionCount == 8);
}
{
int predicateCount = 0;
auto pred = [&](int, int) { ++predicateCount; return false; };
auto projectionCount = 0;
auto proj = [&](int i) { ++projectionCount; return i; };
int a[] = {1, 2, 3, 4, 5};
auto ret = std::ranges::adjacent_find(a, pred, proj);
assert(ret == a + 5);
assert(predicateCount == 4);
assert(projectionCount == 8);
}
}
{ // check that the complexity requirements are met with a match
{
int predicateCount = 0;
auto pred = [&](int i, int j) { ++predicateCount; return i == j; };
auto projectionCount = 0;
auto proj = [&](int i) { ++projectionCount; return i; };
int a[] = {1, 2, 4, 4, 5};
auto ret = std::ranges::adjacent_find(a, a + 5, pred, proj);
assert(ret == a + 2);
assert(predicateCount == 3);
assert(projectionCount == 6);
}
{
int predicateCount = 0;
auto pred = [&](int i, int j) { ++predicateCount; return i == j; };
auto projectionCount = 0;
auto proj = [&](int i) { ++projectionCount; return i; };
int a[] = {1, 2, 4, 4, 5};
auto ret = std::ranges::adjacent_find(a, pred, proj);
assert(ret == a + 2);
assert(predicateCount == 3);
assert(projectionCount == 6);
}
}
{ // check that std::invoke is used
struct S {
constexpr S(int i_) : i(i_) {}
constexpr bool compare(const S& j) const { return j.i == i; }
constexpr const S& identity() const { return *this; }
int i;
};
{
S a[] = {1, 2, 3, 4};
auto ret = std::ranges::adjacent_find(std::begin(a), std::end(a), &S::compare, &S::identity);
assert(ret == a + 4);
}
{
S a[] = {1, 2, 3, 4};
auto ret = std::ranges::adjacent_find(a, &S::compare, &S::identity);
assert(ret == a + 4);
}
}
{ // check that the implicit conversion to bool works
{
int a[] = {1, 2, 2, 4};
auto ret = std::ranges::adjacent_find(a, a + 4, [](int i, int j) { return BooleanTestable{i == j}; });
assert(ret == a + 1);
}
{
int a[] = {1, 2, 2, 4};
auto ret = std::ranges::adjacent_find(a, [](int i, int j) { return BooleanTestable{i == j}; });
assert(ret == a + 1);
}
}
return true;
}
int main(int, char**) {
test();
static_assert(test());
return 0;
}

libcxx/test/std/library/description/conventions/customization.point.object/niebloid.compile.pass.cpp

Show First 20 Lines • Show All 54 Lines • ▼ Show 20 Lines
int a[10]; int a[10];
auto odd = [](int x) { return x % 2 != 0; }; auto odd = [](int x) { return x % 2 != 0; };
auto triple = [](int x) { return 3*x; }; auto triple = [](int x) { return 3*x; };
//auto plus = [](int x, int y) { return x == y; }; //auto plus = [](int x, int y) { return x == y; };
//std::mt19937 g; //std::mt19937 g;
// [algorithm.syn] // [algorithm.syn]
//static_assert(test(std::ranges::adjacent_find, a)); static_assert(test(std::ranges::adjacent_find, a));
static_assert(test(std::ranges::all_of, a, odd)); static_assert(test(std::ranges::all_of, a, odd));
static_assert(test(std::ranges::any_of, a, odd)); static_assert(test(std::ranges::any_of, a, odd));
static_assert(test(std::ranges::binary_search, a, 42)); static_assert(test(std::ranges::binary_search, a, 42));
//static_assert(test(std::ranges::clamp, 42, 42, 42)); //static_assert(test(std::ranges::clamp, 42, 42, 42));
static_assert(test(std::ranges::copy, a, a)); static_assert(test(std::ranges::copy, a, a));
static_assert(test(std::ranges::copy_backward, a, a)); static_assert(test(std::ranges::copy_backward, a, a));
static_assert(test(std::ranges::copy_if, a, a, odd)); static_assert(test(std::ranges::copy_if, a, a, odd));
static_assert(test(std::ranges::copy_n, a, 10, a)); static_assert(test(std::ranges::copy_n, a, 10, a));
▲ Show 20 Lines • Show All 118 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.stdcvt/codecvt_mode.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <codecvt> // <codecvt>
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
// enum codecvt_mode // enum codecvt_mode
// { // {
// consume_header = 4, // consume_header = 4,
// generate_header = 2, // generate_header = 2,
// little_endian = 1 // little_endian = 1
// }; // };
#include <codecvt> #include <codecvt>
Show All 14 Lines

libcxx/test/std/localization/locale.stdcvt/codecvt_utf16.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <codecvt> // <codecvt>
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
// template <class Elem, unsigned long Maxcode = 0x10ffff, // template <class Elem, unsigned long Maxcode = 0x10ffff,
// codecvt_mode Mode = (codecvt_mode)0> // codecvt_mode Mode = (codecvt_mode)0>
// class codecvt_utf16 // class codecvt_utf16
// : public codecvt<Elem, char, mbstate_t> // : public codecvt<Elem, char, mbstate_t>
// { // {
// // unspecified // // unspecified
// }; // };
Show All 30 Lines

libcxx/test/std/localization/locale.stdcvt/codecvt_utf16_always_noconv.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <codecvt> // <codecvt>
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
// template <class Elem, unsigned long Maxcode = 0x10ffff, // template <class Elem, unsigned long Maxcode = 0x10ffff,
// codecvt_mode Mode = (codecvt_mode)0> // codecvt_mode Mode = (codecvt_mode)0>
// class codecvt_utf16 // class codecvt_utf16
// : public codecvt<Elem, char, mbstate_t> // : public codecvt<Elem, char, mbstate_t>
// { // {
// // unspecified // // unspecified
// }; // };
Show All 32 Lines

libcxx/test/std/localization/locale.stdcvt/codecvt_utf16_encoding.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <codecvt> // <codecvt>
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
// template <class Elem, unsigned long Maxcode = 0x10ffff, // template <class Elem, unsigned long Maxcode = 0x10ffff,
// codecvt_mode Mode = (codecvt_mode)0> // codecvt_mode Mode = (codecvt_mode)0>
// class codecvt_utf16 // class codecvt_utf16
// : public codecvt<Elem, char, mbstate_t> // : public codecvt<Elem, char, mbstate_t>
// { // {
// // unspecified // // unspecified
// }; // };
Show All 32 Lines

libcxx/test/std/localization/locale.stdcvt/codecvt_utf16_in.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <codecvt> // <codecvt>
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
// template <class Elem, unsigned long Maxcode = 0x10ffff, // template <class Elem, unsigned long Maxcode = 0x10ffff,
// codecvt_mode Mode = (codecvt_mode)0> // codecvt_mode Mode = (codecvt_mode)0>
// class codecvt_utf16 // class codecvt_utf16
// : public codecvt<Elem, char, mbstate_t> // : public codecvt<Elem, char, mbstate_t>
// { // {
// // unspecified // // unspecified
// }; // };
▲ Show 20 Lines • Show All 724 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.stdcvt/codecvt_utf16_length.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <codecvt> // <codecvt>
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
// template <class Elem, unsigned long Maxcode = 0x10ffff, // template <class Elem, unsigned long Maxcode = 0x10ffff,
// codecvt_mode Mode = (codecvt_mode)0> // codecvt_mode Mode = (codecvt_mode)0>
// class codecvt_utf16 // class codecvt_utf16
// : public codecvt<Elem, char, mbstate_t> // : public codecvt<Elem, char, mbstate_t>
// { // {
// // unspecified // // unspecified
// }; // };
▲ Show 20 Lines • Show All 311 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.stdcvt/codecvt_utf16_max_length.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <codecvt> // <codecvt>
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
// template <class Elem, unsigned long Maxcode = 0x10ffff, // template <class Elem, unsigned long Maxcode = 0x10ffff,
// codecvt_mode Mode = (codecvt_mode)0> // codecvt_mode Mode = (codecvt_mode)0>
// class codecvt_utf16 // class codecvt_utf16
// : public codecvt<Elem, char, mbstate_t> // : public codecvt<Elem, char, mbstate_t>
// { // {
// // unspecified // // unspecified
// }; // };
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.stdcvt/codecvt_utf16_out.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <codecvt> // <codecvt>
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
// template <class Elem, unsigned long Maxcode = 0x10ffff, // template <class Elem, unsigned long Maxcode = 0x10ffff,
// codecvt_mode Mode = (codecvt_mode)0> // codecvt_mode Mode = (codecvt_mode)0>
// class codecvt_utf16 // class codecvt_utf16
// : public codecvt<Elem, char, mbstate_t> // : public codecvt<Elem, char, mbstate_t>
// { // {
// // unspecified // // unspecified
// }; // };
▲ Show 20 Lines • Show All 340 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.stdcvt/codecvt_utf16_unshift.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <codecvt> // <codecvt>
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
// template <class Elem, unsigned long Maxcode = 0x10ffff, // template <class Elem, unsigned long Maxcode = 0x10ffff,
// codecvt_mode Mode = (codecvt_mode)0> // codecvt_mode Mode = (codecvt_mode)0>
// class codecvt_utf16 // class codecvt_utf16
// : public codecvt<Elem, char, mbstate_t> // : public codecvt<Elem, char, mbstate_t>
// { // {
// // unspecified // // unspecified
// }; // };
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.stdcvt/codecvt_utf8.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <codecvt> // <codecvt>
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
// template <class Elem, unsigned long Maxcode = 0x10ffff, // template <class Elem, unsigned long Maxcode = 0x10ffff,
// codecvt_mode Mode = (codecvt_mode)0> // codecvt_mode Mode = (codecvt_mode)0>
// class codecvt_utf8 // class codecvt_utf8
// : public codecvt<Elem, char, mbstate_t> // : public codecvt<Elem, char, mbstate_t>
// { // {
// // unspecified // // unspecified
// }; // };
Show All 30 Lines

libcxx/test/std/localization/locale.stdcvt/codecvt_utf8_always_noconv.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <codecvt> // <codecvt>
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
// template <class Elem, unsigned long Maxcode = 0x10ffff, // template <class Elem, unsigned long Maxcode = 0x10ffff,
// codecvt_mode Mode = (codecvt_mode)0> // codecvt_mode Mode = (codecvt_mode)0>
// class codecvt_utf8 // class codecvt_utf8
// : public codecvt<Elem, char, mbstate_t> // : public codecvt<Elem, char, mbstate_t>
// { // {
// // unspecified // // unspecified
// }; // };
Show All 32 Lines

libcxx/test/std/localization/locale.stdcvt/codecvt_utf8_encoding.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <codecvt> // <codecvt>
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
// template <class Elem, unsigned long Maxcode = 0x10ffff, // template <class Elem, unsigned long Maxcode = 0x10ffff,
// codecvt_mode Mode = (codecvt_mode)0> // codecvt_mode Mode = (codecvt_mode)0>
// class codecvt_utf8 // class codecvt_utf8
// : public codecvt<Elem, char, mbstate_t> // : public codecvt<Elem, char, mbstate_t>
// { // {
// // unspecified // // unspecified
// }; // };
Show All 32 Lines

libcxx/test/std/localization/locale.stdcvt/codecvt_utf8_in.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <codecvt> // <codecvt>
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
// template <class Elem, unsigned long Maxcode = 0x10ffff, // template <class Elem, unsigned long Maxcode = 0x10ffff,
// codecvt_mode Mode = (codecvt_mode)0> // codecvt_mode Mode = (codecvt_mode)0>
// class codecvt_utf8 // class codecvt_utf8
// : public codecvt<Elem, char, mbstate_t> // : public codecvt<Elem, char, mbstate_t>
// { // {
// // unspecified // // unspecified
// }; // };
▲ Show 20 Lines • Show All 345 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.stdcvt/codecvt_utf8_length.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <codecvt> // <codecvt>
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
// template <class Elem, unsigned long Maxcode = 0x10ffff, // template <class Elem, unsigned long Maxcode = 0x10ffff,
// codecvt_mode Mode = (codecvt_mode)0> // codecvt_mode Mode = (codecvt_mode)0>
// class codecvt_utf8 // class codecvt_utf8
// : public codecvt<Elem, char, mbstate_t> // : public codecvt<Elem, char, mbstate_t>
// { // {
// // unspecified // // unspecified
// }; // };
▲ Show 20 Lines • Show All 181 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.stdcvt/codecvt_utf8_max_length.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <codecvt> // <codecvt>
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
// template <class Elem, unsigned long Maxcode = 0x10ffff, // template <class Elem, unsigned long Maxcode = 0x10ffff,
// codecvt_mode Mode = (codecvt_mode)0> // codecvt_mode Mode = (codecvt_mode)0>
// class codecvt_utf8 // class codecvt_utf8
// : public codecvt<Elem, char, mbstate_t> // : public codecvt<Elem, char, mbstate_t>
// { // {
// // unspecified // // unspecified
// }; // };
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.stdcvt/codecvt_utf8_out.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <codecvt> // <codecvt>
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
// template <class Elem, unsigned long Maxcode = 0x10ffff, // template <class Elem, unsigned long Maxcode = 0x10ffff,
// codecvt_mode Mode = (codecvt_mode)0> // codecvt_mode Mode = (codecvt_mode)0>
// class codecvt_utf8 // class codecvt_utf8
// : public codecvt<Elem, char, mbstate_t> // : public codecvt<Elem, char, mbstate_t>
// { // {
// // unspecified // // unspecified
// }; // };
▲ Show 20 Lines • Show All 313 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.stdcvt/codecvt_utf8_unshift.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <codecvt> // <codecvt>
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
// template <class Elem, unsigned long Maxcode = 0x10ffff, // template <class Elem, unsigned long Maxcode = 0x10ffff,
// codecvt_mode Mode = (codecvt_mode)0> // codecvt_mode Mode = (codecvt_mode)0>
// class codecvt_utf8 // class codecvt_utf8
// : public codecvt<Elem, char, mbstate_t> // : public codecvt<Elem, char, mbstate_t>
// { // {
// // unspecified // // unspecified
// }; // };
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_always_noconv.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <codecvt> // <codecvt>
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
// template <class Elem, unsigned long Maxcode = 0x10ffff, // template <class Elem, unsigned long Maxcode = 0x10ffff,
// codecvt_mode Mode = (codecvt_mode)0> // codecvt_mode Mode = (codecvt_mode)0>
// class codecvt_utf8_utf16 // class codecvt_utf8_utf16
// : public codecvt<Elem, char, mbstate_t> // : public codecvt<Elem, char, mbstate_t>
// { // {
// // unspecified // // unspecified
// }; // };
Show All 32 Lines

libcxx/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_encoding.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <codecvt> // <codecvt>
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
// template <class Elem, unsigned long Maxcode = 0x10ffff, // template <class Elem, unsigned long Maxcode = 0x10ffff,
// codecvt_mode Mode = (codecvt_mode)0> // codecvt_mode Mode = (codecvt_mode)0>
// class codecvt_utf8_utf16 // class codecvt_utf8_utf16
// : public codecvt<Elem, char, mbstate_t> // : public codecvt<Elem, char, mbstate_t>
// { // {
// // unspecified // // unspecified
// }; // };
Show All 32 Lines

libcxx/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_in.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <codecvt> // <codecvt>
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
// template <class Elem, unsigned long Maxcode = 0x10ffff, // template <class Elem, unsigned long Maxcode = 0x10ffff,
// codecvt_mode Mode = (codecvt_mode)0> // codecvt_mode Mode = (codecvt_mode)0>
// class codecvt_utf8_utf16 // class codecvt_utf8_utf16
// : public codecvt<Elem, char, mbstate_t> // : public codecvt<Elem, char, mbstate_t>
// { // {
// // unspecified // // unspecified
// }; // };
▲ Show 20 Lines • Show All 229 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_length.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <codecvt> // <codecvt>
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
// template <class Elem, unsigned long Maxcode = 0x10ffff, // template <class Elem, unsigned long Maxcode = 0x10ffff,
// codecvt_mode Mode = (codecvt_mode)0> // codecvt_mode Mode = (codecvt_mode)0>
// class codecvt_utf8_utf16 // class codecvt_utf8_utf16
// : public codecvt<Elem, char, mbstate_t> // : public codecvt<Elem, char, mbstate_t>
// { // {
// // unspecified // // unspecified
// }; // };
▲ Show 20 Lines • Show All 222 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_max_length.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <codecvt> // <codecvt>
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
// template <class Elem, unsigned long Maxcode = 0x10ffff, // template <class Elem, unsigned long Maxcode = 0x10ffff,
// codecvt_mode Mode = (codecvt_mode)0> // codecvt_mode Mode = (codecvt_mode)0>
// class codecvt_utf8_utf16 // class codecvt_utf8_utf16
// : public codecvt<Elem, char, mbstate_t> // : public codecvt<Elem, char, mbstate_t>
// { // {
// // unspecified // // unspecified
// }; // };
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_out.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <codecvt> // <codecvt>
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
// template <class Elem, unsigned long Maxcode = 0x10ffff, // template <class Elem, unsigned long Maxcode = 0x10ffff,
// codecvt_mode Mode = (codecvt_mode)0> // codecvt_mode Mode = (codecvt_mode)0>
// class codecvt_utf8_utf16 // class codecvt_utf8_utf16
// : public codecvt<Elem, char, mbstate_t> // : public codecvt<Elem, char, mbstate_t>
// { // {
// // unspecified // // unspecified
// }; // };
▲ Show 20 Lines • Show All 294 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_unshift.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <codecvt> // <codecvt>
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
// template <class Elem, unsigned long Maxcode = 0x10ffff, // template <class Elem, unsigned long Maxcode = 0x10ffff,
// codecvt_mode Mode = (codecvt_mode)0> // codecvt_mode Mode = (codecvt_mode)0>
// class codecvt_utf8_utf16 // class codecvt_utf8_utf16
// : public codecvt<Elem, char, mbstate_t> // : public codecvt<Elem, char, mbstate_t>
// { // {
// // unspecified // // unspecified
// }; // };
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

libcxx/test/std/localization/locale.stdcvt/depr.verify.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, c++11, c++14
// <codecvt>
// ensure that codecvt content is marked as deprecated
#include <codecvt>
std::codecvt_mode c1; // expected-warning {{'codecvt_mode' is deprecated}}
std::codecvt_utf8<wchar_t> c2; // expected-warning {{'codecvt_utf8<wchar_t, 1114111, 0>' is deprecated}}
std::codecvt_utf16<wchar_t> c3; // expected-warning {{'codecvt_utf16<wchar_t, 1114111, 0>' is deprecated}}
std::codecvt_utf8_utf16<wchar_t> c4; // expected-warning {{'codecvt_utf8_utf16<wchar_t, 1114111, 0>' is deprecated}}

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/ctor.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <locale> // <locale>
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
// wbuffer_convert<Codecvt, Elem, Tr> // wbuffer_convert<Codecvt, Elem, Tr>
// wbuffer_convert(streambuf* bytebuf = 0, Codecvt* pcvt = new Codecvt, // wbuffer_convert(streambuf* bytebuf = 0, Codecvt* pcvt = new Codecvt,
// state_type state = state_type()); // before C++14 // state_type state = state_type()); // before C++14
// explicit wbuffer_convert(streambuf* bytebuf = nullptr, Codecvt* pcvt = new Codecvt, // explicit wbuffer_convert(streambuf* bytebuf = nullptr, Codecvt* pcvt = new Codecvt,
// state_type state = state_type()); // before C++20 // state_type state = state_type()); // before C++20
// wbuffer_convert() : wbuffer_convert(nullptr) {} // C++20 // wbuffer_convert() : wbuffer_convert(nullptr) {} // C++20
// explicit wbuffer_convert(streambuf* bytebuf, Codecvt* pcvt = new Codecvt, // explicit wbuffer_convert(streambuf* bytebuf, Codecvt* pcvt = new Codecvt,
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/depr.verify.cpp

  • This file was copied from libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/state.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
ldionneUnsubmitted
Not Done
ReplyInline Actions

I think you'll need to handle no-localization and no-wide-characters here.

ldionne: I think you'll need to handle `no-localization` and `no-wide-characters` here.
// <locale> // UNSUPPORTED: c++03, c++11, c++14
// wbuffer_convert<Codecvt, Elem, Tr> // <codecvt>
// state_type state() const; // ensure that wbuffer_convert is marked as deprecated
// XFAIL: no-wide-characters
#include <locale>
#include <codecvt> #include <codecvt>
#include <sstream> #include <locale>
#include <cassert>
#include "test_macros.h"
int main(int, char**)
{
typedef std::wbuffer_convert<std::codecvt_utf8<wchar_t> > B;
{
B b;
std::mbstate_t s = b.state();
((void)s);
}
return 0; std::wbuffer_convert<std::codecvt_utf8<wchar_t>> c1; // expected-warning {{'wbuffer_convert<std::codecvt_utf8<wchar_t, 1114111, 0>>' is deprecated}}
} // expected-warning@-1 {{'codecvt_utf8<wchar_t, 1114111, 0>' is deprecated}}

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/overflow.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <locale> // <locale>
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
// wbuffer_convert<Codecvt, Elem, Tr> // wbuffer_convert<Codecvt, Elem, Tr>
// int_type overflow(int_type c = traits::eof()); // int_type overflow(int_type c = traits::eof());
// This test is not entirely portable // This test is not entirely portable
// XFAIL: no-wide-characters // XFAIL: no-wide-characters
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/pbackfail.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// FILE_DEPENDENCIES: underflow.dat // FILE_DEPENDENCIES: underflow.dat
// <locale> // <locale>
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
// wbuffer_convert<Codecvt, Elem, Tr> // wbuffer_convert<Codecvt, Elem, Tr>
// int_type pbackfail(int_type c = traits::eof()); // int_type pbackfail(int_type c = traits::eof());
// This test is not entirely portable // This test is not entirely portable
// XFAIL: no-wide-characters // XFAIL: no-wide-characters
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/rdbuf.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <locale> // <locale>
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
// wbuffer_convert<Codecvt, Elem, Tr> // wbuffer_convert<Codecvt, Elem, Tr>
// streambuf *rdbuf(streambuf *bytebuf); // streambuf *rdbuf(streambuf *bytebuf);
// XFAIL: no-wide-characters // XFAIL: no-wide-characters
#include <locale> #include <locale>
#include <codecvt> #include <codecvt>
Show All 18 Lines

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/seekoff.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <locale> // <locale>
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
// wbuffer_convert<Codecvt, Elem, Tr> // wbuffer_convert<Codecvt, Elem, Tr>
// pos_type seekoff(off_type off, ios_base::seekdir way, // pos_type seekoff(off_type off, ios_base::seekdir way,
// ios_base::openmode which = ios_base::in | ios_base::out); // ios_base::openmode which = ios_base::in | ios_base::out);
// pos_type seekpos(pos_type sp, // pos_type seekpos(pos_type sp,
// ios_base::openmode which = ios_base::in | ios_base::out); // ios_base::openmode which = ios_base::in | ios_base::out);
// This test is not entirely portable // This test is not entirely portable
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/state.pass.cpp

  • This file was copied to libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/depr.verify.cpp, libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.string/depr.verify.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <locale> // <locale>
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
// wbuffer_convert<Codecvt, Elem, Tr> // wbuffer_convert<Codecvt, Elem, Tr>
// state_type state() const; // state_type state() const;
// XFAIL: no-wide-characters // XFAIL: no-wide-characters
#include <locale> #include <locale>
#include <codecvt> #include <codecvt>
Show All 16 Lines

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/test.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <locale> // <locale>
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
// wbuffer_convert<Codecvt, Elem, Tr> // wbuffer_convert<Codecvt, Elem, Tr>
// XFAIL: no-wide-characters // XFAIL: no-wide-characters
#include <fstream> #include <fstream>
#include <locale> #include <locale>
#include <codecvt> #include <codecvt>
#include <cassert> #include <cassert>
Show All 23 Lines

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/underflow.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// FILE_DEPENDENCIES: underflow.dat, underflow_utf8.dat // FILE_DEPENDENCIES: underflow.dat, underflow_utf8.dat
// <locale> // <locale>
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
// wbuffer_convert<Codecvt, Elem, Tr> // wbuffer_convert<Codecvt, Elem, Tr>
// int_type underflow(); // int_type underflow();
// This test is not entirely portable // This test is not entirely portable
// XFAIL: no-wide-characters // XFAIL: no-wide-characters
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.string/converted.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <locale> // <locale>
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
// wstring_convert<Codecvt, Elem, Wide_alloc, Byte_alloc> // wstring_convert<Codecvt, Elem, Wide_alloc, Byte_alloc>
// size_t converted() const; // size_t converted() const;
// XFAIL: no-wide-characters // XFAIL: no-wide-characters
#include <locale> #include <locale>
#include <codecvt> #include <codecvt>
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_codecvt.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <locale> // <locale>
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
// wstring_convert<Codecvt, Elem, Wide_alloc, Byte_alloc> // wstring_convert<Codecvt, Elem, Wide_alloc, Byte_alloc>
// wstring_convert(Codecvt* pcvt = new Codecvt); // before C++14 // wstring_convert(Codecvt* pcvt = new Codecvt); // before C++14
// explicit wstring_convert(Codecvt* pcvt = new Codecvt); // before C++20 // explicit wstring_convert(Codecvt* pcvt = new Codecvt); // before C++20
// wstring_convert() : wstring_convert(new Codecvt) {} // C++20 // wstring_convert() : wstring_convert(new Codecvt) {} // C++20
// explicit wstring_convert(Codecvt* pcvt); // C++20 // explicit wstring_convert(Codecvt* pcvt); // C++20
// XFAIL: no-wide-characters // XFAIL: no-wide-characters
Show All 40 Lines

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_codecvt_state.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <locale> // <locale>
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
// wstring_convert<Codecvt, Elem, Wide_alloc, Byte_alloc> // wstring_convert<Codecvt, Elem, Wide_alloc, Byte_alloc>
// wstring_convert(Codecvt* pcvt, state_type state); // wstring_convert(Codecvt* pcvt, state_type state);
// XFAIL: no-wide-characters // XFAIL: no-wide-characters
#include <locale> #include <locale>
#include <codecvt> #include <codecvt>
Show All 15 Lines

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_copy.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// These constructors are still unavailable in C++03, but this test depends // These constructors are still unavailable in C++03, but this test depends
// on access control SFINAE and fails without it. // on access control SFINAE and fails without it.
// UNSUPPORTED: c++03 // UNSUPPORTED: c++03
// <locale> // <locale>
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
// wstring_convert<Codecvt, Elem, Wide_alloc, Byte_alloc> // wstring_convert<Codecvt, Elem, Wide_alloc, Byte_alloc>
// wstring_convert(wstring_convert const&) = delete; // wstring_convert(wstring_convert const&) = delete;
// wstring_convert& operator=(wstring_convert const&) = delete; // wstring_convert& operator=(wstring_convert const&) = delete;
// XFAIL: no-wide-characters // XFAIL: no-wide-characters
#include <locale> #include <locale>
Show All 14 Lines

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_err_string.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <locale> // <locale>
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
// wstring_convert<Codecvt, Elem, Wide_alloc, Byte_alloc> // wstring_convert<Codecvt, Elem, Wide_alloc, Byte_alloc>
// wstring_convert(const byte_string& byte_err, // wstring_convert(const byte_string& byte_err,
// const wide_string& wide_err = wide_string()); // const wide_string& wide_err = wide_string());
// XFAIL: no-wide-characters // XFAIL: no-wide-characters
#include <locale> #include <locale>
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.string/depr.verify.cpp

  • This file was copied from libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/state.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <locale> // UNSUPPORTED: c++03, c++11, c++14
// wbuffer_convert<Codecvt, Elem, Tr> // <codecvt>
// state_type state() const; // ensure that wstring_convert is marked as deprecated
// XFAIL: no-wide-characters
#include <locale>
#include <codecvt> #include <codecvt>
#include <sstream> #include <locale>
#include <cassert>
#include "test_macros.h"
int main(int, char**)
{
typedef std::wbuffer_convert<std::codecvt_utf8<wchar_t> > B;
{
B b;
std::mbstate_t s = b.state();
((void)s);
}
return 0; std::wstring_convert<std::codecvt_utf8<wchar_t>> c1; // expected-warning {{'wstring_convert<std::codecvt_utf8<wchar_t, 1114111, 0>>' is deprecated}}
} // expected-warning@-1 {{'codecvt_utf8<wchar_t, 1114111, 0>' is deprecated}}

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.string/from_bytes.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <locale> // <locale>
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
// wstring_convert<Codecvt, Elem, Wide_alloc, Byte_alloc> // wstring_convert<Codecvt, Elem, Wide_alloc, Byte_alloc>
// wide_string from_bytes(char byte); // wide_string from_bytes(char byte);
// wide_string from_bytes(const char* ptr); // wide_string from_bytes(const char* ptr);
// wide_string from_bytes(const byte_string& str); // wide_string from_bytes(const byte_string& str);
// wide_string from_bytes(const char* first, const char* last); // wide_string from_bytes(const char* first, const char* last);
// XFAIL: no-wide-characters // XFAIL: no-wide-characters
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.string/state.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <locale> // <locale>
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
// wstring_convert<Codecvt, Elem, Wide_alloc, Byte_alloc> // wstring_convert<Codecvt, Elem, Wide_alloc, Byte_alloc>
// state_type state() const; // state_type state() const;
// XFAIL: no-wide-characters // XFAIL: no-wide-characters
#include <locale> #include <locale>
#include <codecvt> #include <codecvt>
Show All 13 Lines

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.string/to_bytes.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <locale> // <locale>
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
// wstring_convert<Codecvt, Elem, Wide_alloc, Byte_alloc> // wstring_convert<Codecvt, Elem, Wide_alloc, Byte_alloc>
// byte_string to_bytes(Elem wchar); // byte_string to_bytes(Elem wchar);
// byte_string to_bytes(const Elem* wptr); // byte_string to_bytes(const Elem* wptr);
// byte_string to_bytes(const wide_string& wstr); // byte_string to_bytes(const wide_string& wstr);
// byte_string to_bytes(const Elem* first, const Elem* last); // byte_string to_bytes(const Elem* first, const Elem* last);
// XFAIL: no-wide-characters // XFAIL: no-wide-characters
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.string/types.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <locale> // <locale>
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
// template<class Codecvt, class Elem = wchar_t, // template<class Codecvt, class Elem = wchar_t,
// class Wide_alloc = allocator<Elem>, // class Wide_alloc = allocator<Elem>,
// class Byte_alloc = allocator<char>> // class Byte_alloc = allocator<char>>
// class wstring_convert // class wstring_convert
// { // {
// public: // public:
// typedef basic_string<char, char_traits<char>, Byte_alloc> byte_string; // typedef basic_string<char, char_traits<char>, Byte_alloc> byte_string;
// typedef basic_string<Elem, char_traits<Elem>, Wide_alloc> wide_string; // typedef basic_string<Elem, char_traits<Elem>, Wide_alloc> wide_string;
Show All 22 Lines

llvm/CMakeLists.txt

Show First 20 Lines • Show All 740 Lines • ▼ Show 20 Lines
if(CMAKE_HOST_APPLE AND APPLE) if(CMAKE_HOST_APPLE AND APPLE)
include(UseLibtool) include(UseLibtool)
endif() endif()
# Override the default target with an environment variable named by LLVM_TARGET_TRIPLE_ENV. # Override the default target with an environment variable named by LLVM_TARGET_TRIPLE_ENV.
set(LLVM_TARGET_TRIPLE_ENV CACHE STRING "The name of environment variable to override default target. Disabled by blank.") set(LLVM_TARGET_TRIPLE_ENV CACHE STRING "The name of environment variable to override default target. Disabled by blank.")
mark_as_advanced(LLVM_TARGET_TRIPLE_ENV) mark_as_advanced(LLVM_TARGET_TRIPLE_ENV)
set(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR OFF CACHE BOOL if(CMAKE_SYSTEM_NAME MATCHES "Linux")
set(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR_default ON)
else()
set(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR_default OFF)
endif()
set(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR ${LLVM_ENABLE_PER_TARGET_RUNTIME_DIR_default} CACHE BOOL
"Enable per-target runtimes directory") "Enable per-target runtimes directory")
set(LLVM_PROFDATA_FILE "" CACHE FILEPATH set(LLVM_PROFDATA_FILE "" CACHE FILEPATH
"Profiling data file to use when compiling in order to improve runtime performance.") "Profiling data file to use when compiling in order to improve runtime performance.")
# All options referred to from HandleLLVMOptions have to be specified # All options referred to from HandleLLVMOptions have to be specified
# BEFORE this include, otherwise options will not be correctly set on # BEFORE this include, otherwise options will not be correctly set on
# first cmake run # first cmake run
▲ Show 20 Lines • Show All 525 Lines • Show Last 20 Lines

llvm/docs/OpaquePointers.rst

Show First 20 Lines • Show All 216 Lines • ▼ Show 20 Lines
For users of LLVM tools like opt, opaque pointers can be disabled by passing For users of LLVM tools like opt, opaque pointers can be disabled by passing
``-opaque-pointers=0``. ``-opaque-pointers=0``.
The next steps for the opaque pointer migration are: The next steps for the opaque pointer migration are:
* Migrate Clang/LLVM tests to use opaque pointers. * Migrate Clang/LLVM tests to use opaque pointers.
* Remove support for typed pointers after the LLVM 15 branch has been created. * Remove support for typed pointers after the LLVM 15 branch has been created.
Version Support
===============
**LLVM 14:** Supports all necessary APIs for migrating to opaque pointers and deprecates/removes incompatible APIs. However, using opaque pointers in the optimization pipeline is **not** fully supported. This release can be used to make out-of-tree code compatible with opaque pointers, but opaque pointers should **not** be enabled in production.
**LLVM 15:** Opaque pointers are enabled by default. Typed pointers are still available, but only supported on a best-effort basis and may be untested.
**LLVM 16:** Only opaque pointers will be supported. Typed pointers will not be supported.

llvm/docs/ProgrammersManual.rst

Show First 20 Lines • Show All 1,699 Lines • ▼ Show 20 Lines
``ilist`` has the same drawbacks as ``std::list``, and additionally requires an ``ilist`` has the same drawbacks as ``std::list``, and additionally requires an
``ilist_traits`` implementation for the element type, but it provides some novel ``ilist_traits`` implementation for the element type, but it provides some novel
characteristics. In particular, it can efficiently store polymorphic objects, characteristics. In particular, it can efficiently store polymorphic objects,
the traits class is informed when an element is inserted or removed from the the traits class is informed when an element is inserted or removed from the
list, and ``ilist``\ s are guaranteed to support a constant-time splice list, and ``ilist``\ s are guaranteed to support a constant-time splice
operation. operation.
An ``ilist`` and an ``iplist`` are ``using`` aliases to one another and the
latter only currently exists for historical purposes.
These properties are exactly what we want for things like ``Instruction``\ s and These properties are exactly what we want for things like ``Instruction``\ s and
basic blocks, which is why these are implemented with ``ilist``\ s. basic blocks, which is why these are implemented with ``ilist``\ s.
Related classes of interest are explained in the following subsections: Related classes of interest are explained in the following subsections:
* :ref:`ilist_traits <dss_ilist_traits>` * :ref:`ilist_traits <dss_ilist_traits>`
* :ref:`iplist <dss_iplist>`
* :ref:`llvm/ADT/ilist_node.h <dss_ilist_node>` * :ref:`llvm/ADT/ilist_node.h <dss_ilist_node>`
* :ref:`Sentinels <dss_ilist_sentinel>` * :ref:`Sentinels <dss_ilist_sentinel>`
.. _dss_packedvector: .. _dss_packedvector:
llvm/ADT/PackedVector.h llvm/ADT/PackedVector.h
^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^
Show All 24 Lines State get() {
return Vec1[0]; // returns 'Both'. return Vec1[0]; // returns 'Both'.
} }
.. _dss_ilist_traits: .. _dss_ilist_traits:
ilist_traits ilist_traits
^^^^^^^^^^^^ ^^^^^^^^^^^^
``ilist_traits<T>`` is ``ilist<T>``'s customization mechanism. ``iplist<T>`` ``ilist_traits<T>`` is ``ilist<T>``'s customization mechanism. ``ilist<T>``
(and consequently ``ilist<T>``) publicly derive from this traits class. publicly derives from this traits class.
.. _dss_iplist:
iplist
^^^^^^
``iplist<T>`` is ``ilist<T>``'s base and as such supports a slightly narrower
interface. Notably, inserters from ``T&`` are absent.
``ilist_traits<T>`` is a public base of this class and can be used for a wide
variety of customizations.
.. _dss_ilist_node: .. _dss_ilist_node:
llvm/ADT/ilist_node.h llvm/ADT/ilist_node.h
^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^
``ilist_node<T>`` implements the forward and backward links that are expected ``ilist_node<T>`` implements the forward and backward links that are expected
by the ``ilist<T>`` (and analogous containers) in the default manner. by the ``ilist<T>`` (and analogous containers) in the default manner.
▲ Show 20 Lines • Show All 2,318 Lines • Show Last 20 Lines

llvm/docs/ReleaseNotes.rst

Show First 20 Lines • Show All 96 Lines • ▼ Show 20 Lines
* Added support for the Armv9-A, Armv9.1-A and Armv9.2-A architectures. * Added support for the Armv9-A, Armv9.1-A and Armv9.2-A architectures.
* Added support for the Armv8.1-M PACBTI-M extension. * Added support for the Armv8.1-M PACBTI-M extension.
* Removed the deprecation of ARMv8-A T32 Complex IT blocks. No deprecation * Removed the deprecation of ARMv8-A T32 Complex IT blocks. No deprecation
warnings will be generated and -mrestrict-it is now always off by default. warnings will be generated and -mrestrict-it is now always off by default.
Previously it was on by default for Armv8 and off for all other architecture Previously it was on by default for Armv8 and off for all other architecture
versions. versions.
* Added a pass to workaround Cortex-A57 Erratum 1742098 and Cortex-A72 * Added a pass to workaround Cortex-A57 Erratum 1742098 and Cortex-A72
Erratum 1655431. This is enabled by default when targeting either CPU. Erratum 1655431. This is enabled by default when targeting either CPU.
* Implemented generation of Windows SEH unwind information.
* Switched the MinGW target to use SEH instead of DWARF for unwind information.
Changes to the AVR Backend Changes to the AVR Backend
-------------------------- --------------------------
* ... * ...
Changes to the Hexagon Backend Changes to the Hexagon Backend
------------------------------ ------------------------------
▲ Show 20 Lines • Show All 111 Lines • Show Last 20 Lines

llvm/include/llvm/ADT/edit_distance.h

Show First 20 Lines • Show All 55 Lines • ▼ Show 20 Linesunsigned ComputeMappedEditDistance(ArrayRef<T> FromArray, ArrayRef<T> ToArray,
// array, only one row plus one element are used at a time, so this // array, only one row plus one element are used at a time, so this
// implementation just keeps one vector for the row. To update one entry, // implementation just keeps one vector for the row. To update one entry,
// only the entries to the left, top, and top-left are needed. The left // only the entries to the left, top, and top-left are needed. The left
// entry is in Row[x-1], the top entry is what's in Row[x] from the last // entry is in Row[x-1], the top entry is what's in Row[x] from the last
// iteration, and the top-left entry is stored in Previous. // iteration, and the top-left entry is stored in Previous.
typename ArrayRef<T>::size_type m = FromArray.size(); typename ArrayRef<T>::size_type m = FromArray.size();
typename ArrayRef<T>::size_type n = ToArray.size(); typename ArrayRef<T>::size_type n = ToArray.size();
if (MaxEditDistance) {
// If the difference in size between the 2 arrays is larger than the max
// distance allowed, we can bail out as we will always need at least
// MaxEditDistance insertions or removals.
typename ArrayRef<T>::size_type AbsDiff = m > n ? m - n : n - m;
if (AbsDiff > MaxEditDistance)
return MaxEditDistance + 1;
}
const unsigned SmallBufferSize = 64; const unsigned SmallBufferSize = 64;
unsigned SmallBuffer[SmallBufferSize]; unsigned SmallBuffer[SmallBufferSize];
std::unique_ptr<unsigned[]> Allocated; std::unique_ptr<unsigned[]> Allocated;
unsigned *Row = SmallBuffer; unsigned *Row = SmallBuffer;
if (n + 1 > SmallBufferSize) { if (n + 1 > SmallBufferSize) {
Row = new unsigned[n + 1]; Row = new unsigned[n + 1];
Allocated.reset(Row); Allocated.reset(Row);
} }
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

llvm/include/llvm/Support/TypeSize.h

Show First 20 Lines • Show All 367 Lines • ▼ Show 20 Linespublic:
} }
LeafTy coefficientNextPowerOf2() const { LeafTy coefficientNextPowerOf2() const {
return static_cast<LeafTy>(LinearPolySize::get( return static_cast<LeafTy>(LinearPolySize::get(
static_cast<ScalarTy>(llvm::NextPowerOf2(getKnownMinValue())), static_cast<ScalarTy>(llvm::NextPowerOf2(getKnownMinValue())),
isScalable())); isScalable()));
} }
/// Returns true if there exists a value X where RHS.multiplyCoefficientBy(X)
/// will result in a value whose size matches our own.
bool hasKnownScalarFactor(const LinearPolySize &RHS) const {
return isScalable() == RHS.isScalable() &&
getKnownMinValue() % RHS.getKnownMinValue() == 0;
}
/// Returns a value X where RHS.multiplyCoefficientBy(X) will result in a
/// value whose size matches our own.
ScalarTy getKnownScalarFactor(const LinearPolySize &RHS) const {
assert(hasKnownScalarFactor(RHS) && "Expected RHS to be a known factor!");
return getKnownMinValue() / RHS.getKnownMinValue();
}
/// Printing function. /// Printing function.
void print(raw_ostream &OS) const { void print(raw_ostream &OS) const {
if (isScalable()) if (isScalable())
OS << "vscale x "; OS << "vscale x ";
OS << getKnownMinValue(); OS << getKnownMinValue();
} }
}; };
▲ Show 20 Lines • Show All 146 Lines • Show Last 20 Lines

llvm/lib/Analysis/MemoryDependenceAnalysis.cpp

Show First 20 Lines • Show All 728 Lines • ▼ Show 20 Lines if (!Cache.empty()) {
for (auto &Entry : Cache) for (auto &Entry : Cache)
if (Entry.getResult().isDirty()) if (Entry.getResult().isDirty())
DirtyBlocks.push_back(Entry.getBB()); DirtyBlocks.push_back(Entry.getBB());
// Sort the cache so that we can do fast binary search lookups below. // Sort the cache so that we can do fast binary search lookups below.
llvm::sort(Cache); llvm::sort(Cache);
++NumCacheDirtyNonLocal; ++NumCacheDirtyNonLocal;
// cerr << "CACHED CASE: " << DirtyBlocks.size() << " dirty: "
// << Cache.size() << " cached: " << *QueryInst;
} else { } else {
// Seed DirtyBlocks with each of the preds of QueryInst's block. // Seed DirtyBlocks with each of the preds of QueryInst's block.
BasicBlock *QueryBB = QueryCall->getParent(); BasicBlock *QueryBB = QueryCall->getParent();
append_range(DirtyBlocks, PredCache.get(QueryBB)); append_range(DirtyBlocks, PredCache.get(QueryBB));
++NumUncacheNonLocal; ++NumUncacheNonLocal;
} }
// isReadonlyCall - If this is a read-only call, we can be more aggressive. // isReadonlyCall - If this is a read-only call, we can be more aggressive.
▲ Show 20 Lines • Show All 1,051 Lines • Show Last 20 Lines

llvm/lib/Analysis/PHITransAddr.cpp

Show All 28 Linesstatic bool CanPHITrans(Instruction *Inst) {
if (isa<CastInst>(Inst) && if (isa<CastInst>(Inst) &&
isSafeToSpeculativelyExecute(Inst)) isSafeToSpeculativelyExecute(Inst))
return true; return true;
if (Inst->getOpcode() == Instruction::Add && if (Inst->getOpcode() == Instruction::Add &&
isa<ConstantInt>(Inst->getOperand(1))) isa<ConstantInt>(Inst->getOperand(1)))
return true; return true;
// cerr << "MEMDEP: Could not PHI translate: " << *Pointer;
// if (isa<BitCastInst>(PtrInst) || isa<GetElementPtrInst>(PtrInst))
// cerr << "OP:\t\t\t\t" << *PtrInst->getOperand(0);
return false; return false;
} }
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP) #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
LLVM_DUMP_METHOD void PHITransAddr::dump() const { LLVM_DUMP_METHOD void PHITransAddr::dump() const {
if (!Addr) { if (!Addr) {
dbgs() << "PHITransAddr: null\n"; dbgs() << "PHITransAddr: null\n";
return; return;
▲ Show 20 Lines • Show All 393 Lines • Show Last 20 Lines

llvm/lib/CodeGen/CodeGenPrepare.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 4,800 Lines • ▼ Show 20 Lines if (matchOperationAddr(I, I->getOpcode(), Depth, &MovedAway)) {
// register pressure too much. // register pressure too much.
if (I->hasOneUse() || if (I->hasOneUse() ||
isProfitableToFoldIntoAddressingMode(I, BackupAddrMode, AddrMode)) { isProfitableToFoldIntoAddressingMode(I, BackupAddrMode, AddrMode)) {
AddrModeInsts.push_back(I); AddrModeInsts.push_back(I);
return true; return true;
} }
// It isn't profitable to do this, roll back. // It isn't profitable to do this, roll back.
//cerr << "NOT FOLDING: " << *I;
AddrMode = BackupAddrMode; AddrMode = BackupAddrMode;
AddrModeInsts.resize(OldSize); AddrModeInsts.resize(OldSize);
TPT.rollback(LastKnownGood); TPT.rollback(LastKnownGood);
} }
} else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Addr)) { } else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Addr)) {
if (matchOperationAddr(CE, CE->getOpcode(), Depth)) if (matchOperationAddr(CE, CE->getOpcode(), Depth))
return true; return true;
TPT.rollback(LastKnownGood); TPT.rollback(LastKnownGood);
▲ Show 20 Lines • Show All 3,582 Lines • Show Last 20 Lines

llvm/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp

Show First 20 Lines • Show All 1,725 Lines • ▼ Show 20 Lines
SDValue SelectionDAGLegalize::EmitStackConvert(SDValue SrcOp, EVT SlotVT, SDValue SelectionDAGLegalize::EmitStackConvert(SDValue SrcOp, EVT SlotVT,
EVT DestVT, const SDLoc &dl) { EVT DestVT, const SDLoc &dl) {
return EmitStackConvert(SrcOp, SlotVT, DestVT, dl, DAG.getEntryNode()); return EmitStackConvert(SrcOp, SlotVT, DestVT, dl, DAG.getEntryNode());
} }
SDValue SelectionDAGLegalize::EmitStackConvert(SDValue SrcOp, EVT SlotVT, SDValue SelectionDAGLegalize::EmitStackConvert(SDValue SrcOp, EVT SlotVT,
EVT DestVT, const SDLoc &dl, EVT DestVT, const SDLoc &dl,
SDValue Chain) { SDValue Chain) {
unsigned SrcSize = SrcOp.getValueSizeInBits(); EVT SrcVT = SrcOp.getValueType();
unsigned SlotSize = SlotVT.getSizeInBits();
unsigned DestSize = DestVT.getSizeInBits();
Type *DestType = DestVT.getTypeForEVT(*DAG.getContext()); Type *DestType = DestVT.getTypeForEVT(*DAG.getContext());
Align DestAlign = DAG.getDataLayout().getPrefTypeAlign(DestType); Align DestAlign = DAG.getDataLayout().getPrefTypeAlign(DestType);
// Don't convert with stack if the load/store is expensive. // Don't convert with stack if the load/store is expensive.
if ((SrcSize > SlotSize && if ((SrcVT.bitsGT(SlotVT) &&
!TLI.isTruncStoreLegalOrCustom(SrcOp.getValueType(), SlotVT)) || !TLI.isTruncStoreLegalOrCustom(SrcOp.getValueType(), SlotVT)) ||
(SlotSize < DestSize && (SlotVT.bitsLT(DestVT) &&
!TLI.isLoadExtLegalOrCustom(ISD::EXTLOAD, DestVT, SlotVT))) !TLI.isLoadExtLegalOrCustom(ISD::EXTLOAD, DestVT, SlotVT)))
return SDValue(); return SDValue();
// Create the stack frame object. // Create the stack frame object.
Align SrcAlign = DAG.getDataLayout().getPrefTypeAlign( Align SrcAlign = DAG.getDataLayout().getPrefTypeAlign(
SrcOp.getValueType().getTypeForEVT(*DAG.getContext())); SrcOp.getValueType().getTypeForEVT(*DAG.getContext()));
SDValue FIPtr = DAG.CreateStackTemporary(SlotVT.getStoreSize(), SrcAlign); SDValue FIPtr = DAG.CreateStackTemporary(SlotVT.getStoreSize(), SrcAlign);
FrameIndexSDNode *StackPtrFI = cast<FrameIndexSDNode>(FIPtr); FrameIndexSDNode *StackPtrFI = cast<FrameIndexSDNode>(FIPtr);
int SPFI = StackPtrFI->getIndex(); int SPFI = StackPtrFI->getIndex();
MachinePointerInfo PtrInfo = MachinePointerInfo PtrInfo =
MachinePointerInfo::getFixedStack(DAG.getMachineFunction(), SPFI); MachinePointerInfo::getFixedStack(DAG.getMachineFunction(), SPFI);
// Emit a store to the stack slot. Use a truncstore if the input value is // Emit a store to the stack slot. Use a truncstore if the input value is
// later than DestVT. // later than DestVT.
SDValue Store; SDValue Store;
if (SrcSize > SlotSize) if (SrcVT.bitsGT(SlotVT))
Store = DAG.getTruncStore(Chain, dl, SrcOp, FIPtr, PtrInfo, Store = DAG.getTruncStore(Chain, dl, SrcOp, FIPtr, PtrInfo,
SlotVT, SrcAlign); SlotVT, SrcAlign);
else { else {
assert(SrcSize == SlotSize && "Invalid store"); assert(SrcVT.bitsEq(SlotVT) && "Invalid store");
Store = Store = DAG.getStore(Chain, dl, SrcOp, FIPtr, PtrInfo, SrcAlign);
DAG.getStore(Chain, dl, SrcOp, FIPtr, PtrInfo, SrcAlign);
} }
// Result is a load from the stack slot. // Result is a load from the stack slot.
if (SlotSize == DestSize) if (SlotVT.bitsEq(DestVT))
return DAG.getLoad(DestVT, dl, Store, FIPtr, PtrInfo, DestAlign); return DAG.getLoad(DestVT, dl, Store, FIPtr, PtrInfo, DestAlign);
assert(SlotSize < DestSize && "Unknown extension!"); assert(SlotVT.bitsLT(DestVT) && "Unknown extension!");
return DAG.getExtLoad(ISD::EXTLOAD, dl, DestVT, Store, FIPtr, PtrInfo, SlotVT, return DAG.getExtLoad(ISD::EXTLOAD, dl, DestVT, Store, FIPtr, PtrInfo, SlotVT,
DestAlign); DestAlign);
} }
SDValue SelectionDAGLegalize::ExpandSCALAR_TO_VECTOR(SDNode *Node) { SDValue SelectionDAGLegalize::ExpandSCALAR_TO_VECTOR(SDNode *Node) {
SDLoc dl(Node); SDLoc dl(Node);
// Create a vector sized/aligned stack slot, store the value to element #0, // Create a vector sized/aligned stack slot, store the value to element #0,
// then load the whole vector back out. // then load the whole vector back out.
▲ Show 20 Lines • Show All 3,316 Lines • Show Last 20 Lines

llvm/lib/CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp

Show First 20 Lines • Show All 447 Lines • ▼ Show 20 Lines if (NOutVT.bitsEq(NInVT) && !NOutVT.isVector()) {
DAG.getShiftAmountConstant(ShiftAmt, NOutVT, dl)); DAG.getShiftAmountConstant(ShiftAmt, NOutVT, dl));
} }
return Res; return Res;
} }
// If the output type is also a vector and widening it to the same size // If the output type is also a vector and widening it to the same size
// as the widened input type would be a legal type, we can widen the bitcast // as the widened input type would be a legal type, we can widen the bitcast
// and handle the promotion after. // and handle the promotion after.
if (NOutVT.isVector()) { if (NOutVT.isVector()) {
unsigned WidenInSize = NInVT.getSizeInBits(); TypeSize WidenInSize = NInVT.getSizeInBits();
unsigned OutSize = OutVT.getSizeInBits(); TypeSize OutSize = OutVT.getSizeInBits();
if (WidenInSize % OutSize == 0) { if (WidenInSize.hasKnownScalarFactor(OutSize)) {
unsigned Scale = WidenInSize / OutSize; unsigned Scale = WidenInSize.getKnownScalarFactor(OutSize);
EVT WideOutVT = EVT::getVectorVT(*DAG.getContext(), EVT WideOutVT =
OutVT.getVectorElementType(), EVT::getVectorVT(*DAG.getContext(), OutVT.getVectorElementType(),
OutVT.getVectorNumElements() * Scale); OutVT.getVectorElementCount() * Scale);
if (isTypeLegal(WideOutVT)) { if (isTypeLegal(WideOutVT)) {
InOp = DAG.getBitcast(WideOutVT, GetWidenedVector(InOp)); InOp = DAG.getBitcast(WideOutVT, GetWidenedVector(InOp));
InOp = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, OutVT, InOp, InOp = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, OutVT, InOp,
DAG.getVectorIdxConstant(0, dl)); DAG.getVectorIdxConstant(0, dl));
return DAG.getNode(ISD::ANY_EXTEND, dl, NOutVT, InOp); return DAG.getNode(ISD::ANY_EXTEND, dl, NOutVT, InOp);
} }
} }
} }
▲ Show 20 Lines • Show All 5,034 Lines • Show Last 20 Lines

llvm/lib/ExecutionEngine/JITLink/ELF_aarch64.cpp

Show All 10 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "llvm/ExecutionEngine/JITLink/ELF_aarch64.h" #include "llvm/ExecutionEngine/JITLink/ELF_aarch64.h"
#include "ELFLinkGraphBuilder.h" #include "ELFLinkGraphBuilder.h"
#include "JITLinkGeneric.h" #include "JITLinkGeneric.h"
#include "llvm/BinaryFormat/ELF.h" #include "llvm/BinaryFormat/ELF.h"
#include "llvm/ExecutionEngine/JITLink/aarch64.h" #include "llvm/ExecutionEngine/JITLink/aarch64.h"
#include "llvm/Object/ELFObjectFile.h" #include "llvm/Object/ELFObjectFile.h"
#include "llvm/Support/Endian.h"
#include "llvm/Support/MathExtras.h" #include "llvm/Support/MathExtras.h"
#include "PerGraphGOTAndPLTStubsBuilder.h"
#define DEBUG_TYPE "jitlink" #define DEBUG_TYPE "jitlink"
using namespace llvm; using namespace llvm;
using namespace llvm::jitlink; using namespace llvm::jitlink;
namespace llvm { namespace llvm {
namespace jitlink { namespace jitlink {
Show All 11 Lines Error applyFixup(LinkGraph &G, Block &B, const Edge &E) const {
return aarch64::applyFixup(G, B, E); return aarch64::applyFixup(G, B, E);
} }
}; };
template <typename ELFT> template <typename ELFT>
class ELFLinkGraphBuilder_aarch64 : public ELFLinkGraphBuilder<ELFT> { class ELFLinkGraphBuilder_aarch64 : public ELFLinkGraphBuilder<ELFT> {
private: private:
enum ELFAArch64RelocationKind : Edge::Kind { enum ELFAArch64RelocationKind : Edge::Kind {
ELFBranch26 = Edge::FirstRelocation, ELFCall26 = Edge::FirstRelocation,
ELFAdrPage21,
ELFAddAbs12,
ELFLdSt8Abs12,
ELFLdSt16Abs12,
ELFLdSt32Abs12,
ELFLdSt64Abs12,
ELFLdSt128Abs12,
ELFAbs64,
ELFAdrGOTPage21,
ELFLd64GOTLo12,
}; };
static Expected<ELFAArch64RelocationKind> static Expected<ELFAArch64RelocationKind>
getRelocationKind(const uint32_t Type) { getRelocationKind(const uint32_t Type) {
using namespace aarch64; using namespace aarch64;
switch (Type) { switch (Type) {
case ELF::R_AARCH64_CALL26: case ELF::R_AARCH64_CALL26:
return ELFBranch26; return ELFCall26;
case ELF::R_AARCH64_ADR_PREL_PG_HI21:
return ELFAdrPage21;
case ELF::R_AARCH64_ADD_ABS_LO12_NC:
return ELFAddAbs12;
case ELF::R_AARCH64_LDST8_ABS_LO12_NC:
return ELFLdSt8Abs12;
case ELF::R_AARCH64_LDST16_ABS_LO12_NC:
return ELFLdSt16Abs12;
case ELF::R_AARCH64_LDST32_ABS_LO12_NC:
return ELFLdSt32Abs12;
case ELF::R_AARCH64_LDST64_ABS_LO12_NC:
return ELFLdSt64Abs12;
case ELF::R_AARCH64_LDST128_ABS_LO12_NC:
return ELFLdSt128Abs12;
case ELF::R_AARCH64_ABS64:
return ELFAbs64;
case ELF::R_AARCH64_ADR_GOT_PAGE:
return ELFAdrGOTPage21;
case ELF::R_AARCH64_LD64_GOT_LO12_NC:
return ELFLd64GOTLo12;
} }
return make_error<JITLinkError>("Unsupported aarch64 relocation:" + return make_error<JITLinkError>("Unsupported aarch64 relocation:" +
formatv("{0:d}", Type)); formatv("{0:d}", Type));
} }
Error addRelocations() override { Error addRelocations() override {
LLVM_DEBUG(dbgs() << "Processing relocations:\n"); LLVM_DEBUG(dbgs() << "Processing relocations:\n");
using Base = ELFLinkGraphBuilder<ELFT>; using Base = ELFLinkGraphBuilder<ELFT>;
using Self = ELFLinkGraphBuilder_aarch64<ELFT>; using Self = ELFLinkGraphBuilder_aarch64<ELFT>;
for (const auto &RelSect : Base::Sections) for (const auto &RelSect : Base::Sections)
if (Error Err = Base::forEachRelocation(RelSect, this, if (Error Err = Base::forEachRelocation(RelSect, this,
&Self::addSingleRelocation)) &Self::addSingleRelocation))
return Err; return Err;
return Error::success(); return Error::success();
} }
Error addSingleRelocation(const typename ELFT::Rela &Rel, Error addSingleRelocation(const typename ELFT::Rela &Rel,
const typename ELFT::Shdr &FixupSect, const typename ELFT::Shdr &FixupSect,
Block &BlockToFix) { Block &BlockToFix) {
using support::ulittle32_t;
using Base = ELFLinkGraphBuilder<ELFT>; using Base = ELFLinkGraphBuilder<ELFT>;
uint32_t SymbolIndex = Rel.getSymbol(false); uint32_t SymbolIndex = Rel.getSymbol(false);
auto ObjSymbol = Base::Obj.getRelocationSymbol(Rel, Base::SymTabSec); auto ObjSymbol = Base::Obj.getRelocationSymbol(Rel, Base::SymTabSec);
if (!ObjSymbol) if (!ObjSymbol)
return ObjSymbol.takeError(); return ObjSymbol.takeError();
Symbol *GraphSymbol = Base::getGraphSymbol(SymbolIndex); Symbol *GraphSymbol = Base::getGraphSymbol(SymbolIndex);
Show All 10 Lines Error addSingleRelocation(const typename ELFT::Rela &Rel,
if (!RelocKind) if (!RelocKind)
return RelocKind.takeError(); return RelocKind.takeError();
int64_t Addend = Rel.r_addend; int64_t Addend = Rel.r_addend;
orc::ExecutorAddr FixupAddress = orc::ExecutorAddr FixupAddress =
orc::ExecutorAddr(FixupSect.sh_addr) + Rel.r_offset; orc::ExecutorAddr(FixupSect.sh_addr) + Rel.r_offset;
Edge::OffsetT Offset = FixupAddress - BlockToFix.getAddress(); Edge::OffsetT Offset = FixupAddress - BlockToFix.getAddress();
// Get a pointer to the fixup content.
const void *FixupContent = BlockToFix.getContent().data() +
(FixupAddress - BlockToFix.getAddress());
Edge::Kind Kind = Edge::Invalid; Edge::Kind Kind = Edge::Invalid;
switch (*RelocKind) { switch (*RelocKind) {
case ELFBranch26: { case ELFCall26: {
Kind = aarch64::Branch26; Kind = aarch64::Branch26;
break; break;
} }
case ELFAdrPage21: {
Kind = aarch64::Page21;
break;
}
case ELFAddAbs12: {
Kind = aarch64::PageOffset12;
break;
}
case ELFLdSt8Abs12: {
uint32_t Instr = *(const ulittle32_t *)FixupContent;
if (!aarch64::isLoadStoreImm12(Instr) ||
aarch64::getPageOffset12Shift(Instr) != 0)
return make_error<JITLinkError>(
"R_AARCH64_LDST8_ABS_LO12_NC target is not a "
"LDRB/STRB (imm12) instruction");
Kind = aarch64::PageOffset12;
break;
}
case ELFLdSt16Abs12: {
uint32_t Instr = *(const ulittle32_t *)FixupContent;
if (!aarch64::isLoadStoreImm12(Instr) ||
aarch64::getPageOffset12Shift(Instr) != 1)
return make_error<JITLinkError>(
"R_AARCH64_LDST16_ABS_LO12_NC target is not a "
"LDRH/STRH (imm12) instruction");
Kind = aarch64::PageOffset12;
break;
}
case ELFLdSt32Abs12: {
uint32_t Instr = *(const ulittle32_t *)FixupContent;
if (!aarch64::isLoadStoreImm12(Instr) ||
aarch64::getPageOffset12Shift(Instr) != 2)
return make_error<JITLinkError>(
"R_AARCH64_LDST32_ABS_LO12_NC target is not a "
"LDR/STR (imm12, 32 bit) instruction");
Kind = aarch64::PageOffset12;
break;
}
case ELFLdSt64Abs12: {
uint32_t Instr = *(const ulittle32_t *)FixupContent;
if (!aarch64::isLoadStoreImm12(Instr) ||
aarch64::getPageOffset12Shift(Instr) != 3)
return make_error<JITLinkError>(
"R_AARCH64_LDST64_ABS_LO12_NC target is not a "
"LDR/STR (imm12, 64 bit) instruction");
Kind = aarch64::PageOffset12;
break;
}
case ELFLdSt128Abs12: {
uint32_t Instr = *(const ulittle32_t *)FixupContent;
if (!aarch64::isLoadStoreImm12(Instr) ||
aarch64::getPageOffset12Shift(Instr) != 4)
return make_error<JITLinkError>(
"R_AARCH64_LDST128_ABS_LO12_NC target is not a "
"LDR/STR (imm12, 128 bit) instruction");
Kind = aarch64::PageOffset12;
break;
}
case ELFAbs64: {
Kind = aarch64::Pointer64;
break;
}
case ELFAdrGOTPage21: {
Kind = aarch64::GOTPage21;
break;
}
case ELFLd64GOTLo12: {
Kind = aarch64::GOTPageOffset12;
break;
}
}; };
Edge GE(Kind, Offset, *GraphSymbol, Addend); Edge GE(Kind, Offset, *GraphSymbol, Addend);
LLVM_DEBUG({ LLVM_DEBUG({
dbgs() << " "; dbgs() << " ";
printEdge(dbgs(), BlockToFix, GE, aarch64::getEdgeKindName(Kind)); printEdge(dbgs(), BlockToFix, GE, aarch64::getEdgeKindName(Kind));
dbgs() << "\n"; dbgs() << "\n";
}); });
BlockToFix.addEdge(std::move(GE)); BlockToFix.addEdge(std::move(GE));
return Error::success(); return Error::success();
} }
/// Return the string name of the given ELF aarch64 edge kind. /// Return the string name of the given ELF aarch64 edge kind.
const char *getELFAArch64RelocationKindName(Edge::Kind R) { const char *getELFAArch64RelocationKindName(Edge::Kind R) {
switch (R) { switch (R) {
case ELFBranch26: case ELFCall26:
return "ELFBranch26"; return "ELFCall26";
case ELFAdrPage21:
return "ELFAdrPage21";
case ELFAddAbs12:
return "ELFAddAbs12";
case ELFLdSt8Abs12:
return "ELFLdSt8Abs12";
case ELFLdSt16Abs12:
return "ELFLdSt16Abs12";
case ELFLdSt32Abs12:
return "ELFLdSt32Abs12";
case ELFLdSt64Abs12:
return "ELFLdSt64Abs12";
case ELFLdSt128Abs12:
return "ELFLdSt128Abs12";
case ELFAbs64:
return "ELFAbs64";
case ELFAdrGOTPage21:
return "ELFAdrGOTPage21";
case ELFLd64GOTLo12:
return "ELFLd64GOTLo12";
default: default:
return getGenericEdgeKindName(static_cast<Edge::Kind>(R)); return getGenericEdgeKindName(static_cast<Edge::Kind>(R));
} }
} }
public: public:
ELFLinkGraphBuilder_aarch64(StringRef FileName, ELFLinkGraphBuilder_aarch64(StringRef FileName,
const object::ELFFile<ELFT> &Obj, const Triple T) const object::ELFFile<ELFT> &Obj, const Triple T)
: ELFLinkGraphBuilder<ELFT>(Obj, std::move(T), FileName, : ELFLinkGraphBuilder<ELFT>(Obj, std::move(T), FileName,
aarch64::getEdgeKindName) {} aarch64::getEdgeKindName) {}
}; };
class PerGraphGOTAndPLTStubsBuilder_ELF_arm64
: public PerGraphGOTAndPLTStubsBuilder<
PerGraphGOTAndPLTStubsBuilder_ELF_arm64> {
public:
using PerGraphGOTAndPLTStubsBuilder<
PerGraphGOTAndPLTStubsBuilder_ELF_arm64>::PerGraphGOTAndPLTStubsBuilder;
bool isGOTEdgeToFix(Edge &E) const {
return E.getKind() == aarch64::GOTPage21 ||
E.getKind() == aarch64::GOTPageOffset12;
}
Symbol &createGOTEntry(Symbol &Target) {
auto &GOTEntryBlock = G.createContentBlock(
getGOTSection(), getGOTEntryBlockContent(), orc::ExecutorAddr(), 8, 0);
GOTEntryBlock.addEdge(aarch64::Pointer64, 0, Target, 0);
return G.addAnonymousSymbol(GOTEntryBlock, 0, 8, false, false);
}
void fixGOTEdge(Edge &E, Symbol &GOTEntry) {
if (E.getKind() == aarch64::GOTPage21) {
E.setKind(aarch64::Page21);
E.setTarget(GOTEntry);
} else if (E.getKind() == aarch64::GOTPageOffset12) {
E.setKind(aarch64::PageOffset12);
E.setTarget(GOTEntry);
} else
llvm_unreachable("Not a GOT edge?");
}
bool isExternalBranchEdge(Edge &E) { return false; }
Symbol &createPLTStub(Symbol &Target) {
assert(false && "unimplemetned");
return Target;
}
void fixPLTEdge(Edge &E, Symbol &Stub) { assert(false && "unimplemetned"); }
private:
Section &getGOTSection() {
if (!GOTSection)
GOTSection = &G.createSection("$__GOT", MemProt::Read | MemProt::Exec);
return *GOTSection;
}
ArrayRef<char> getGOTEntryBlockContent() {
return {reinterpret_cast<const char *>(NullGOTEntryContent),
sizeof(NullGOTEntryContent)};
}
static const uint8_t NullGOTEntryContent[8];
Section *GOTSection = nullptr;
};
const uint8_t PerGraphGOTAndPLTStubsBuilder_ELF_arm64::NullGOTEntryContent[8] =
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
Expected<std::unique_ptr<LinkGraph>> Expected<std::unique_ptr<LinkGraph>>
createLinkGraphFromELFObject_aarch64(MemoryBufferRef ObjectBuffer) { createLinkGraphFromELFObject_aarch64(MemoryBufferRef ObjectBuffer) {
LLVM_DEBUG({ LLVM_DEBUG({
dbgs() << "Building jitlink graph for new input " dbgs() << "Building jitlink graph for new input "
<< ObjectBuffer.getBufferIdentifier() << "...\n"; << ObjectBuffer.getBufferIdentifier() << "...\n";
}); });
auto ELFObj = object::ObjectFile::createELFObjectFile(ObjectBuffer); auto ELFObj = object::ObjectFile::createELFObjectFile(ObjectBuffer);
Show All 15 Linesvoid link_ELF_aarch64(std::unique_ptr<LinkGraph> G,
PassConfiguration Config; PassConfiguration Config;
const Triple &TT = G->getTargetTriple(); const Triple &TT = G->getTargetTriple();
if (Ctx->shouldAddDefaultTargetPasses(TT)) { if (Ctx->shouldAddDefaultTargetPasses(TT)) {
if (auto MarkLive = Ctx->getMarkLivePass(TT)) if (auto MarkLive = Ctx->getMarkLivePass(TT))
Config.PrePrunePasses.push_back(std::move(MarkLive)); Config.PrePrunePasses.push_back(std::move(MarkLive));
else else
Config.PrePrunePasses.push_back(markAllSymbolsLive); Config.PrePrunePasses.push_back(markAllSymbolsLive);
} }
Config.PostPrunePasses.push_back(
PerGraphGOTAndPLTStubsBuilder_ELF_arm64::asPass);
if (auto Err = Ctx->modifyPassConfig(*G, Config)) if (auto Err = Ctx->modifyPassConfig(*G, Config))
return Ctx->notifyFailed(std::move(Err)); return Ctx->notifyFailed(std::move(Err));
ELFJITLinker_aarch64::link(std::move(Ctx), std::move(G), std::move(Config)); ELFJITLinker_aarch64::link(std::move(Ctx), std::move(G), std::move(Config));
} }
} // namespace jitlink } // namespace jitlink
} // namespace llvm } // namespace llvm

llvm/lib/Target/AArch64/AArch64ISelLowering.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 3,811 Lines • ▼ Show 20 LinesSDValue AArch64TargetLowering::LowerBITCAST(SDValue Op,
SelectionDAG &DAG) const { SelectionDAG &DAG) const {
EVT OpVT = Op.getValueType(); EVT OpVT = Op.getValueType();
EVT ArgVT = Op.getOperand(0).getValueType(); EVT ArgVT = Op.getOperand(0).getValueType();
if (useSVEForFixedLengthVectorVT(OpVT)) if (useSVEForFixedLengthVectorVT(OpVT))
return LowerFixedLengthBitcastToSVE(Op, DAG); return LowerFixedLengthBitcastToSVE(Op, DAG);
if (OpVT.isScalableVector()) { if (OpVT.isScalableVector()) {
// Bitcasting between unpacked vector types of different element counts is
// not a NOP because the live elements are laid out differently.
// 01234567
// e.g. nxv2i32 = XX??XX??
// nxv4f16 = X?X?X?X?
if (OpVT.getVectorElementCount() != ArgVT.getVectorElementCount())
return SDValue();
if (isTypeLegal(OpVT) && !isTypeLegal(ArgVT)) { if (isTypeLegal(OpVT) && !isTypeLegal(ArgVT)) {
assert(OpVT.isFloatingPoint() && !ArgVT.isFloatingPoint() && assert(OpVT.isFloatingPoint() && !ArgVT.isFloatingPoint() &&
"Expected int->fp bitcast!"); "Expected int->fp bitcast!");
SDValue ExtResult = SDValue ExtResult =
DAG.getNode(ISD::ANY_EXTEND, SDLoc(Op), getSVEContainerType(ArgVT), DAG.getNode(ISD::ANY_EXTEND, SDLoc(Op), getSVEContainerType(ArgVT),
Op.getOperand(0)); Op.getOperand(0));
return getSVESafeBitCast(OpVT, ExtResult, DAG); return getSVESafeBitCast(OpVT, ExtResult, DAG);
} }
▲ Show 20 Lines • Show All 15,449 Lines • ▼ Show 20 Linesvoid AArch64TargetLowering::ReplaceBITCASTResults(
SDLoc DL(N); SDLoc DL(N);
SDValue Op = N->getOperand(0); SDValue Op = N->getOperand(0);
EVT VT = N->getValueType(0); EVT VT = N->getValueType(0);
EVT SrcVT = Op.getValueType(); EVT SrcVT = Op.getValueType();
if (VT.isScalableVector() && !isTypeLegal(VT) && isTypeLegal(SrcVT)) { if (VT.isScalableVector() && !isTypeLegal(VT) && isTypeLegal(SrcVT)) {
assert(!VT.isFloatingPoint() && SrcVT.isFloatingPoint() && assert(!VT.isFloatingPoint() && SrcVT.isFloatingPoint() &&
"Expected fp->int bitcast!"); "Expected fp->int bitcast!");
// Bitcasting between unpacked vector types of different element counts is
// not a NOP because the live elements are laid out differently.
// 01234567
// e.g. nxv2i32 = XX??XX??
// nxv4f16 = X?X?X?X?
if (VT.getVectorElementCount() != SrcVT.getVectorElementCount())
return;
SDValue CastResult = getSVESafeBitCast(getSVEContainerType(VT), Op, DAG); SDValue CastResult = getSVESafeBitCast(getSVEContainerType(VT), Op, DAG);
Results.push_back(DAG.getNode(ISD::TRUNCATE, DL, VT, CastResult)); Results.push_back(DAG.getNode(ISD::TRUNCATE, DL, VT, CastResult));
return; return;
} }
if (VT != MVT::i16 || (SrcVT != MVT::f16 && SrcVT != MVT::bf16)) if (VT != MVT::i16 || (SrcVT != MVT::f16 && SrcVT != MVT::bf16))
return; return;
▲ Show 20 Lines • Show All 1,839 Lines • ▼ Show 20 Lines if (InVT == VT)
return Op; return Op;
if (VT.getVectorElementType() == MVT::i1) if (VT.getVectorElementType() == MVT::i1)
return DAG.getNode(AArch64ISD::REINTERPRET_CAST, DL, VT, Op); return DAG.getNode(AArch64ISD::REINTERPRET_CAST, DL, VT, Op);
EVT PackedVT = getPackedSVEVectorVT(VT.getVectorElementType()); EVT PackedVT = getPackedSVEVectorVT(VT.getVectorElementType());
EVT PackedInVT = getPackedSVEVectorVT(InVT.getVectorElementType()); EVT PackedInVT = getPackedSVEVectorVT(InVT.getVectorElementType());
// Safe bitcasting between unpacked vector types of different element counts
// is currently unsupported because the following is missing the necessary
// work to ensure the result's elements live where they're supposed to within
// an SVE register.
// 01234567
// e.g. nxv2i32 = XX??XX??
// nxv4f16 = X?X?X?X?
assert((VT.getVectorElementCount() == InVT.getVectorElementCount() ||
VT == PackedVT || InVT == PackedInVT) &&
"Unexpected bitcast!");
// Pack input if required. // Pack input if required.
if (InVT != PackedInVT) if (InVT != PackedInVT)
Op = DAG.getNode(AArch64ISD::REINTERPRET_CAST, DL, PackedInVT, Op); Op = DAG.getNode(AArch64ISD::REINTERPRET_CAST, DL, PackedInVT, Op);
Op = DAG.getNode(ISD::BITCAST, DL, PackedVT, Op); Op = DAG.getNode(ISD::BITCAST, DL, PackedVT, Op);
// Unpack result if required. // Unpack result if required.
if (VT != PackedVT) if (VT != PackedVT)
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

llvm/lib/Target/DirectX/DXILPrepare.cpp

Show First 20 Lines • Show All 121 Lines • ▼ Show 20 Lines for (auto &F : M.functions()) {
Builder.SetInsertPoint(&I); Builder.SetInsertPoint(&I);
Value *In = I.getOperand(0); Value *In = I.getOperand(0);
Value *Zero = ConstantFP::get(In->getType(), -0.0); Value *Zero = ConstantFP::get(In->getType(), -0.0);
I.replaceAllUsesWith(Builder.CreateFSub(Zero, In)); I.replaceAllUsesWith(Builder.CreateFSub(Zero, In));
I.eraseFromParent(); I.eraseFromParent();
continue; continue;
} }
// Only insert bitcasts if the IR is using opaque pointers. // Only insert bitcasts if the IR is using opaque pointers.
if (!M.getContext().hasSetOpaquePointersValue()) if (M.getContext().supportsTypedPointers())
continue; continue;
// Emtting NoOp bitcast instructions allows the ValueEnumerator to be // Emtting NoOp bitcast instructions allows the ValueEnumerator to be
// unmodified as it reserves instruction IDs during contruction. // unmodified as it reserves instruction IDs during contruction.
if (auto LI = dyn_cast<LoadInst>(&I)) { if (auto LI = dyn_cast<LoadInst>(&I)) {
if (Value *NoOpBitcast = maybeGenerateBitcast( if (Value *NoOpBitcast = maybeGenerateBitcast(
Builder, PointerTypes, I, LI->getPointerOperand(), Builder, PointerTypes, I, LI->getPointerOperand(),
LI->getType())) { LI->getType())) {
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

llvm/lib/Transforms/Coroutines/CoroFrame.cpp

Show First 20 Lines • Show All 2,558 Lines • ▼ Show 20 Lines while (isa<IntrinsicInst>(InsertPt))
++InsertPt; ++InsertPt;
Builder.SetInsertPoint(&F->getEntryBlock(), InsertPt); Builder.SetInsertPoint(&F->getEntryBlock(), InsertPt);
DIExpression *Expr = DVI->getExpression(); DIExpression *Expr = DVI->getExpression();
// Follow the pointer arithmetic all the way to the incoming // Follow the pointer arithmetic all the way to the incoming
// function argument and convert into a DIExpression. // function argument and convert into a DIExpression.
bool SkipOutermostLoad = !isa<DbgValueInst>(DVI); bool SkipOutermostLoad = !isa<DbgValueInst>(DVI);
Value *Storage = DVI->getVariableLocationOp(0); Value *Storage = DVI->getVariableLocationOp(0);
Value *OriginalStorage = Storage; Value *OriginalStorage = Storage;
while (auto *Inst = dyn_cast_or_null<Instruction>(Storage)) { while (auto *Inst = dyn_cast_or_null<Instruction>(Storage)) {
if (auto *LdInst = dyn_cast<LoadInst>(Inst)) { if (auto *LdInst = dyn_cast<LoadInst>(Inst)) {
Storage = LdInst->getOperand(0); Storage = LdInst->getOperand(0);
// FIXME: This is a heuristic that works around the fact that // FIXME: This is a heuristic that works around the fact that
// LLVM IR debug intrinsics cannot yet distinguish between // LLVM IR debug intrinsics cannot yet distinguish between
// memory and value locations: Because a dbg.declare(alloca) is // memory and value locations: Because a dbg.declare(alloca) is
// implicitly a memory location no DW_OP_deref operation for the // implicitly a memory location no DW_OP_deref operation for the
// last direct load from an alloca is necessary. This condition // last direct load from an alloca is necessary. This condition
Show All 39 Lines if (auto *Arg = dyn_cast<llvm::Argument>(Storage)) {
Storage = Cached; Storage = Cached;
// FIXME: LLVM lacks nuanced semantics to differentiate between // FIXME: LLVM lacks nuanced semantics to differentiate between
// memory and direct locations at the IR level. The backend will // memory and direct locations at the IR level. The backend will
// turn a dbg.declare(alloca, ..., DIExpression()) into a memory // turn a dbg.declare(alloca, ..., DIExpression()) into a memory
// location. Thus, if there are deref and offset operations in the // location. Thus, if there are deref and offset operations in the
// expression, we need to add a DW_OP_deref at the *start* of the // expression, we need to add a DW_OP_deref at the *start* of the
// expression to first load the contents of the alloca before // expression to first load the contents of the alloca before
// adjusting it with the expression. // adjusting it with the expression.
if (Expr && Expr->isComplex())
Expr = DIExpression::prepend(Expr, DIExpression::DerefBefore); Expr = DIExpression::prepend(Expr, DIExpression::DerefBefore);
} }
DVI->replaceVariableLocationOp(OriginalStorage, Storage); DVI->replaceVariableLocationOp(OriginalStorage, Storage);
DVI->setExpression(Expr); DVI->setExpression(Expr);
// We only hoist dbg.declare today since it doesn't make sense to hoist // We only hoist dbg.declare today since it doesn't make sense to hoist
// dbg.value or dbg.addr since they do not have the same function wide // dbg.value or dbg.addr since they do not have the same function wide
// guarantees that dbg.declare does. // guarantees that dbg.declare does.
if (!isa<DbgValueInst>(DVI) && !isa<DbgAddrIntrinsic>(DVI)) { if (!isa<DbgValueInst>(DVI) && !isa<DbgAddrIntrinsic>(DVI)) {
▲ Show 20 Lines • Show All 183 Lines • Show Last 20 Lines

llvm/lib/Transforms/IPO/GlobalOpt.cpp

Show First 20 Lines • Show All 602 Lines • ▼ Show 20 Lines if (const Instruction *I = dyn_cast<Instruction>(U)) {
// Non address-space 0 globals have already been pruned by the caller. // Non address-space 0 globals have already been pruned by the caller.
if (NullPointerIsDefined(I->getFunction())) if (NullPointerIsDefined(I->getFunction()))
return false; return false;
} }
if (isa<LoadInst>(U)) { if (isa<LoadInst>(U)) {
// Will trap. // Will trap.
} else if (const StoreInst *SI = dyn_cast<StoreInst>(U)) { } else if (const StoreInst *SI = dyn_cast<StoreInst>(U)) {
if (SI->getOperand(0) == V) { if (SI->getOperand(0) == V) {
//cerr << "NONTRAPPING USE: " << *U;
return false; // Storing the value. return false; // Storing the value.
} }
} else if (const CallInst *CI = dyn_cast<CallInst>(U)) { } else if (const CallInst *CI = dyn_cast<CallInst>(U)) {
if (CI->getCalledOperand() != V) { if (CI->getCalledOperand() != V) {
//cerr << "NONTRAPPING USE: " << *U;
return false; // Not calling the ptr return false; // Not calling the ptr
} }
} else if (const InvokeInst *II = dyn_cast<InvokeInst>(U)) { } else if (const InvokeInst *II = dyn_cast<InvokeInst>(U)) {
if (II->getCalledOperand() != V) { if (II->getCalledOperand() != V) {
//cerr << "NONTRAPPING USE: " << *U;
return false; // Not calling the ptr return false; // Not calling the ptr
} }
} else if (const BitCastInst *CI = dyn_cast<BitCastInst>(U)) { } else if (const BitCastInst *CI = dyn_cast<BitCastInst>(U)) {
if (!AllUsesOfValueWillTrapIfNull(CI, PHIs)) return false; if (!AllUsesOfValueWillTrapIfNull(CI, PHIs)) return false;
} else if (const GetElementPtrInst *GEPI = dyn_cast<GetElementPtrInst>(U)) { } else if (const GetElementPtrInst *GEPI = dyn_cast<GetElementPtrInst>(U)) {
if (!AllUsesOfValueWillTrapIfNull(GEPI, PHIs)) return false; if (!AllUsesOfValueWillTrapIfNull(GEPI, PHIs)) return false;
} else if (const PHINode *PN = dyn_cast<PHINode>(U)) { } else if (const PHINode *PN = dyn_cast<PHINode>(U)) {
// If we've already seen this phi node, ignore it, it has already been // If we've already seen this phi node, ignore it, it has already been
// checked. // checked.
if (PHIs.insert(PN).second && !AllUsesOfValueWillTrapIfNull(PN, PHIs)) if (PHIs.insert(PN).second && !AllUsesOfValueWillTrapIfNull(PN, PHIs))
return false; return false;
} else if (isa<ICmpInst>(U) && } else if (isa<ICmpInst>(U) &&
!ICmpInst::isSigned(cast<ICmpInst>(U)->getPredicate()) && !ICmpInst::isSigned(cast<ICmpInst>(U)->getPredicate()) &&
isa<LoadInst>(U->getOperand(0)) && isa<LoadInst>(U->getOperand(0)) &&
isa<ConstantPointerNull>(U->getOperand(1))) { isa<ConstantPointerNull>(U->getOperand(1))) {
assert(isa<GlobalValue>(cast<LoadInst>(U->getOperand(0)) assert(isa<GlobalValue>(cast<LoadInst>(U->getOperand(0))
->getPointerOperand() ->getPointerOperand()
->stripPointerCasts()) && ->stripPointerCasts()) &&
"Should be GlobalVariable"); "Should be GlobalVariable");
// This and only this kind of non-signed ICmpInst is to be replaced with // This and only this kind of non-signed ICmpInst is to be replaced with
// the comparing of the value of the created global init bool later in // the comparing of the value of the created global init bool later in
// optimizeGlobalAddressOfAllocation for the global variable. // optimizeGlobalAddressOfAllocation for the global variable.
} else { } else {
//cerr << "NONTRAPPING USE: " << *U;
return false; return false;
} }
} }
return true; return true;
} }
/// Return true if all uses of any loads from GV will trap if the loaded value /// Return true if all uses of any loads from GV will trap if the loaded value
/// is null. Note that this also permits comparisons of the loaded value /// is null. Note that this also permits comparisons of the loaded value
▲ Show 20 Lines • Show All 1,907 Lines • Show Last 20 Lines

llvm/lib/Transforms/InstCombine/InstCombineCasts.cpp

Show All 30 Linesstatic Value *decomposeSimpleLinearExpr(Value *Val, unsigned &Scale,
if (ConstantInt *CI = dyn_cast<ConstantInt>(Val)) { if (ConstantInt *CI = dyn_cast<ConstantInt>(Val)) {
Offset = CI->getZExtValue(); Offset = CI->getZExtValue();
Scale = 0; Scale = 0;
return ConstantInt::get(Val->getType(), 0); return ConstantInt::get(Val->getType(), 0);
} }
if (BinaryOperator *I = dyn_cast<BinaryOperator>(Val)) { if (BinaryOperator *I = dyn_cast<BinaryOperator>(Val)) {
// Cannot look past anything that might overflow. // Cannot look past anything that might overflow.
// We specifically require nuw because we store the Scale in an unsigned
// and perform an unsigned divide on it.
OverflowingBinaryOperator *OBI = dyn_cast<OverflowingBinaryOperator>(Val); OverflowingBinaryOperator *OBI = dyn_cast<OverflowingBinaryOperator>(Val);
if (OBI && !OBI->hasNoUnsignedWrap() && !OBI->hasNoSignedWrap()) { if (OBI && !OBI->hasNoUnsignedWrap()) {
Scale = 1; Scale = 1;
Offset = 0; Offset = 0;
return Val; return Val;
} }
if (ConstantInt *RHS = dyn_cast<ConstantInt>(I->getOperand(1))) { if (ConstantInt *RHS = dyn_cast<ConstantInt>(I->getOperand(1))) {
if (I->getOpcode() == Instruction::Shl) { if (I->getOpcode() == Instruction::Shl) {
// This is a value scaled by '1 << the shift amt'. // This is a value scaled by '1 << the shift amt'.
▲ Show 20 Lines • Show All 2,865 Lines • Show Last 20 Lines

llvm/lib/Transforms/Utils/ScalarEvolutionExpander.cpp

Show First 20 Lines • Show All 1,626 Lines • ▼ Show 20 LinesValue *SCEVExpander::visitAddRecExpr(const SCEVAddRecExpr *S) {
// Promote S up to the canonical IV type, if the cast is foldable. // Promote S up to the canonical IV type, if the cast is foldable.
const SCEV *NewS = S; const SCEV *NewS = S;
const SCEV *Ext = SE.getNoopOrAnyExtend(S, CanonicalIV->getType()); const SCEV *Ext = SE.getNoopOrAnyExtend(S, CanonicalIV->getType());
if (isa<SCEVAddRecExpr>(Ext)) if (isa<SCEVAddRecExpr>(Ext))
NewS = Ext; NewS = Ext;
const SCEV *V = cast<SCEVAddRecExpr>(NewS)->evaluateAtIteration(IH, SE); const SCEV *V = cast<SCEVAddRecExpr>(NewS)->evaluateAtIteration(IH, SE);
//cerr << "Evaluated: " << *this << "\n to: " << *V << "\n";
// Truncate the result down to the original type, if needed. // Truncate the result down to the original type, if needed.
const SCEV *T = SE.getTruncateOrNoop(V, Ty); const SCEV *T = SE.getTruncateOrNoop(V, Ty);
return expand(T); return expand(T);
} }
Value *SCEVExpander::visitPtrToIntExpr(const SCEVPtrToIntExpr *S) { Value *SCEVExpander::visitPtrToIntExpr(const SCEVPtrToIntExpr *S) {
Value *V = Value *V =
▲ Show 20 Lines • Show All 1,032 Lines • Show Last 20 Lines

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 ; http://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-PR24755: 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"
; CHECK: target triple = "x86_64-apple-macosx10.10.0" ; CHECK: target triple = "x86_64-apple-macosx10.10.0"
;; Module-level assembly ;; Module-level assembly
▲ Show 20 Lines • Show All 2,013 Lines • Show Last 20 Lines

llvm/test/CodeGen/AArch64/sve-bitcast.ll

Show First 20 Lines • Show All 512 Lines • ▼ Show 20 Lines
; CHECK-NEXT: ld1b { z0.h }, p0/z, [sp, #1, mul vl] ; CHECK-NEXT: ld1b { z0.h }, p0/z, [sp, #1, mul vl]
; CHECK-NEXT: addvl sp, sp, #1 ; CHECK-NEXT: addvl sp, sp, #1
; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload ; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload
; CHECK-NEXT: ret ; CHECK-NEXT: ret
%bc = bitcast <vscale x 2 x i32> %v to <vscale x 8 x i8> %bc = bitcast <vscale x 2 x i32> %v to <vscale x 8 x i8>
ret <vscale x 8 x i8> %bc ret <vscale x 8 x i8> %bc
} }
define <vscale x 8 x i8> @bitcast_nxv1i64_to_nxv8i8(<vscale x 1 x i64> %v) #0 {
; CHECK-LABEL: bitcast_nxv1i64_to_nxv8i8:
; CHECK: // %bb.0:
; CHECK-NEXT: uunpklo z0.h, z0.b
; CHECK-NEXT: ret
%bc = bitcast <vscale x 1 x i64> %v to <vscale x 8 x i8>
ret <vscale x 8 x i8> %bc
}
define <vscale x 8 x i8> @bitcast_nxv4f16_to_nxv8i8(<vscale x 4 x half> %v) #0 { define <vscale x 8 x i8> @bitcast_nxv4f16_to_nxv8i8(<vscale x 4 x half> %v) #0 {
; CHECK-LABEL: bitcast_nxv4f16_to_nxv8i8: ; CHECK-LABEL: bitcast_nxv4f16_to_nxv8i8:
; CHECK: // %bb.0: ; CHECK: // %bb.0:
; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill ; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill
; CHECK-NEXT: addvl sp, sp, #-1 ; CHECK-NEXT: addvl sp, sp, #-1
; CHECK-NEXT: ptrue p0.s ; CHECK-NEXT: ptrue p0.s
; CHECK-NEXT: st1h { z0.s }, p0, [sp, #1, mul vl] ; CHECK-NEXT: st1h { z0.s }, p0, [sp, #1, mul vl]
; CHECK-NEXT: ptrue p0.h ; CHECK-NEXT: ptrue p0.h
Show All 16 Lines
; CHECK-NEXT: ld1b { z0.h }, p0/z, [sp, #1, mul vl] ; CHECK-NEXT: ld1b { z0.h }, p0/z, [sp, #1, mul vl]
; CHECK-NEXT: addvl sp, sp, #1 ; CHECK-NEXT: addvl sp, sp, #1
; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload ; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload
; CHECK-NEXT: ret ; CHECK-NEXT: ret
%bc = bitcast <vscale x 2 x float> %v to <vscale x 8 x i8> %bc = bitcast <vscale x 2 x float> %v to <vscale x 8 x i8>
ret <vscale x 8 x i8> %bc ret <vscale x 8 x i8> %bc
} }
define <vscale x 8 x i8> @bitcast_nxv1f64_to_nxv8i8(<vscale x 1 x double> %v) #0 {
; CHECK-LABEL: bitcast_nxv1f64_to_nxv8i8:
; CHECK: // %bb.0:
; CHECK-NEXT: uunpklo z0.h, z0.b
; CHECK-NEXT: ret
%bc = bitcast <vscale x 1 x double> %v to <vscale x 8 x i8>
ret <vscale x 8 x i8> %bc
}
define <vscale x 8 x i8> @bitcast_nxv4bf16_to_nxv8i8(<vscale x 4 x bfloat> %v) #0 { define <vscale x 8 x i8> @bitcast_nxv4bf16_to_nxv8i8(<vscale x 4 x bfloat> %v) #0 {
; CHECK-LABEL: bitcast_nxv4bf16_to_nxv8i8: ; CHECK-LABEL: bitcast_nxv4bf16_to_nxv8i8:
; CHECK: // %bb.0: ; CHECK: // %bb.0:
; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill ; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill
; CHECK-NEXT: addvl sp, sp, #-1 ; CHECK-NEXT: addvl sp, sp, #-1
; CHECK-NEXT: ptrue p0.s ; CHECK-NEXT: ptrue p0.s
; CHECK-NEXT: st1h { z0.s }, p0, [sp, #1, mul vl] ; CHECK-NEXT: st1h { z0.s }, p0, [sp, #1, mul vl]
; CHECK-NEXT: ptrue p0.h ; CHECK-NEXT: ptrue p0.h
Show All 36 Lines
; CHECK-NEXT: ld1h { z0.s }, p0/z, [sp, #1, mul vl] ; CHECK-NEXT: ld1h { z0.s }, p0/z, [sp, #1, mul vl]
; CHECK-NEXT: addvl sp, sp, #1 ; CHECK-NEXT: addvl sp, sp, #1
; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload ; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload
; CHECK-NEXT: ret ; CHECK-NEXT: ret
%bc = bitcast <vscale x 2 x i32> %v to <vscale x 4 x i16> %bc = bitcast <vscale x 2 x i32> %v to <vscale x 4 x i16>
ret <vscale x 4 x i16> %bc ret <vscale x 4 x i16> %bc
} }
define <vscale x 4 x i16> @bitcast_nxv1i64_to_nxv4i16(<vscale x 1 x i64> %v) #0 {
; CHECK-LABEL: bitcast_nxv1i64_to_nxv4i16:
; CHECK: // %bb.0:
; CHECK-NEXT: uunpklo z0.s, z0.h
; CHECK-NEXT: ret
%bc = bitcast <vscale x 1 x i64> %v to <vscale x 4 x i16>
ret <vscale x 4 x i16> %bc
}
define <vscale x 4 x i16> @bitcast_nxv4f16_to_nxv4i16(<vscale x 4 x half> %v) #0 { define <vscale x 4 x i16> @bitcast_nxv4f16_to_nxv4i16(<vscale x 4 x half> %v) #0 {
; CHECK-LABEL: bitcast_nxv4f16_to_nxv4i16: ; CHECK-LABEL: bitcast_nxv4f16_to_nxv4i16:
; CHECK: // %bb.0: ; CHECK: // %bb.0:
; CHECK-NEXT: ret ; CHECK-NEXT: ret
%bc = bitcast <vscale x 4 x half> %v to <vscale x 4 x i16> %bc = bitcast <vscale x 4 x half> %v to <vscale x 4 x i16>
ret <vscale x 4 x i16> %bc ret <vscale x 4 x i16> %bc
} }
; TODO: Invalid code generation because the bitcast must change the in-register
; layout when casting between unpacked scalable vector types.
define <vscale x 4 x i16> @bitcast_nxv2f32_to_nxv4i16(<vscale x 2 x float> %v) #0 { define <vscale x 4 x i16> @bitcast_nxv2f32_to_nxv4i16(<vscale x 2 x float> %v) #0 {
; CHECK-LABEL: bitcast_nxv2f32_to_nxv4i16: ; CHECK-LABEL: bitcast_nxv2f32_to_nxv4i16:
; CHECK: // %bb.0: ; CHECK: // %bb.0:
; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill
; CHECK-NEXT: addvl sp, sp, #-1
; CHECK-NEXT: ptrue p0.d
; CHECK-NEXT: st1w { z0.d }, p0, [sp, #1, mul vl]
; CHECK-NEXT: ptrue p0.s
; CHECK-NEXT: ld1h { z0.s }, p0/z, [sp, #1, mul vl]
; CHECK-NEXT: addvl sp, sp, #1
; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload
; CHECK-NEXT: ret ; CHECK-NEXT: ret
%bc = bitcast <vscale x 2 x float> %v to <vscale x 4 x i16> %bc = bitcast <vscale x 2 x float> %v to <vscale x 4 x i16>
ret <vscale x 4 x i16> %bc ret <vscale x 4 x i16> %bc
} }
define <vscale x 4 x i16> @bitcast_nxv1f64_to_nxv4i16(<vscale x 1 x double> %v) #0 {
; CHECK-LABEL: bitcast_nxv1f64_to_nxv4i16:
; CHECK: // %bb.0:
; CHECK-NEXT: uunpklo z0.s, z0.h
; CHECK-NEXT: ret
%bc = bitcast <vscale x 1 x double> %v to <vscale x 4 x i16>
ret <vscale x 4 x i16> %bc
}
define <vscale x 4 x i16> @bitcast_nxv4bf16_to_nxv4i16(<vscale x 4 x bfloat> %v) #0 { define <vscale x 4 x i16> @bitcast_nxv4bf16_to_nxv4i16(<vscale x 4 x bfloat> %v) #0 {
; CHECK-LABEL: bitcast_nxv4bf16_to_nxv4i16: ; CHECK-LABEL: bitcast_nxv4bf16_to_nxv4i16:
; CHECK: // %bb.0: ; CHECK: // %bb.0:
; CHECK-NEXT: ret ; CHECK-NEXT: ret
%bc = bitcast <vscale x 4 x bfloat> %v to <vscale x 4 x i16> %bc = bitcast <vscale x 4 x bfloat> %v to <vscale x 4 x i16>
ret <vscale x 4 x i16> %bc ret <vscale x 4 x i16> %bc
} }
Show All 28 Lines
; CHECK-NEXT: ld1w { z0.d }, p0/z, [sp, #1, mul vl] ; CHECK-NEXT: ld1w { z0.d }, p0/z, [sp, #1, mul vl]
; CHECK-NEXT: addvl sp, sp, #1 ; CHECK-NEXT: addvl sp, sp, #1
; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload ; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload
; CHECK-NEXT: ret ; CHECK-NEXT: ret
%bc = bitcast <vscale x 4 x i16> %v to <vscale x 2 x i32> %bc = bitcast <vscale x 4 x i16> %v to <vscale x 2 x i32>
ret <vscale x 2 x i32> %bc ret <vscale x 2 x i32> %bc
} }
; TODO: Invalid code generation because the bitcast must change the in-register define <vscale x 2 x i32> @bitcast_nxv1i64_to_nxv2i32(<vscale x 1 x i64> %v) #0 {
; layout when casting between unpacked scalable vector types. ; CHECK-LABEL: bitcast_nxv1i64_to_nxv2i32:
; CHECK: // %bb.0:
; CHECK-NEXT: uunpklo z0.d, z0.s
; CHECK-NEXT: ret
%bc = bitcast <vscale x 1 x i64> %v to <vscale x 2 x i32>
ret <vscale x 2 x i32> %bc
}
define <vscale x 2 x i32> @bitcast_nxv4f16_to_nxv2i32(<vscale x 4 x half> %v) #0 { define <vscale x 2 x i32> @bitcast_nxv4f16_to_nxv2i32(<vscale x 4 x half> %v) #0 {
; CHECK-LABEL: bitcast_nxv4f16_to_nxv2i32: ; CHECK-LABEL: bitcast_nxv4f16_to_nxv2i32:
; CHECK: // %bb.0: ; CHECK: // %bb.0:
; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill
; CHECK-NEXT: addvl sp, sp, #-1
; CHECK-NEXT: ptrue p0.s
; CHECK-NEXT: st1h { z0.s }, p0, [sp, #1, mul vl]
; CHECK-NEXT: ptrue p0.d
; CHECK-NEXT: ld1w { z0.d }, p0/z, [sp, #1, mul vl]
; CHECK-NEXT: addvl sp, sp, #1
; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload
; CHECK-NEXT: ret ; CHECK-NEXT: ret
%bc = bitcast <vscale x 4 x half> %v to <vscale x 2 x i32> %bc = bitcast <vscale x 4 x half> %v to <vscale x 2 x i32>
ret <vscale x 2 x i32> %bc ret <vscale x 2 x i32> %bc
} }
define <vscale x 2 x i32> @bitcast_nxv2f32_to_nxv2i32(<vscale x 2 x float> %v) #0 { define <vscale x 2 x i32> @bitcast_nxv2f32_to_nxv2i32(<vscale x 2 x float> %v) #0 {
; CHECK-LABEL: bitcast_nxv2f32_to_nxv2i32: ; CHECK-LABEL: bitcast_nxv2f32_to_nxv2i32:
; CHECK: // %bb.0: ; CHECK: // %bb.0:
; CHECK-NEXT: ret ; CHECK-NEXT: ret
%bc = bitcast <vscale x 2 x float> %v to <vscale x 2 x i32> %bc = bitcast <vscale x 2 x float> %v to <vscale x 2 x i32>
ret <vscale x 2 x i32> %bc ret <vscale x 2 x i32> %bc
} }
; TODO: Invalid code generation because the bitcast must change the in-register define <vscale x 2 x i32> @bitcast_nxv1f64_to_nxv2i32(<vscale x 1 x double> %v) #0 {
; layout when casting between unpacked scalable vector types. ; CHECK-LABEL: bitcast_nxv1f64_to_nxv2i32:
; CHECK: // %bb.0:
; CHECK-NEXT: uunpklo z0.d, z0.s
; CHECK-NEXT: ret
%bc = bitcast <vscale x 1 x double> %v to <vscale x 2 x i32>
ret <vscale x 2 x i32> %bc
}
define <vscale x 2 x i32> @bitcast_nxv4bf16_to_nxv2i32(<vscale x 4 x bfloat> %v) #0 { define <vscale x 2 x i32> @bitcast_nxv4bf16_to_nxv2i32(<vscale x 4 x bfloat> %v) #0 {
; CHECK-LABEL: bitcast_nxv4bf16_to_nxv2i32: ; CHECK-LABEL: bitcast_nxv4bf16_to_nxv2i32:
; CHECK: // %bb.0: ; CHECK: // %bb.0:
; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill
; CHECK-NEXT: addvl sp, sp, #-1
; CHECK-NEXT: ptrue p0.s
; CHECK-NEXT: st1h { z0.s }, p0, [sp, #1, mul vl]
; CHECK-NEXT: ptrue p0.d
; CHECK-NEXT: ld1w { z0.d }, p0/z, [sp, #1, mul vl]
; CHECK-NEXT: addvl sp, sp, #1
; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload
; CHECK-NEXT: ret ; CHECK-NEXT: ret
%bc = bitcast <vscale x 4 x bfloat> %v to <vscale x 2 x i32> %bc = bitcast <vscale x 4 x bfloat> %v to <vscale x 2 x i32>
ret <vscale x 2 x i32> %bc ret <vscale x 2 x i32> %bc
} }
; ;
; bitcast to nxv1i64
;
define <vscale x 1 x i64> @bitcast_nxv8i8_to_nxv1i64(<vscale x 8 x i8> %v) #0 {
; CHECK-LABEL: bitcast_nxv8i8_to_nxv1i64:
; CHECK: // %bb.0:
; CHECK-NEXT: uzp1 z0.b, z0.b, z0.b
; CHECK-NEXT: ret
%bc = bitcast <vscale x 8 x i8> %v to <vscale x 1 x i64>
ret <vscale x 1 x i64> %bc
}
define <vscale x 1 x i64> @bitcast_nxv4i16_to_nxv1i64(<vscale x 4 x i16> %v) #0 {
; CHECK-LABEL: bitcast_nxv4i16_to_nxv1i64:
; CHECK: // %bb.0:
; CHECK-NEXT: uzp1 z0.h, z0.h, z0.h
; CHECK-NEXT: ret
%bc = bitcast <vscale x 4 x i16> %v to <vscale x 1 x i64>
ret <vscale x 1 x i64> %bc
}
define <vscale x 1 x i64> @bitcast_nxv2i32_to_nxv1i64(<vscale x 2 x i32> %v) #0 {
; CHECK-LABEL: bitcast_nxv2i32_to_nxv1i64:
; CHECK: // %bb.0:
; CHECK-NEXT: uzp1 z0.s, z0.s, z0.s
; CHECK-NEXT: ret
%bc = bitcast <vscale x 2 x i32> %v to <vscale x 1 x i64>
ret <vscale x 1 x i64> %bc
}
define <vscale x 1 x i64> @bitcast_nxv4f16_to_nxv1i64(<vscale x 4 x half> %v) #0 {
; CHECK-LABEL: bitcast_nxv4f16_to_nxv1i64:
; CHECK: // %bb.0:
; CHECK-NEXT: uzp1 z0.h, z0.h, z0.h
; CHECK-NEXT: ret
%bc = bitcast <vscale x 4 x half> %v to <vscale x 1 x i64>
ret <vscale x 1 x i64> %bc
}
define <vscale x 1 x i64> @bitcast_nxv2f32_to_nxv1i64(<vscale x 2 x float> %v) #0 {
; CHECK-LABEL: bitcast_nxv2f32_to_nxv1i64:
; CHECK: // %bb.0:
; CHECK-NEXT: uzp1 z0.s, z0.s, z0.s
; CHECK-NEXT: ret
%bc = bitcast <vscale x 2 x float> %v to <vscale x 1 x i64>
ret <vscale x 1 x i64> %bc
}
define <vscale x 1 x i64> @bitcast_nxv1f64_to_nxv1i64(<vscale x 1 x double> %v) #0 {
; CHECK-LABEL: bitcast_nxv1f64_to_nxv1i64:
; CHECK: // %bb.0:
; CHECK-NEXT: ret
%bc = bitcast <vscale x 1 x double> %v to <vscale x 1 x i64>
ret <vscale x 1 x i64> %bc
}
define <vscale x 1 x i64> @bitcast_nxv4bf16_to_nxv1i64(<vscale x 4 x bfloat> %v) #0 {
; CHECK-LABEL: bitcast_nxv4bf16_to_nxv1i64:
; CHECK: // %bb.0:
; CHECK-NEXT: uzp1 z0.h, z0.h, z0.h
; CHECK-NEXT: ret
%bc = bitcast <vscale x 4 x bfloat> %v to <vscale x 1 x i64>
ret <vscale x 1 x i64> %bc
}
;
; bitcast to nxv4f16 ; bitcast to nxv4f16
; ;
define <vscale x 4 x half> @bitcast_nxv8i8_to_nxv4f16(<vscale x 8 x i8> %v) #0 { define <vscale x 4 x half> @bitcast_nxv8i8_to_nxv4f16(<vscale x 8 x i8> %v) #0 {
; CHECK-LABEL: bitcast_nxv8i8_to_nxv4f16: ; CHECK-LABEL: bitcast_nxv8i8_to_nxv4f16:
; CHECK: // %bb.0: ; CHECK: // %bb.0:
; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill ; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill
; CHECK-NEXT: addvl sp, sp, #-1 ; CHECK-NEXT: addvl sp, sp, #-1
Show All 11 Lines
define <vscale x 4 x half> @bitcast_nxv4i16_to_nxv4f16(<vscale x 4 x i16> %v) #0 { define <vscale x 4 x half> @bitcast_nxv4i16_to_nxv4f16(<vscale x 4 x i16> %v) #0 {
; CHECK-LABEL: bitcast_nxv4i16_to_nxv4f16: ; CHECK-LABEL: bitcast_nxv4i16_to_nxv4f16:
; CHECK: // %bb.0: ; CHECK: // %bb.0:
; CHECK-NEXT: ret ; CHECK-NEXT: ret
%bc = bitcast <vscale x 4 x i16> %v to <vscale x 4 x half> %bc = bitcast <vscale x 4 x i16> %v to <vscale x 4 x half>
ret <vscale x 4 x half> %bc ret <vscale x 4 x half> %bc
} }
; TODO: Invalid code generation because the bitcast must change the in-register
; layout when casting between unpacked scalable vector types.
define <vscale x 4 x half> @bitcast_nxv2i32_to_nxv4f16(<vscale x 2 x i32> %v) #0 { define <vscale x 4 x half> @bitcast_nxv2i32_to_nxv4f16(<vscale x 2 x i32> %v) #0 {
; CHECK-LABEL: bitcast_nxv2i32_to_nxv4f16: ; CHECK-LABEL: bitcast_nxv2i32_to_nxv4f16:
; CHECK: // %bb.0: ; CHECK: // %bb.0:
; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill
; CHECK-NEXT: addvl sp, sp, #-1
; CHECK-NEXT: ptrue p0.d
; CHECK-NEXT: st1w { z0.d }, p0, [sp, #1, mul vl]
; CHECK-NEXT: ptrue p0.s
; CHECK-NEXT: ld1h { z0.s }, p0/z, [sp, #1, mul vl]
; CHECK-NEXT: addvl sp, sp, #1
; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload
; CHECK-NEXT: ret ; CHECK-NEXT: ret
%bc = bitcast <vscale x 2 x i32> %v to <vscale x 4 x half> %bc = bitcast <vscale x 2 x i32> %v to <vscale x 4 x half>
ret <vscale x 4 x half> %bc ret <vscale x 4 x half> %bc
} }
; TODO: Invalid code generation because the bitcast must change the in-register ; @bitcast_nxv1i64_to_nxv4f16 is missing
; layout when casting between unpacked scalable vector types.
define <vscale x 4 x half> @bitcast_nxv2f32_to_nxv4f16(<vscale x 2 x float> %v) #0 { define <vscale x 4 x half> @bitcast_nxv2f32_to_nxv4f16(<vscale x 2 x float> %v) #0 {
; CHECK-LABEL: bitcast_nxv2f32_to_nxv4f16: ; CHECK-LABEL: bitcast_nxv2f32_to_nxv4f16:
; CHECK: // %bb.0: ; CHECK: // %bb.0:
; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill
; CHECK-NEXT: addvl sp, sp, #-1
; CHECK-NEXT: ptrue p0.d
; CHECK-NEXT: st1w { z0.d }, p0, [sp, #1, mul vl]
; CHECK-NEXT: ptrue p0.s
; CHECK-NEXT: ld1h { z0.s }, p0/z, [sp, #1, mul vl]
; CHECK-NEXT: addvl sp, sp, #1
; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload
; CHECK-NEXT: ret ; CHECK-NEXT: ret
%bc = bitcast <vscale x 2 x float> %v to <vscale x 4 x half> %bc = bitcast <vscale x 2 x float> %v to <vscale x 4 x half>
ret <vscale x 4 x half> %bc ret <vscale x 4 x half> %bc
} }
; @bitcast_nxv1f64_to_nxv4f16 is missing
define <vscale x 4 x half> @bitcast_nxv4bf16_to_nxv4f16(<vscale x 4 x bfloat> %v) #0 { define <vscale x 4 x half> @bitcast_nxv4bf16_to_nxv4f16(<vscale x 4 x bfloat> %v) #0 {
; CHECK-LABEL: bitcast_nxv4bf16_to_nxv4f16: ; CHECK-LABEL: bitcast_nxv4bf16_to_nxv4f16:
; CHECK: // %bb.0: ; CHECK: // %bb.0:
; CHECK-NEXT: ret ; CHECK-NEXT: ret
%bc = bitcast <vscale x 4 x bfloat> %v to <vscale x 4 x half> %bc = bitcast <vscale x 4 x bfloat> %v to <vscale x 4 x half>
ret <vscale x 4 x half> %bc ret <vscale x 4 x half> %bc
} }
Show All 12 Lines
; CHECK-NEXT: ld1w { z0.d }, p0/z, [sp, #1, mul vl] ; CHECK-NEXT: ld1w { z0.d }, p0/z, [sp, #1, mul vl]
; CHECK-NEXT: addvl sp, sp, #1 ; CHECK-NEXT: addvl sp, sp, #1
; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload ; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload
; CHECK-NEXT: ret ; CHECK-NEXT: ret
%bc = bitcast <vscale x 8 x i8> %v to <vscale x 2 x float> %bc = bitcast <vscale x 8 x i8> %v to <vscale x 2 x float>
ret <vscale x 2 x float> %bc ret <vscale x 2 x float> %bc
} }
; TODO: Invalid code generation because the bitcast must change the in-register
; layout when casting between unpacked scalable vector types.
define <vscale x 2 x float> @bitcast_nxv4i16_to_nxv2f32(<vscale x 4 x i16> %v) #0 { define <vscale x 2 x float> @bitcast_nxv4i16_to_nxv2f32(<vscale x 4 x i16> %v) #0 {
; CHECK-LABEL: bitcast_nxv4i16_to_nxv2f32: ; CHECK-LABEL: bitcast_nxv4i16_to_nxv2f32:
; CHECK: // %bb.0: ; CHECK: // %bb.0:
; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill
; CHECK-NEXT: addvl sp, sp, #-1
; CHECK-NEXT: ptrue p0.s
; CHECK-NEXT: st1h { z0.s }, p0, [sp, #1, mul vl]
; CHECK-NEXT: ptrue p0.d
; CHECK-NEXT: ld1w { z0.d }, p0/z, [sp, #1, mul vl]
; CHECK-NEXT: addvl sp, sp, #1
; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload
; CHECK-NEXT: ret ; CHECK-NEXT: ret
%bc = bitcast <vscale x 4 x i16> %v to <vscale x 2 x float> %bc = bitcast <vscale x 4 x i16> %v to <vscale x 2 x float>
ret <vscale x 2 x float> %bc ret <vscale x 2 x float> %bc
} }
define <vscale x 2 x float> @bitcast_nxv2i32_to_nxv2f32(<vscale x 2 x i32> %v) #0 { define <vscale x 2 x float> @bitcast_nxv2i32_to_nxv2f32(<vscale x 2 x i32> %v) #0 {
; CHECK-LABEL: bitcast_nxv2i32_to_nxv2f32: ; CHECK-LABEL: bitcast_nxv2i32_to_nxv2f32:
; CHECK: // %bb.0: ; CHECK: // %bb.0:
; CHECK-NEXT: ret ; CHECK-NEXT: ret
%bc = bitcast <vscale x 2 x i32> %v to <vscale x 2 x float> %bc = bitcast <vscale x 2 x i32> %v to <vscale x 2 x float>
ret <vscale x 2 x float> %bc ret <vscale x 2 x float> %bc
} }
; TODO: Invalid code generation because the bitcast must change the in-register ; @bitcast_nxv1i64_to_nxv2f32 is missing
; layout when casting between unpacked scalable vector types.
define <vscale x 2 x float> @bitcast_nxv4f16_to_nxv2f32(<vscale x 4 x half> %v) #0 { define <vscale x 2 x float> @bitcast_nxv4f16_to_nxv2f32(<vscale x 4 x half> %v) #0 {
; CHECK-LABEL: bitcast_nxv4f16_to_nxv2f32: ; CHECK-LABEL: bitcast_nxv4f16_to_nxv2f32:
; CHECK: // %bb.0: ; CHECK: // %bb.0:
; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill
; CHECK-NEXT: addvl sp, sp, #-1
; CHECK-NEXT: ptrue p0.s
; CHECK-NEXT: st1h { z0.s }, p0, [sp, #1, mul vl]
; CHECK-NEXT: ptrue p0.d
; CHECK-NEXT: ld1w { z0.d }, p0/z, [sp, #1, mul vl]
; CHECK-NEXT: addvl sp, sp, #1
; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload
; CHECK-NEXT: ret ; CHECK-NEXT: ret
%bc = bitcast <vscale x 4 x half> %v to <vscale x 2 x float> %bc = bitcast <vscale x 4 x half> %v to <vscale x 2 x float>
ret <vscale x 2 x float> %bc ret <vscale x 2 x float> %bc
} }
; TODO: Invalid code generation because the bitcast must change the in-register ; @bitcast_nxv1f64_to_nxv2f32 is missing
; layout when casting between unpacked scalable vector types.
define <vscale x 2 x float> @bitcast_nxv4bf16_to_nxv2f32(<vscale x 4 x bfloat> %v) #0 { define <vscale x 2 x float> @bitcast_nxv4bf16_to_nxv2f32(<vscale x 4 x bfloat> %v) #0 {
; CHECK-LABEL: bitcast_nxv4bf16_to_nxv2f32: ; CHECK-LABEL: bitcast_nxv4bf16_to_nxv2f32:
; CHECK: // %bb.0: ; CHECK: // %bb.0:
; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill
; CHECK-NEXT: addvl sp, sp, #-1
; CHECK-NEXT: ptrue p0.s
; CHECK-NEXT: st1h { z0.s }, p0, [sp, #1, mul vl]
; CHECK-NEXT: ptrue p0.d
; CHECK-NEXT: ld1w { z0.d }, p0/z, [sp, #1, mul vl]
; CHECK-NEXT: addvl sp, sp, #1
; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload
; CHECK-NEXT: ret ; CHECK-NEXT: ret
%bc = bitcast <vscale x 4 x bfloat> %v to <vscale x 2 x float> %bc = bitcast <vscale x 4 x bfloat> %v to <vscale x 2 x float>
ret <vscale x 2 x float> %bc ret <vscale x 2 x float> %bc
} }
; ;
; bitcast to nxv1f64
;
; @bitcast_nxv8i8_to_nxv1f64 is missing
; @bitcast_nxv4i16_to_nxv1f64 is missing
; @bitcast_nxv2i32_to_nxv1f64 is missing
; @bitcast_nxv1i64_to_nxv1f64 is missing
; @bitcast_nxv4f16_to_nxv1f64 is missing
; @bitcast_nxv2f32_to_nxv1f64 is missing
; @bitcast_nxv4bf16_to_nxv1f64 is missing
;
; bitcast to nxv4bf16 ; bitcast to nxv4bf16
; ;
define <vscale x 4 x bfloat> @bitcast_nxv8i8_to_nxv4bf16(<vscale x 8 x i8> %v) #0 { define <vscale x 4 x bfloat> @bitcast_nxv8i8_to_nxv4bf16(<vscale x 8 x i8> %v) #0 {
; CHECK-LABEL: bitcast_nxv8i8_to_nxv4bf16: ; CHECK-LABEL: bitcast_nxv8i8_to_nxv4bf16:
; CHECK: // %bb.0: ; CHECK: // %bb.0:
; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill ; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill
; CHECK-NEXT: addvl sp, sp, #-1 ; CHECK-NEXT: addvl sp, sp, #-1
Show All 11 Lines
define <vscale x 4 x bfloat> @bitcast_nxv4i16_to_nxv4bf16(<vscale x 4 x i16> %v) #0 { define <vscale x 4 x bfloat> @bitcast_nxv4i16_to_nxv4bf16(<vscale x 4 x i16> %v) #0 {
; CHECK-LABEL: bitcast_nxv4i16_to_nxv4bf16: ; CHECK-LABEL: bitcast_nxv4i16_to_nxv4bf16:
; CHECK: // %bb.0: ; CHECK: // %bb.0:
; CHECK-NEXT: ret ; CHECK-NEXT: ret
%bc = bitcast <vscale x 4 x i16> %v to <vscale x 4 x bfloat> %bc = bitcast <vscale x 4 x i16> %v to <vscale x 4 x bfloat>
ret <vscale x 4 x bfloat> %bc ret <vscale x 4 x bfloat> %bc
} }
; TODO: Invalid code generation because the bitcast must change the in-register
; layout when casting between unpacked scalable vector types.
define <vscale x 4 x bfloat> @bitcast_nxv2i32_to_nxv4bf16(<vscale x 2 x i32> %v) #0 { define <vscale x 4 x bfloat> @bitcast_nxv2i32_to_nxv4bf16(<vscale x 2 x i32> %v) #0 {
; CHECK-LABEL: bitcast_nxv2i32_to_nxv4bf16: ; CHECK-LABEL: bitcast_nxv2i32_to_nxv4bf16:
; CHECK: // %bb.0: ; CHECK: // %bb.0:
; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill
; CHECK-NEXT: addvl sp, sp, #-1
; CHECK-NEXT: ptrue p0.d
; CHECK-NEXT: st1w { z0.d }, p0, [sp, #1, mul vl]
; CHECK-NEXT: ptrue p0.s
; CHECK-NEXT: ld1h { z0.s }, p0/z, [sp, #1, mul vl]
; CHECK-NEXT: addvl sp, sp, #1
; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload
; CHECK-NEXT: ret ; CHECK-NEXT: ret
%bc = bitcast <vscale x 2 x i32> %v to <vscale x 4 x bfloat> %bc = bitcast <vscale x 2 x i32> %v to <vscale x 4 x bfloat>
ret <vscale x 4 x bfloat> %bc ret <vscale x 4 x bfloat> %bc
} }
; @bitcast_nxv1i64_to_nxv4bf16 is missing
define <vscale x 4 x bfloat> @bitcast_nxv4f16_to_nxv4bf16(<vscale x 4 x half> %v) #0 { define <vscale x 4 x bfloat> @bitcast_nxv4f16_to_nxv4bf16(<vscale x 4 x half> %v) #0 {
; CHECK-LABEL: bitcast_nxv4f16_to_nxv4bf16: ; CHECK-LABEL: bitcast_nxv4f16_to_nxv4bf16:
; CHECK: // %bb.0: ; CHECK: // %bb.0:
; CHECK-NEXT: ret ; CHECK-NEXT: ret
%bc = bitcast <vscale x 4 x half> %v to <vscale x 4 x bfloat> %bc = bitcast <vscale x 4 x half> %v to <vscale x 4 x bfloat>
ret <vscale x 4 x bfloat> %bc ret <vscale x 4 x bfloat> %bc
} }
; TODO: Invalid code generation because the bitcast must change the in-register
; layout when casting between unpacked scalable vector types.
define <vscale x 4 x bfloat> @bitcast_nxv2f32_to_nxv4bf16(<vscale x 2 x float> %v) #0 { define <vscale x 4 x bfloat> @bitcast_nxv2f32_to_nxv4bf16(<vscale x 2 x float> %v) #0 {
; CHECK-LABEL: bitcast_nxv2f32_to_nxv4bf16: ; CHECK-LABEL: bitcast_nxv2f32_to_nxv4bf16:
; CHECK: // %bb.0: ; CHECK: // %bb.0:
; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill
; CHECK-NEXT: addvl sp, sp, #-1
; CHECK-NEXT: ptrue p0.d
; CHECK-NEXT: st1w { z0.d }, p0, [sp, #1, mul vl]
; CHECK-NEXT: ptrue p0.s
; CHECK-NEXT: ld1h { z0.s }, p0/z, [sp, #1, mul vl]
; CHECK-NEXT: addvl sp, sp, #1
; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload
; CHECK-NEXT: ret ; CHECK-NEXT: ret
%bc = bitcast <vscale x 2 x float> %v to <vscale x 4 x bfloat> %bc = bitcast <vscale x 2 x float> %v to <vscale x 4 x bfloat>
ret <vscale x 4 x bfloat> %bc ret <vscale x 4 x bfloat> %bc
} }
; @bitcast_nxv1f64_to_nxv4bf16 is missing
; ;
; bitcast to nxv4i8 ; bitcast to nxv4i8
; ;
define <vscale x 4 x i8> @bitcast_nxv2i16_to_nxv4i8(<vscale x 2 x i16> %v) #0 { define <vscale x 4 x i8> @bitcast_nxv2i16_to_nxv4i8(<vscale x 2 x i16> %v) #0 {
; CHECK-LABEL: bitcast_nxv2i16_to_nxv4i8: ; CHECK-LABEL: bitcast_nxv2i16_to_nxv4i8:
; CHECK: // %bb.0: ; CHECK: // %bb.0:
; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill ; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill
; CHECK-NEXT: addvl sp, sp, #-1 ; CHECK-NEXT: addvl sp, sp, #-1
; CHECK-NEXT: ptrue p0.d ; CHECK-NEXT: ptrue p0.d
; CHECK-NEXT: st1h { z0.d }, p0, [sp, #3, mul vl] ; CHECK-NEXT: st1h { z0.d }, p0, [sp, #3, mul vl]
; CHECK-NEXT: ptrue p0.s ; CHECK-NEXT: ptrue p0.s
; CHECK-NEXT: ld1b { z0.s }, p0/z, [sp, #3, mul vl] ; CHECK-NEXT: ld1b { z0.s }, p0/z, [sp, #3, mul vl]
; CHECK-NEXT: addvl sp, sp, #1 ; CHECK-NEXT: addvl sp, sp, #1
; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload ; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload
; CHECK-NEXT: ret ; CHECK-NEXT: ret
%bc = bitcast <vscale x 2 x i16> %v to <vscale x 4 x i8> %bc = bitcast <vscale x 2 x i16> %v to <vscale x 4 x i8>
ret <vscale x 4 x i8> %bc ret <vscale x 4 x i8> %bc
} }
define <vscale x 4 x i8> @bitcast_nxv1i32_to_nxv4i8(<vscale x 1 x i32> %v) #0 {
; CHECK-LABEL: bitcast_nxv1i32_to_nxv4i8:
; CHECK: // %bb.0:
; CHECK-NEXT: uunpklo z0.h, z0.b
; CHECK-NEXT: uunpklo z0.s, z0.h
; CHECK-NEXT: ret
%bc = bitcast <vscale x 1 x i32> %v to <vscale x 4 x i8>
ret <vscale x 4 x i8> %bc
}
define <vscale x 4 x i8> @bitcast_nxv2f16_to_nxv4i8(<vscale x 2 x half> %v) #0 { define <vscale x 4 x i8> @bitcast_nxv2f16_to_nxv4i8(<vscale x 2 x half> %v) #0 {
; CHECK-LABEL: bitcast_nxv2f16_to_nxv4i8: ; CHECK-LABEL: bitcast_nxv2f16_to_nxv4i8:
; CHECK: // %bb.0: ; CHECK: // %bb.0:
; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill ; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill
; CHECK-NEXT: addvl sp, sp, #-1 ; CHECK-NEXT: addvl sp, sp, #-1
; CHECK-NEXT: ptrue p0.d ; CHECK-NEXT: ptrue p0.d
; CHECK-NEXT: st1h { z0.d }, p0, [sp, #3, mul vl] ; CHECK-NEXT: st1h { z0.d }, p0, [sp, #3, mul vl]
; CHECK-NEXT: ptrue p0.s ; CHECK-NEXT: ptrue p0.s
; CHECK-NEXT: ld1b { z0.s }, p0/z, [sp, #3, mul vl] ; CHECK-NEXT: ld1b { z0.s }, p0/z, [sp, #3, mul vl]
; CHECK-NEXT: addvl sp, sp, #1 ; CHECK-NEXT: addvl sp, sp, #1
; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload ; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload
; CHECK-NEXT: ret ; CHECK-NEXT: ret
%bc = bitcast <vscale x 2 x half> %v to <vscale x 4 x i8> %bc = bitcast <vscale x 2 x half> %v to <vscale x 4 x i8>
ret <vscale x 4 x i8> %bc ret <vscale x 4 x i8> %bc
} }
; @bitcast_nxv1f32_to_nxv4i8 is missing
define <vscale x 4 x i8> @bitcast_nxv2bf16_to_nxv4i8(<vscale x 2 x bfloat> %v) #0 { define <vscale x 4 x i8> @bitcast_nxv2bf16_to_nxv4i8(<vscale x 2 x bfloat> %v) #0 {
; CHECK-LABEL: bitcast_nxv2bf16_to_nxv4i8: ; CHECK-LABEL: bitcast_nxv2bf16_to_nxv4i8:
; CHECK: // %bb.0: ; CHECK: // %bb.0:
; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill ; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill
; CHECK-NEXT: addvl sp, sp, #-1 ; CHECK-NEXT: addvl sp, sp, #-1
; CHECK-NEXT: ptrue p0.d ; CHECK-NEXT: ptrue p0.d
; CHECK-NEXT: st1h { z0.d }, p0, [sp, #3, mul vl] ; CHECK-NEXT: st1h { z0.d }, p0, [sp, #3, mul vl]
; CHECK-NEXT: ptrue p0.s ; CHECK-NEXT: ptrue p0.s
Show All 20 Lines
; CHECK-NEXT: ld1h { z0.d }, p0/z, [sp, #3, mul vl] ; CHECK-NEXT: ld1h { z0.d }, p0/z, [sp, #3, mul vl]
; CHECK-NEXT: addvl sp, sp, #1 ; CHECK-NEXT: addvl sp, sp, #1
; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload ; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload
; CHECK-NEXT: ret ; CHECK-NEXT: ret
%bc = bitcast <vscale x 4 x i8> %v to <vscale x 2 x i16> %bc = bitcast <vscale x 4 x i8> %v to <vscale x 2 x i16>
ret <vscale x 2 x i16> %bc ret <vscale x 2 x i16> %bc
} }
define <vscale x 2 x i16> @bitcast_nxv1i32_to_nxv2i16(<vscale x 1 x i32> %v) #0 {
; CHECK-LABEL: bitcast_nxv1i32_to_nxv2i16:
; CHECK: // %bb.0:
; CHECK-NEXT: uunpklo z0.s, z0.h
; CHECK-NEXT: uunpklo z0.d, z0.s
; CHECK-NEXT: ret
%bc = bitcast <vscale x 1 x i32> %v to <vscale x 2 x i16>
ret <vscale x 2 x i16> %bc
}
define <vscale x 2 x i16> @bitcast_nxv2f16_to_nxv2i16(<vscale x 2 x half> %v) #0 { define <vscale x 2 x i16> @bitcast_nxv2f16_to_nxv2i16(<vscale x 2 x half> %v) #0 {
; CHECK-LABEL: bitcast_nxv2f16_to_nxv2i16: ; CHECK-LABEL: bitcast_nxv2f16_to_nxv2i16:
; CHECK: // %bb.0: ; CHECK: // %bb.0:
; CHECK-NEXT: ret ; CHECK-NEXT: ret
%bc = bitcast <vscale x 2 x half> %v to <vscale x 2 x i16> %bc = bitcast <vscale x 2 x half> %v to <vscale x 2 x i16>
ret <vscale x 2 x i16> %bc ret <vscale x 2 x i16> %bc
} }
; @bitcast_nxv1f32_to_nxv2i16 is missing
define <vscale x 2 x i16> @bitcast_nxv2bf16_to_nxv2i16(<vscale x 2 x bfloat> %v) #0 { define <vscale x 2 x i16> @bitcast_nxv2bf16_to_nxv2i16(<vscale x 2 x bfloat> %v) #0 {
; CHECK-LABEL: bitcast_nxv2bf16_to_nxv2i16: ; CHECK-LABEL: bitcast_nxv2bf16_to_nxv2i16:
; CHECK: // %bb.0: ; CHECK: // %bb.0:
; CHECK-NEXT: ret ; CHECK-NEXT: ret
%bc = bitcast <vscale x 2 x bfloat> %v to <vscale x 2 x i16> %bc = bitcast <vscale x 2 x bfloat> %v to <vscale x 2 x i16>
ret <vscale x 2 x i16> %bc ret <vscale x 2 x i16> %bc
} }
; ;
; bitcast to nxv1i32
;
define <vscale x 1 x i32> @bitcast_nxv4i8_to_nxv1i32(<vscale x 4 x i8> %v) #0 {
; CHECK-LABEL: bitcast_nxv4i8_to_nxv1i32:
; CHECK: // %bb.0:
; CHECK-NEXT: uzp1 z0.h, z0.h, z0.h
; CHECK-NEXT: uzp1 z0.b, z0.b, z0.b
; CHECK-NEXT: ret
%bc = bitcast <vscale x 4 x i8> %v to <vscale x 1 x i32>
ret <vscale x 1 x i32> %bc
}
define <vscale x 1 x i32> @bitcast_nxv2i16_to_nxv1i32(<vscale x 2 x i16> %v) #0 {
; CHECK-LABEL: bitcast_nxv2i16_to_nxv1i32:
; CHECK: // %bb.0:
; CHECK-NEXT: uzp1 z0.s, z0.s, z0.s
; CHECK-NEXT: uzp1 z0.h, z0.h, z0.h
; CHECK-NEXT: ret
%bc = bitcast <vscale x 2 x i16> %v to <vscale x 1 x i32>
ret <vscale x 1 x i32> %bc
}
define <vscale x 1 x i32> @bitcast_nxv2f16_to_nxv1i32(<vscale x 2 x half> %v) #0 {
; CHECK-LABEL: bitcast_nxv2f16_to_nxv1i32:
; CHECK: // %bb.0:
; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill
; CHECK-NEXT: addvl sp, sp, #-1
; CHECK-NEXT: ptrue p0.d
; CHECK-NEXT: st1h { z0.d }, p0, [sp]
; CHECK-NEXT: ptrue p0.s
; CHECK-NEXT: ld1w { z0.s }, p0/z, [sp]
; CHECK-NEXT: addvl sp, sp, #1
; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload
; CHECK-NEXT: ret
%bc = bitcast <vscale x 2 x half> %v to <vscale x 1 x i32>
ret <vscale x 1 x i32> %bc
}
; @bitcast_nxv1f32_to_nxv1i32 is missing
define <vscale x 1 x i32> @bitcast_nxv2bf16_to_nxv1i32(<vscale x 2 x bfloat> %v) #0 {
; CHECK-LABEL: bitcast_nxv2bf16_to_nxv1i32:
; CHECK: // %bb.0:
; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill
; CHECK-NEXT: addvl sp, sp, #-1
; CHECK-NEXT: ptrue p0.d
; CHECK-NEXT: st1h { z0.d }, p0, [sp]
; CHECK-NEXT: ptrue p0.s
; CHECK-NEXT: ld1w { z0.s }, p0/z, [sp]
; CHECK-NEXT: addvl sp, sp, #1
; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload
; CHECK-NEXT: ret
%bc = bitcast <vscale x 2 x bfloat> %v to <vscale x 1 x i32>
ret <vscale x 1 x i32> %bc
}
;
; bitcast to nxv2f16 ; bitcast to nxv2f16
; ;
define <vscale x 2 x half> @bitcast_nxv4i8_to_nxv2f16(<vscale x 4 x i8> %v) #0 { define <vscale x 2 x half> @bitcast_nxv4i8_to_nxv2f16(<vscale x 4 x i8> %v) #0 {
; CHECK-LABEL: bitcast_nxv4i8_to_nxv2f16: ; CHECK-LABEL: bitcast_nxv4i8_to_nxv2f16:
; CHECK: // %bb.0: ; CHECK: // %bb.0:
; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill ; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill
; CHECK-NEXT: addvl sp, sp, #-1 ; CHECK-NEXT: addvl sp, sp, #-1
Show All 11 Lines
define <vscale x 2 x half> @bitcast_nxv2i16_to_nxv2f16(<vscale x 2 x i16> %v) #0 { define <vscale x 2 x half> @bitcast_nxv2i16_to_nxv2f16(<vscale x 2 x i16> %v) #0 {
; CHECK-LABEL: bitcast_nxv2i16_to_nxv2f16: ; CHECK-LABEL: bitcast_nxv2i16_to_nxv2f16:
; CHECK: // %bb.0: ; CHECK: // %bb.0:
; CHECK-NEXT: ret ; CHECK-NEXT: ret
%bc = bitcast <vscale x 2 x i16> %v to <vscale x 2 x half> %bc = bitcast <vscale x 2 x i16> %v to <vscale x 2 x half>
ret <vscale x 2 x half> %bc ret <vscale x 2 x half> %bc
} }
; @bitcast_nxv1i32_to_nxv2f16 is missing
; @bitcast_nxv1f32_to_nxv2f16 is missing
define <vscale x 2 x half> @bitcast_nxv2bf16_to_nxv2f16(<vscale x 2 x bfloat> %v) #0 { define <vscale x 2 x half> @bitcast_nxv2bf16_to_nxv2f16(<vscale x 2 x bfloat> %v) #0 {
; CHECK-LABEL: bitcast_nxv2bf16_to_nxv2f16: ; CHECK-LABEL: bitcast_nxv2bf16_to_nxv2f16:
; CHECK: // %bb.0: ; CHECK: // %bb.0:
; CHECK-NEXT: ret ; CHECK-NEXT: ret
%bc = bitcast <vscale x 2 x bfloat> %v to <vscale x 2 x half> %bc = bitcast <vscale x 2 x bfloat> %v to <vscale x 2 x half>
ret <vscale x 2 x half> %bc ret <vscale x 2 x half> %bc
} }
Show All 20 Lines
define <vscale x 2 x bfloat> @bitcast_nxv2i16_to_nxv2bf16(<vscale x 2 x i16> %v) #0 { define <vscale x 2 x bfloat> @bitcast_nxv2i16_to_nxv2bf16(<vscale x 2 x i16> %v) #0 {
; CHECK-LABEL: bitcast_nxv2i16_to_nxv2bf16: ; CHECK-LABEL: bitcast_nxv2i16_to_nxv2bf16:
; CHECK: // %bb.0: ; CHECK: // %bb.0:
; CHECK-NEXT: ret ; CHECK-NEXT: ret
%bc = bitcast <vscale x 2 x i16> %v to <vscale x 2 x bfloat> %bc = bitcast <vscale x 2 x i16> %v to <vscale x 2 x bfloat>
ret <vscale x 2 x bfloat> %bc ret <vscale x 2 x bfloat> %bc
} }
; @bitcast_nxv1i32_to_nxv2bf16 is missing
define <vscale x 2 x bfloat> @bitcast_nxv2f16_to_nxv2bf16(<vscale x 2 x half> %v) #0 { define <vscale x 2 x bfloat> @bitcast_nxv2f16_to_nxv2bf16(<vscale x 2 x half> %v) #0 {
; CHECK-LABEL: bitcast_nxv2f16_to_nxv2bf16: ; CHECK-LABEL: bitcast_nxv2f16_to_nxv2bf16:
; CHECK: // %bb.0: ; CHECK: // %bb.0:
; CHECK-NEXT: ret ; CHECK-NEXT: ret
%bc = bitcast <vscale x 2 x half> %v to <vscale x 2 x bfloat> %bc = bitcast <vscale x 2 x half> %v to <vscale x 2 x bfloat>
ret <vscale x 2 x bfloat> %bc ret <vscale x 2 x bfloat> %bc
} }
; @bitcast_nxv1f32_to_nxv2bf16 is missing
;
; bitcast to nxv2i8
;
define <vscale x 2 x i8> @bitcast_nxv1i16_to_nxv2i8(<vscale x 1 x i16> %v) #0 {
; CHECK-LABEL: bitcast_nxv1i16_to_nxv2i8:
; CHECK: // %bb.0:
; CHECK-NEXT: uunpklo z0.h, z0.b
; CHECK-NEXT: uunpklo z0.s, z0.h
; CHECK-NEXT: uunpklo z0.d, z0.s
; CHECK-NEXT: ret
%bc = bitcast <vscale x 1 x i16> %v to <vscale x 2 x i8>
ret <vscale x 2 x i8> %bc
}
; @bitcast_nxv1f16_to_nxv2i8 is missing
; @bitcast_nxv1bf16_to_nxv2i8 is missing
;
; bitcast to nxv1i16
;
define <vscale x 1 x i16> @bitcast_nxv2i8_to_nxv1i16(<vscale x 2 x i8> %v) #0 {
; CHECK-LABEL: bitcast_nxv2i8_to_nxv1i16:
; CHECK: // %bb.0:
; CHECK-NEXT: uzp1 z0.s, z0.s, z0.s
; CHECK-NEXT: uzp1 z0.h, z0.h, z0.h
; CHECK-NEXT: uzp1 z0.b, z0.b, z0.b
; CHECK-NEXT: ret
%bc = bitcast <vscale x 2 x i8> %v to <vscale x 1 x i16>
ret <vscale x 1 x i16> %bc
}
; @bitcast_nxv1f16_to_nxv1i16 is missing
; @bitcast_nxv1bf16_to_nxv1i16 is missing
; ;
; Other ; Other
; ;
define <vscale x 2 x i32> @bitcast_short_float_to_i32(<vscale x 2 x double> %v) #0 { define <vscale x 2 x i32> @bitcast_short_float_to_i32(<vscale x 2 x double> %v) #0 {
; CHECK-LABEL: bitcast_short_float_to_i32: ; CHECK-LABEL: bitcast_short_float_to_i32:
; CHECK: // %bb.0: ; CHECK: // %bb.0:
; CHECK-NEXT: ptrue p0.d ; CHECK-NEXT: ptrue p0.d
Show All 11 Lines
; CHECK-NEXT: fcvt z0.d, p0/m, z0.s ; CHECK-NEXT: fcvt z0.d, p0/m, z0.s
; CHECK-NEXT: ret ; CHECK-NEXT: ret
%trunc = trunc <vscale x 2 x i64> %v to <vscale x 2 x i32> %trunc = trunc <vscale x 2 x i64> %v to <vscale x 2 x i32>
%bitcast = bitcast <vscale x 2 x i32> %trunc to <vscale x 2 x float> %bitcast = bitcast <vscale x 2 x i32> %trunc to <vscale x 2 x float>
%extended = fpext <vscale x 2 x float> %bitcast to <vscale x 2 x double> %extended = fpext <vscale x 2 x float> %bitcast to <vscale x 2 x double>
ret <vscale x 2 x double> %extended ret <vscale x 2 x double> %extended
} }
; TODO: Invalid code generation because the bitcast must change the in-register
; layout when casting between unpacked scalable vector types.
define <vscale x 2 x float> @bitcast_short_half_to_float(<vscale x 4 x half> %v) #0 { define <vscale x 2 x float> @bitcast_short_half_to_float(<vscale x 4 x half> %v) #0 {
; CHECK-LABEL: bitcast_short_half_to_float: ; CHECK-LABEL: bitcast_short_half_to_float:
; CHECK: // %bb.0: ; CHECK: // %bb.0:
; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill
; CHECK-NEXT: addvl sp, sp, #-1
; CHECK-NEXT: ptrue p0.s ; CHECK-NEXT: ptrue p0.s
; CHECK-NEXT: fadd z0.h, p0/m, z0.h, z0.h ; CHECK-NEXT: fadd z0.h, p0/m, z0.h, z0.h
; CHECK-NEXT: st1h { z0.s }, p0, [sp, #1, mul vl]
; CHECK-NEXT: ptrue p0.d
; CHECK-NEXT: ld1w { z0.d }, p0/z, [sp, #1, mul vl]
; CHECK-NEXT: addvl sp, sp, #1
; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload
; CHECK-NEXT: ret ; CHECK-NEXT: ret
%add = fadd <vscale x 4 x half> %v, %v %add = fadd <vscale x 4 x half> %v, %v
%bitcast = bitcast <vscale x 4 x half> %add to <vscale x 2 x float> %bitcast = bitcast <vscale x 4 x half> %add to <vscale x 2 x float>
ret <vscale x 2 x float> %bitcast ret <vscale x 2 x float> %bitcast
} }
; +bf16 is required for the bfloat version. ; +bf16 is required for the bfloat version.
attributes #0 = { nounwind "target-features"="+sve,+bf16" } attributes #0 = { nounwind "target-features"="+sve,+bf16" }

llvm/test/CodeGen/DirectX/typed_ptr.ll

  • This file was added.
; RUN: opt -S -dxil-prepare < %s | FileCheck %s
target triple = "dxil-unknown-unknown"
; Make sure not crash when has typed ptr.
; CHECK:@test
define i64 @test(i64* %p) {
%v = load i64, i64* %p
ret i64 %v
}

llvm/test/CodeGen/RISCV/early-clobber-tied-def-subreg-liveness.ll

  • This file was added.
; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc -O2 -mtriple riscv64 -mattr=+v,+m,+zbb -riscv-enable-subreg-liveness < %s \
; RUN: | FileCheck %s
@var_47 = dso_local global [2 x i16] [i16 -32732, i16 19439], align 2
@__const._Z3foov.var_49 = private unnamed_addr constant [2 x i16] [i16 157, i16 24062], align 2
@__const._Z3foov.var_48 = private unnamed_addr constant [2 x i8] c"\AEN", align 1
@__const._Z3foov.var_46 = private unnamed_addr constant [2 x i16] [i16 729, i16 -32215], align 2
@__const._Z3foov.var_45 = private unnamed_addr constant [2 x i16] [i16 -27462, i16 -1435], align 2
@__const._Z3foov.var_44 = private unnamed_addr constant [2 x i16] [i16 22611, i16 -18435], align 2
@__const._Z3foov.var_40 = private unnamed_addr constant [2 x i16] [i16 -19932, i16 -26252], align 2
define void @_Z3foov() {
; CHECK-LABEL: _Z3foov:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: addi sp, sp, -16
; CHECK-NEXT: .cfi_def_cfa_offset 16
; CHECK-NEXT: csrr a0, vlenb
; CHECK-NEXT: li a1, 10
; CHECK-NEXT: mul a0, a0, a1
; CHECK-NEXT: sub sp, sp, a0
; CHECK-NEXT: lui a0, %hi(.L__const._Z3foov.var_49)
; CHECK-NEXT: addi a0, a0, %lo(.L__const._Z3foov.var_49)
; CHECK-NEXT: vsetivli zero, 2, e16, m2, ta, mu
; CHECK-NEXT: vle16.v v8, (a0)
; CHECK-NEXT: lui a0, %hi(.L__const._Z3foov.var_48)
; CHECK-NEXT: addi a0, a0, %lo(.L__const._Z3foov.var_48)
; CHECK-NEXT: vle8.v v10, (a0)
; CHECK-NEXT: csrr a0, vlenb
; CHECK-NEXT: slli a0, a0, 3
; CHECK-NEXT: add a0, sp, a0
; CHECK-NEXT: addi a0, a0, 16
; CHECK-NEXT: vs1r.v v10, (a0) # Unknown-size Folded Spill
; CHECK-NEXT: lui a0, %hi(.L__const._Z3foov.var_46)
; CHECK-NEXT: addi a0, a0, %lo(.L__const._Z3foov.var_46)
; CHECK-NEXT: vle16.v v10, (a0)
; CHECK-NEXT: lui a0, %hi(.L__const._Z3foov.var_45)
; CHECK-NEXT: addi a0, a0, %lo(.L__const._Z3foov.var_45)
; CHECK-NEXT: vle16.v v12, (a0)
; CHECK-NEXT: addi a0, sp, 16
; CHECK-NEXT: csrr a1, vlenb
; CHECK-NEXT: slli a1, a1, 1
; CHECK-NEXT: vs2r.v v8, (a0) # Unknown-size Folded Spill
; CHECK-NEXT: add a0, a0, a1
; CHECK-NEXT: vs2r.v v10, (a0) # Unknown-size Folded Spill
; CHECK-NEXT: add a0, a0, a1
; CHECK-NEXT: vs2r.v v12, (a0) # Unknown-size Folded Spill
; CHECK-NEXT: add a0, a0, a1
; CHECK-NEXT: vs2r.v v14, (a0) # Unknown-size Folded Spill
; CHECK-NEXT: #APP
; CHECK-NEXT: #NO_APP
; CHECK-NEXT: lui a0, %hi(.L__const._Z3foov.var_44)
; CHECK-NEXT: addi a0, a0, %lo(.L__const._Z3foov.var_44)
; CHECK-NEXT: vsetivli zero, 2, e16, m2, ta, mu
; CHECK-NEXT: addi a1, sp, 16
; CHECK-NEXT: csrr a2, vlenb
; CHECK-NEXT: slli a2, a2, 1
; CHECK-NEXT: vl2r.v v8, (a1) # Unknown-size Folded Reload
; CHECK-NEXT: add a1, a1, a2
; CHECK-NEXT: vl2r.v v10, (a1) # Unknown-size Folded Reload
; CHECK-NEXT: add a1, a1, a2
; CHECK-NEXT: vl2r.v v12, (a1) # Unknown-size Folded Reload
; CHECK-NEXT: add a1, a1, a2
; CHECK-NEXT: vl2r.v v14, (a1) # Unknown-size Folded Reload
; CHECK-NEXT: vle16.v v14, (a0)
; CHECK-NEXT: vsetivli zero, 2, e16, m2, ta, mu
; CHECK-NEXT: lui a0, %hi(.L__const._Z3foov.var_40)
; CHECK-NEXT: addi a0, a0, %lo(.L__const._Z3foov.var_40)
; CHECK-NEXT: vle16.v v8, (a0)
; CHECK-NEXT: vsetivli zero, 2, e16, m2, ta, mu
; CHECK-NEXT: lui a0, 1048572
; CHECK-NEXT: addiw a0, a0, 928
; CHECK-NEXT: vmsbc.vx v0, v8, a0
; CHECK-NEXT: vsetivli zero, 2, e16, m2, tu, mu
; CHECK-NEXT: csrr a0, vlenb
; CHECK-NEXT: slli a0, a0, 3
; CHECK-NEXT: add a0, sp, a0
; CHECK-NEXT: addi a0, a0, 16
; CHECK-NEXT: vl1r.v v16, (a0) # Unknown-size Folded Reload
; CHECK-NEXT: vsext.vf2 v8, v16, v0.t
; CHECK-NEXT: lui a0, %hi(var_47)
; CHECK-NEXT: addi a0, a0, %lo(var_47)
; CHECK-NEXT: vsseg4e16.v v8, (a0)
; CHECK-NEXT: csrr a0, vlenb
; CHECK-NEXT: li a1, 10
; CHECK-NEXT: mul a0, a0, a1
; CHECK-NEXT: add sp, sp, a0
; CHECK-NEXT: addi sp, sp, 16
; CHECK-NEXT: ret
entry:
%0 = tail call <vscale x 8 x i16> @llvm.riscv.vle.nxv8i16.i64(<vscale x 8 x i16> undef, ptr nonnull @__const._Z3foov.var_49, i64 2)
%1 = tail call <vscale x 8 x i8> @llvm.riscv.vle.nxv8i8.i64(<vscale x 8 x i8> undef, ptr nonnull @__const._Z3foov.var_48, i64 2)
%2 = tail call <vscale x 8 x i16> @llvm.riscv.vle.nxv8i16.i64(<vscale x 8 x i16> undef, ptr nonnull @__const._Z3foov.var_46, i64 2)
%3 = tail call <vscale x 8 x i16> @llvm.riscv.vle.nxv8i16.i64(<vscale x 8 x i16> undef, ptr nonnull @__const._Z3foov.var_45, i64 2)
tail call void asm sideeffect "", "~{v0},~{v1},~{v2},~{v3},~{v4},~{v5},~{v6},~{v7},~{v8},~{v9},~{v10},~{v11},~{v12},~{v13},~{v14},~{v15},~{v16},~{v17},~{v18},~{v19},~{v20},~{v21},~{v22},~{v23},~{v24},~{v25},~{v26},~{v27},~{v28},~{v29},~{v30},~{v31}"() #2
%4 = tail call <vscale x 8 x i16> @llvm.riscv.vle.nxv8i16.i64(<vscale x 8 x i16> undef, ptr nonnull @__const._Z3foov.var_44, i64 2)
%5 = tail call i64 @llvm.riscv.vsetvli.i64(i64 2, i64 1, i64 1)
%6 = tail call <vscale x 8 x i16> @llvm.riscv.vle.nxv8i16.i64(<vscale x 8 x i16> undef, ptr nonnull @__const._Z3foov.var_40, i64 2)
%7 = tail call i64 @llvm.riscv.vsetvli.i64(i64 2, i64 1, i64 1)
%8 = tail call <vscale x 8 x i1> @llvm.riscv.vmsbc.nxv8i16.i16.i64(<vscale x 8 x i16> %6, i16 -15456, i64 2)
%9 = tail call i64 @llvm.riscv.vsetvli.i64(i64 2, i64 1, i64 1)
%10 = tail call <vscale x 8 x i16> @llvm.riscv.vsext.mask.nxv8i16.nxv8i8.i64(<vscale x 8 x i16> %0, <vscale x 8 x i8> %1, <vscale x 8 x i1> %8, i64 2, i64 0)
tail call void @llvm.riscv.vsseg4.nxv8i16.i64(<vscale x 8 x i16> %10, <vscale x 8 x i16> %2, <vscale x 8 x i16> %3, <vscale x 8 x i16> %4, ptr nonnull @var_47, i64 2)
ret void
}
declare <vscale x 8 x i16> @llvm.riscv.vle.nxv8i16.i64(<vscale x 8 x i16>, ptr nocapture, i64)
declare <vscale x 8 x i8> @llvm.riscv.vle.nxv8i8.i64(<vscale x 8 x i8>, ptr nocapture, i64)
declare i64 @llvm.riscv.vsetvli.i64(i64, i64 immarg, i64 immarg)
declare <vscale x 8 x i1> @llvm.riscv.vmsbc.nxv8i16.i16.i64(<vscale x 8 x i16>, i16, i64)
declare <vscale x 8 x i16> @llvm.riscv.vsext.mask.nxv8i16.nxv8i8.i64(<vscale x 8 x i16>, <vscale x 8 x i8>, <vscale x 8 x i1>, i64, i64 immarg)
declare void @llvm.riscv.vsseg4.nxv8i16.i64(<vscale x 8 x i16>, <vscale x 8 x i16>, <vscale x 8 x i16>, <vscale x 8 x i16>, ptr nocapture, i64)

llvm/test/CodeGen/RISCV/early-clobber-tied-def-subreg-liveness.mir

  • This file was added.
# REQUIRES: asserts
# RUN: llc %s -run-pass=greedy -debug -riscv-enable-subreg-liveness -o - 2>&1 \
# RUN: | FileCheck %s
--- |
; ModuleID = 'early-clobber-tied-def-subreg-liveness.ll'
source_filename = "early-clobber-tied-def-subreg-liveness.ll"
target datalayout = "e-m:e-p:64:64-i64:64-i128:128-n64-S128"
target triple = "riscv64"
@var_47 = dso_local global [2 x i16] [i16 -32732, i16 19439], align 2
@__const._Z3foov.var_49 = private unnamed_addr constant [2 x i16] [i16 157, i16 24062], align 2
@__const._Z3foov.var_48 = private unnamed_addr constant [2 x i8] c"\AEN", align 1
@__const._Z3foov.var_46 = private unnamed_addr constant [2 x i16] [i16 729, i16 -32215], align 2
@__const._Z3foov.var_45 = private unnamed_addr constant [2 x i16] [i16 -27462, i16 -1435], align 2
@__const._Z3foov.var_44 = private unnamed_addr constant [2 x i16] [i16 22611, i16 -18435], align 2
@__const._Z3foov.var_40 = private unnamed_addr constant [2 x i16] [i16 -19932, i16 -26252], align 2
define void @_Z3foov() #0 {
entry:
%0 = tail call <vscale x 8 x i16> @llvm.riscv.vle.nxv8i16.i64(<vscale x 8 x i16> undef, ptr nonnull @__const._Z3foov.var_49, i64 2)
%1 = tail call <vscale x 8 x i8> @llvm.riscv.vle.nxv8i8.i64(<vscale x 8 x i8> undef, ptr nonnull @__const._Z3foov.var_48, i64 2)
%2 = tail call <vscale x 8 x i16> @llvm.riscv.vle.nxv8i16.i64(<vscale x 8 x i16> undef, ptr nonnull @__const._Z3foov.var_46, i64 2)
%3 = tail call <vscale x 8 x i16> @llvm.riscv.vle.nxv8i16.i64(<vscale x 8 x i16> undef, ptr nonnull @__const._Z3foov.var_45, i64 2)
tail call void asm sideeffect "", "~{v0},~{v1},~{v2},~{v3},~{v4},~{v5},~{v6},~{v7},~{v8},~{v9},~{v10},~{v11},~{v12},~{v13},~{v14},~{v15},~{v16},~{v17},~{v18},~{v19},~{v20},~{v21},~{v22},~{v23},~{v24},~{v25},~{v26},~{v27},~{v28},~{v29},~{v30},~{v31}"()
%4 = tail call <vscale x 8 x i16> @llvm.riscv.vle.nxv8i16.i64(<vscale x 8 x i16> undef, ptr nonnull @__const._Z3foov.var_44, i64 2)
%5 = tail call i64 @llvm.riscv.vsetvli.i64(i64 2, i64 1, i64 1)
%6 = tail call <vscale x 8 x i16> @llvm.riscv.vle.nxv8i16.i64(<vscale x 8 x i16> undef, ptr nonnull @__const._Z3foov.var_40, i64 2)
%7 = tail call i64 @llvm.riscv.vsetvli.i64(i64 2, i64 1, i64 1)
%8 = tail call <vscale x 8 x i1> @llvm.riscv.vmsbc.nxv8i16.i16.i64(<vscale x 8 x i16> %6, i16 -15456, i64 2)
%9 = tail call i64 @llvm.riscv.vsetvli.i64(i64 2, i64 1, i64 1)
%10 = tail call <vscale x 8 x i16> @llvm.riscv.vsext.mask.nxv8i16.nxv8i8.i64(<vscale x 8 x i16> %0, <vscale x 8 x i8> %1, <vscale x 8 x i1> %8, i64 2, i64 0)
tail call void @llvm.riscv.vsseg4.nxv8i16.i64(<vscale x 8 x i16> %10, <vscale x 8 x i16> %2, <vscale x 8 x i16> %3, <vscale x 8 x i16> %4, ptr nonnull @var_47, i64 2)
ret void
}
; Function Attrs: nounwind readonly
declare <vscale x 8 x i16> @llvm.riscv.vle.nxv8i16.i64(<vscale x 8 x i16>, ptr nocapture, i64) #1
; Function Attrs: nounwind readonly
declare <vscale x 8 x i8> @llvm.riscv.vle.nxv8i8.i64(<vscale x 8 x i8>, ptr nocapture, i64) #1
; Function Attrs: nounwind
declare i64 @llvm.riscv.vsetvli.i64(i64, i64 immarg, i64 immarg) #2
; Function Attrs: nounwind readnone
declare <vscale x 8 x i1> @llvm.riscv.vmsbc.nxv8i16.i16.i64(<vscale x 8 x i16>, i16, i64) #3
; Function Attrs: nounwind readnone
declare <vscale x 8 x i16> @llvm.riscv.vsext.mask.nxv8i16.nxv8i8.i64(<vscale x 8 x i16>, <vscale x 8 x i8>, <vscale x 8 x i1>, i64, i64 immarg) #3
; Function Attrs: nounwind writeonly
declare void @llvm.riscv.vsseg4.nxv8i16.i64(<vscale x 8 x i16>, <vscale x 8 x i16>, <vscale x 8 x i16>, <vscale x 8 x i16>, ptr nocapture, i64) #4
attributes #0 = { "target-features"="+v,+m,+zbb" }
attributes #1 = { nounwind readonly "target-features"="+v,+m,+zbb" }
attributes #2 = { nounwind "target-features"="+v,+m,+zbb" }
attributes #3 = { nounwind readnone "target-features"="+v,+m,+zbb" }
attributes #4 = { nounwind writeonly "target-features"="+v,+m,+zbb" }
...
---
name: _Z3foov
alignment: 4
exposesReturnsTwice: false
legalized: false
regBankSelected: false
selected: false
failedISel: false
tracksRegLiveness: true
hasWinCFI: false
callsEHReturn: false
callsUnwindInit: false
hasEHCatchret: false
hasEHScopes: false
hasEHFunclets: false
failsVerification: false
tracksDebugUserValues: false
registers:
- { id: 0, class: gpr, preferred-register: '' }
- { id: 1, class: gpr, preferred-register: '' }
- { id: 2, class: vrm2nov0, preferred-register: '' }
- { id: 3, class: gpr, preferred-register: '' }
- { id: 4, class: gpr, preferred-register: '' }
- { id: 5, class: vr, preferred-register: '' }
- { id: 6, class: gpr, preferred-register: '' }
- { id: 7, class: gpr, preferred-register: '' }
- { id: 8, class: vrm2, preferred-register: '' }
- { id: 9, class: gpr, preferred-register: '' }
- { id: 10, class: gpr, preferred-register: '' }
- { id: 11, class: vrm2, preferred-register: '' }
- { id: 12, class: gpr, preferred-register: '' }
- { id: 13, class: gpr, preferred-register: '' }
- { id: 14, class: vrm2, preferred-register: '' }
- { id: 15, class: gpr, preferred-register: '' }
- { id: 16, class: gpr, preferred-register: '' }
- { id: 17, class: gpr, preferred-register: '' }
- { id: 18, class: vrm2, preferred-register: '' }
- { id: 19, class: gpr, preferred-register: '' }
- { id: 20, class: gpr, preferred-register: '' }
- { id: 21, class: gpr, preferred-register: '' }
- { id: 22, class: vr, preferred-register: '' }
- { id: 23, class: gpr, preferred-register: '' }
- { id: 24, class: vrm2nov0, preferred-register: '' }
- { id: 25, class: vrn4m2nov0, preferred-register: '' }
- { id: 26, class: gpr, preferred-register: '' }
- { id: 27, class: gpr, preferred-register: '' }
liveins: []
frameInfo:
isFrameAddressTaken: false
isReturnAddressTaken: false
hasStackMap: false
hasPatchPoint: false
stackSize: 0
offsetAdjustment: 0
maxAlignment: 1
adjustsStack: false
hasCalls: false
stackProtector: ''
functionContext: ''
maxCallFrameSize: 4294967295
cvBytesOfCalleeSavedRegisters: 0
hasOpaqueSPAdjustment: false
hasVAStart: false
hasMustTailInVarArgFunc: false
hasTailCall: false
localFrameSize: 0
savePoint: ''
restorePoint: ''
fixedStack: []
stack: []
callSites: []
debugValueSubstitutions: []
constants: []
machineFunctionInfo:
varArgsFrameIndex: 0
varArgsSaveSize: 0
body: |
bb.0.entry:
; CHECK: 0B bb.0.entry:
; CHECK-NEXT: 16B %0:gpr = LUI target-flags(riscv-hi) @__const._Z3foov.var_49
; CHECK-NEXT: 32B %1:gpr = ADDI %0:gpr, target-flags(riscv-lo) @__const._Z3foov.var_49
; CHECK-NEXT: 48B dead $x0 = PseudoVSETIVLI 2, 73, implicit-def $vl, implicit-def $vtype
; CHECK-NEXT: 64B undef %25.sub_vrm2_0:vrn4m2nov0 = PseudoVLE16_V_M2 %1:gpr, 2, 4, implicit $vl, implicit $vtype
; CHECK-NEXT: 80B %3:gpr = LUI target-flags(riscv-hi) @__const._Z3foov.var_48
; CHECK-NEXT: 96B %4:gpr = ADDI %3:gpr, target-flags(riscv-lo) @__const._Z3foov.var_48
; CHECK-NEXT: 112B %5:vr = PseudoVLE8_V_M1 %4:gpr, 2, 3, implicit $vl, implicit $vtype
; CHECK-NEXT: 128B %6:gpr = LUI target-flags(riscv-hi) @__const._Z3foov.var_46
; CHECK-NEXT: 144B %7:gpr = ADDI %6:gpr, target-flags(riscv-lo) @__const._Z3foov.var_46
; CHECK-NEXT: 160B %25.sub_vrm2_1:vrn4m2nov0 = PseudoVLE16_V_M2 %7:gpr, 2, 4, implicit $vl, implicit $vtype
; CHECK-NEXT: 176B %9:gpr = LUI target-flags(riscv-hi) @__const._Z3foov.var_45
; CHECK-NEXT: 192B %10:gpr = ADDI %9:gpr, target-flags(riscv-lo) @__const._Z3foov.var_45
; CHECK-NEXT: 208B %25.sub_vrm2_2:vrn4m2nov0 = PseudoVLE16_V_M2 %10:gpr, 2, 4, implicit $vl, implicit $vtype
; CHECK-NEXT: 224B INLINEASM &"" [sideeffect] [attdialect], $0:[clobber], implicit-def dead early-clobber $v0, $1:[clobber], implicit-def dead early-clobber $v1, $2:[clobber], implicit-def dead early-clobber $v2, $3:[clobber], implicit-def dead early-clobber $v3, $4:[clobber], implicit-def dead early-clobber $v4, $5:[clobber], implicit-def dead early-clobber $v5, $6:[clobber], implicit-def dead early-clobber $v6, $7:[clobber], implicit-def dead early-clobber $v7, $8:[clobber], implicit-def dead early-clobber $v8, $9:[clobber], implicit-def dead early-clobber $v9, $10:[clobber], implicit-def dead early-clobber $v10, $11:[clobber], implicit-def dead early-clobber $v11, $12:[clobber], implicit-def dead early-clobber $v12, $13:[clobber], implicit-def dead early-clobber $v13, $14:[clobber], implicit-def dead early-clobber $v14, $15:[clobber], implicit-def dead early-clobber $v15, $16:[clobber], implicit-def dead early-clobber $v16, $17:[clobber], implicit-def dead early-clobber $v17, $18:[clobber], implicit-def dead early-clobber $v18, $19:[clobber], implicit-def dead early-clobber $v19, $20:[clobber], implicit-def dead early-clobber $v20, $21:[clobber], implicit-def dead early-clobber $v21, $22:[clobber], implicit-def dead early-clobber $v22, $23:[clobber], implicit-def dead early-clobber $v23, $24:[clobber], implicit-def dead early-clobber $v24, $25:[clobber], implicit-def dead early-clobber $v25, $26:[clobber], implicit-def dead early-clobber $v26, $27:[clobber], implicit-def dead early-clobber $v27, $28:[clobber], implicit-def dead early-clobber $v28, $29:[clobber], implicit-def dead early-clobber $v29, $30:[clobber], implicit-def dead early-clobber $v30, $31:[clobber], implicit-def dead early-clobber $v31
; CHECK-NEXT: 240B %12:gpr = LUI target-flags(riscv-hi) @__const._Z3foov.var_44
; CHECK-NEXT: 256B %13:gpr = ADDI %12:gpr, target-flags(riscv-lo) @__const._Z3foov.var_44
; CHECK-NEXT: 272B dead $x0 = PseudoVSETIVLI 2, 73, implicit-def $vl, implicit-def $vtype
; CHECK-NEXT: 288B %25.sub_vrm2_3:vrn4m2nov0 = PseudoVLE16_V_M2 %13:gpr, 2, 4, implicit $vl, implicit $vtype
; CHECK-NEXT: 304B $x0 = PseudoVSETIVLI 2, 73, implicit-def $vl, implicit-def $vtype
; CHECK-NEXT: 320B %16:gpr = LUI target-flags(riscv-hi) @__const._Z3foov.var_40
; CHECK-NEXT: 336B %17:gpr = ADDI %16:gpr, target-flags(riscv-lo) @__const._Z3foov.var_40
; CHECK-NEXT: 352B %18:vrm2 = PseudoVLE16_V_M2 %17:gpr, 2, 4, implicit $vl, implicit $vtype
; CHECK-NEXT: 368B $x0 = PseudoVSETIVLI 2, 73, implicit-def $vl, implicit-def $vtype
; CHECK-NEXT: 384B %20:gpr = LUI 1048572
; CHECK-NEXT: 400B %21:gpr = ADDIW %20:gpr, 928
; CHECK-NEXT: 416B early-clobber %22:vr = PseudoVMSBC_VX_M2 %18:vrm2, %21:gpr, 2, 4, implicit $vl, implicit $vtype
; CHECK-NEXT: 432B $x0 = PseudoVSETIVLI 2, 9, implicit-def $vl, implicit-def $vtype
; CHECK-NEXT: 448B $v0 = COPY %22:vr
; CHECK-NEXT: 464B early-clobber %25.sub_vrm2_0:vrn4m2nov0 = PseudoVSEXT_VF2_M2_MASK %25.sub_vrm2_0:vrn4m2nov0(tied-def 0), %5:vr, killed $v0, 2, 4, 0, implicit $vl, implicit $vtype
; CHECK-NEXT: 480B %26:gpr = LUI target-flags(riscv-hi) @var_47
; CHECK-NEXT: 496B %27:gpr = ADDI %26:gpr, target-flags(riscv-lo) @var_47
; CHECK-NEXT: 512B PseudoVSSEG4E16_V_M2 %25:vrn4m2nov0, %27:gpr, 2, 4, implicit $vl, implicit $vtype
; CHECK-NEXT: 528B PseudoRET
%0:gpr = LUI target-flags(riscv-hi) @__const._Z3foov.var_49
%1:gpr = ADDI %0, target-flags(riscv-lo) @__const._Z3foov.var_49
dead $x0 = PseudoVSETIVLI 2, 73 /* e16, m2, ta, mu */, implicit-def $vl, implicit-def $vtype
undef %25.sub_vrm2_0:vrn4m2nov0 = PseudoVLE16_V_M2 %1, 2, 4 /* e16 */, implicit $vl, implicit $vtype
%3:gpr = LUI target-flags(riscv-hi) @__const._Z3foov.var_48
%4:gpr = ADDI %3, target-flags(riscv-lo) @__const._Z3foov.var_48
%5:vr = PseudoVLE8_V_M1 %4, 2, 3 /* e8 */, implicit $vl, implicit $vtype
%6:gpr = LUI target-flags(riscv-hi) @__const._Z3foov.var_46
%7:gpr = ADDI %6, target-flags(riscv-lo) @__const._Z3foov.var_46
%25.sub_vrm2_1:vrn4m2nov0 = PseudoVLE16_V_M2 %7, 2, 4 /* e16 */, implicit $vl, implicit $vtype
%9:gpr = LUI target-flags(riscv-hi) @__const._Z3foov.var_45
%10:gpr = ADDI %9, target-flags(riscv-lo) @__const._Z3foov.var_45
%25.sub_vrm2_2:vrn4m2nov0 = PseudoVLE16_V_M2 %10, 2, 4 /* e16 */, implicit $vl, implicit $vtype
INLINEASM &"", 1 /* sideeffect attdialect */, 12 /* clobber */, implicit-def dead early-clobber $v0, 12 /* clobber */, implicit-def dead early-clobber $v1, 12 /* clobber */, implicit-def dead early-clobber $v2, 12 /* clobber */, implicit-def dead early-clobber $v3, 12 /* clobber */, implicit-def dead early-clobber $v4, 12 /* clobber */, implicit-def dead early-clobber $v5, 12 /* clobber */, implicit-def dead early-clobber $v6, 12 /* clobber */, implicit-def dead early-clobber $v7, 12 /* clobber */, implicit-def dead early-clobber $v8, 12 /* clobber */, implicit-def dead early-clobber $v9, 12 /* clobber */, implicit-def dead early-clobber $v10, 12 /* clobber */, implicit-def dead early-clobber $v11, 12 /* clobber */, implicit-def dead early-clobber $v12, 12 /* clobber */, implicit-def dead early-clobber $v13, 12 /* clobber */, implicit-def dead early-clobber $v14, 12 /* clobber */, implicit-def dead early-clobber $v15, 12 /* clobber */, implicit-def dead early-clobber $v16, 12 /* clobber */, implicit-def dead early-clobber $v17, 12 /* clobber */, implicit-def dead early-clobber $v18, 12 /* clobber */, implicit-def dead early-clobber $v19, 12 /* clobber */, implicit-def dead early-clobber $v20, 12 /* clobber */, implicit-def dead early-clobber $v21, 12 /* clobber */, implicit-def dead early-clobber $v22, 12 /* clobber */, implicit-def dead early-clobber $v23, 12 /* clobber */, implicit-def dead early-clobber $v24, 12 /* clobber */, implicit-def dead early-clobber $v25, 12 /* clobber */, implicit-def dead early-clobber $v26, 12 /* clobber */, implicit-def dead early-clobber $v27, 12 /* clobber */, implicit-def dead early-clobber $v28, 12 /* clobber */, implicit-def dead early-clobber $v29, 12 /* clobber */, implicit-def dead early-clobber $v30, 12 /* clobber */, implicit-def dead early-clobber $v31
%12:gpr = LUI target-flags(riscv-hi) @__const._Z3foov.var_44
%13:gpr = ADDI %12, target-flags(riscv-lo) @__const._Z3foov.var_44
dead $x0 = PseudoVSETIVLI 2, 73 /* e16, m2, ta, mu */, implicit-def $vl, implicit-def $vtype
%25.sub_vrm2_3:vrn4m2nov0 = PseudoVLE16_V_M2 %13, 2, 4 /* e16 */, implicit $vl, implicit $vtype
$x0 = PseudoVSETIVLI 2, 73 /* e16, m2, ta, mu */, implicit-def $vl, implicit-def $vtype
%16:gpr = LUI target-flags(riscv-hi) @__const._Z3foov.var_40
%17:gpr = ADDI %16, target-flags(riscv-lo) @__const._Z3foov.var_40
%18:vrm2 = PseudoVLE16_V_M2 %17, 2, 4 /* e16 */, implicit $vl, implicit $vtype
$x0 = PseudoVSETIVLI 2, 73 /* e16, m2, ta, mu */, implicit-def $vl, implicit-def $vtype
%20:gpr = LUI 1048572
%21:gpr = ADDIW %20, 928
early-clobber %22:vr = PseudoVMSBC_VX_M2 %18, %21, 2, 4 /* e16 */, implicit $vl, implicit $vtype
$x0 = PseudoVSETIVLI 2, 9 /* e16, m2, tu, mu */, implicit-def $vl, implicit-def $vtype
$v0 = COPY %22
early-clobber %25.sub_vrm2_0:vrn4m2nov0 = PseudoVSEXT_VF2_M2_MASK %25.sub_vrm2_0, %5, killed $v0, 2, 4 /* e16 */, 0, implicit $vl, implicit $vtype
; CHECK: Best local split range: 64r-208r, 6.999861e-03, 3 instrs
; CHECK-NEXT: enterIntvBefore 64r: not live
; CHECK-NEXT: leaveIntvAfter 208r: valno 1
; CHECK-NEXT: useIntv [64B;216r): [64B;216r):1
; CHECK-NEXT: blit [64r,160r:4): [64r;160r)=1(%29)(recalc)
; CHECK-NEXT: blit [160r,208r:0): [160r;208r)=1(%29)(recalc)
; CHECK-NEXT: blit [208r,288r:1): [208r;216r)=1(%29)(recalc) [216r;288r)=0(%28)(recalc)
; CHECK-NEXT: blit [288r,464e:2): [288r;464e)=0(%28)(recalc)
; CHECK-NEXT: blit [464e,512r:3): [464e;512r)=0(%28)(recalc)
; CHECK-NEXT: rewr %bb.0 464e:0 early-clobber %28.sub_vrm2_0:vrn4m2nov0 = PseudoVSEXT_VF2_M2_MASK %25.sub_vrm2_0:vrn4m2nov0(tied-def 0), %5:vr, $v0, 2, 4, 0, implicit $vl, implicit $vtype
; CHECK-NEXT: rewr %bb.0 288r:0 %28.sub_vrm2_3:vrn4m2nov0 = PseudoVLE16_V_M2 %13:gpr, 2, 4, implicit $vl, implicit $vtype
; CHECK-NEXT: rewr %bb.0 208r:1 %29.sub_vrm2_2:vrn4m2nov0 = PseudoVLE16_V_M2 %10:gpr, 2, 4, implicit $vl, implicit $vtype
; CHECK-NEXT: rewr %bb.0 160r:1 %29.sub_vrm2_1:vrn4m2nov0 = PseudoVLE16_V_M2 %7:gpr, 2, 4, implicit $vl, implicit $vtype
; CHECK-NEXT: rewr %bb.0 64r:1 undef %29.sub_vrm2_0:vrn4m2nov0 = PseudoVLE16_V_M2 %1:gpr, 2, 4, implicit $vl, implicit $vtype
; CHECK-NEXT: rewr %bb.0 464B:0 early-clobber %28.sub_vrm2_0:vrn4m2nov0 = PseudoVSEXT_VF2_M2_MASK %28.sub_vrm2_0:vrn4m2nov0(tied-def 0), %5:vr, $v0, 2, 4, 0, implicit $vl, implicit $vtype
; CHECK-NEXT: rewr %bb.0 512B:0 PseudoVSSEG4E16_V_M2 %28:vrn4m2nov0, %27:gpr, 2, 4, implicit $vl, implicit $vtype
; CHECK-NEXT: rewr %bb.0 216B:1 undef %28.sub_vrm1_0_sub_vrm1_1_sub_vrm1_2_sub_vrm1_3_sub_vrm1_4_sub_vrm1_5:vrn4m2nov0 = COPY %29.sub_vrm1_0_sub_vrm1_1_sub_vrm1_2_sub_vrm1_3_sub_vrm1_4_sub_vrm1_5:vrn4m2nov0
; CHECK-NEXT: queuing new interval: %28 [216r,288r:0)[288r,464e:1)[464e,512r:2) 0@216r 1@288r 2@464e L000000000000000C [216r,216d:0)[464e,512r:1) 0@216r 1@464e L0000000000000300 [288r,512r:0) 0@288r L00000000000000C0 [216r,512r:0) 0@216r L0000000000000030 [216r,512r:0) 0@216r weight:8.706897e-03
%26:gpr = LUI target-flags(riscv-hi) @var_47
%27:gpr = ADDI %26, target-flags(riscv-lo) @var_47
PseudoVSSEG4E16_V_M2 %25, %27, 2, 4 /* e16 */, implicit $vl, implicit $vtype
PseudoRET
...

llvm/test/ExecutionEngine/JITLink/AArch64/ELF_aarch64_relocations.s

  • This file was added.
# RUN: rm -rf %t && mkdir -p %t
# RUN: llvm-mc -triple=aarch64-unknown-linux-gnu -relax-relocations=false \
# RUN: -position-independent -filetype=obj -o %t/elf_reloc.o %s
# RUN: llvm-jitlink -noexec \
# RUN: -abs external_data=0xdeadbeef \
# RUN: -check %s %t/elf_reloc.o
.text
.globl main
.p2align 2
.type main,@function
main:
ret
.size main, .-main
# Check R_AARCH64_CALL26 relocation of a local function call
#
# jitlink-check: decode_operand(local_func_call26, 0)[25:0] = (local_func - local_func_call26)[27:2]
.globl local_func
.p2align 2
.type local_func,@function
local_func:
ret
.size local_func, .-local_func
.globl local_func_call26
.p2align 2
local_func_call26:
bl local_func
.size local_func_call26, .-local_func_call26
# Check R_AARCH64_ADR_PREL_PG_HI21 / R_AARCH64_ADD_ABS_LO12_NC relocation of a local symbol
#
# For the ADR_PREL_PG_HI21/ADRP instruction we have the 21-bit delta to the 4k page
# containing the global.
#
# jitlink-check: decode_operand(test_adr_prel, 1) = (named_data - test_adr_prel)[32:12]
# jitlink-check: decode_operand(test_add_abs_lo12, 2) = (named_data + 0)[11:0]
.globl test_adr_prel
.p2align 2
test_adr_prel:
adrp x0, named_data
.size test_adr_prel, .-test_adr_prel
.globl test_add_abs_lo12
.p2align 2
test_add_abs_lo12:
add x0, x0, :lo12:named_data
.size test_add_abs_lo12, .-test_add_abs_lo12
# Check R_AARCH64_LDST*_ABS_LO12_NC relocation of a local symbol
#
# The immediate value should be the symbol address right shifted according to its instruction bitwidth.
#
# jitlink-check: decode_operand(test_ldrb, 2) = named_data[11:0]
# jitlink-check: decode_operand(test_ldrsb, 2) = (named_data + 0)[11:0]
# jitlink-check: decode_operand(test_ldrh, 2) = (named_data + 0)[11:1]
# jitlink-check: decode_operand(test_ldrsh, 2) = (named_data + 0)[11:1]
# jitlink-check: decode_operand(test_ldr_32bit, 2) = (named_data + 0)[11:2]
# jitlink-check: decode_operand(test_ldr_64bit, 2) = (named_data + 0)[11:3]
# jitlink-check: decode_operand(test_strb, 2) = named_data[11:0]
# jitlink-check: decode_operand(test_strh, 2) = (named_data + 0)[11:1]
# jitlink-check: decode_operand(test_str_32bit, 2) = (named_data + 0)[11:2]
# jitlink-check: decode_operand(test_str_64bit, 2) = (named_data + 0)[11:3]
.globl test_ldrb
test_ldrb:
ldrb w0, [x1, :lo12:named_data]
.size test_ldrb, .-test_ldrb
.globl test_ldrsb
test_ldrsb:
ldrsb w0, [x1, :lo12:named_data]
.size test_ldrsb, .-test_ldrsb
.globl test_ldrh
test_ldrh:
ldrh w0, [x1, :lo12:named_data]
.size test_ldrh, .-test_ldrh
.globl test_ldrsh
test_ldrsh:
ldrsh w0, [x1, :lo12:named_data]
.size test_ldrsh, .-test_ldrsh
.globl test_ldr_32bit
test_ldr_32bit:
ldr w0, [x1, :lo12:named_data]
.size test_ldr_32bit, .-test_ldr_32bit
.globl test_ldr_64bit
test_ldr_64bit:
ldr x0, [x1, :lo12:named_data]
.size test_ldr_64bit, .-test_ldr_64bit
.globl test_strb
test_strb:
strb w0, [x1, :lo12:named_data]
.size test_strb, .-test_strb
.globl test_strh
test_strh:
strh w0, [x1, :lo12:named_data]
.size test_strh, .-test_strh
.globl test_str_32bit
test_str_32bit:
str w0, [x1, :lo12:named_data]
.size test_str_32bit, .-test_str_32bit
.globl test_str_64bit
test_str_64bit:
str x0, [x1, :lo12:named_data]
.size test_str_64bit, .-test_str_64bit
# Check R_AARCH64_ABS64 relocation of a function pointer to local symbol
#
# jitlink-check: *{8}local_func_addr_quad = named_func
.globl local_func_addr_quad
.p2align 3
local_func_addr_quad:
.xword named_func
.size local_func_addr_quad, 8
# Check R_AARCH64_ADR_GOT_PAGE / R_AARCH64_LD64_GOT_LO12_NC handling with a
# reference to an external symbol. Validate both the reference to the GOT entry,
# and also the content of the GOT entry.
#
# For the ADRP :got: instruction we have the 21-bit delta to the 4k page
# containing the GOT entry for external_data.
#
# For the LDR :got_lo12: instruction we have the 12-bit offset of the entry
# within the page.
#
# jitlink-check: *{8}(got_addr(elf_reloc.o, external_data)) = external_data
# jitlink-check: decode_operand(test_adr_gotpage_external, 1) = \
# jitlink-check: (got_addr(elf_reloc.o, external_data)[32:12] - \
# jitlink-check: test_adr_gotpage_external[32:12])
# jitlink-check: decode_operand(test_ld64_gotlo12_external, 2) = \
# jitlink-check: got_addr(elf_reloc.o, external_data)[11:3]
.globl test_adr_gotpage_external
.p2align 2
test_adr_gotpage_external:
adrp x0, :got:external_data
.size test_adr_gotpage_external, .-test_adr_gotpage_external
.globl test_ld64_gotlo12_external
.p2align 2
test_ld64_gotlo12_external:
ldr x0, [x0, :got_lo12:external_data]
.size test_ld64_gotlo12_external, .-test_ld64_gotlo12_external
.globl named_data
.p2align 4
.type named_data,@object
named_data:
.quad 0x2222222222222222
.quad 0x3333333333333333
.size named_data, .-named_data
.globl named_func
.p2align 2
.type named_func,@function
named_func:
ret
.size named_func, .-named_func

llvm/test/Transforms/Coroutines/coro-debug-coro-frame.ll

; RUN: opt < %s -passes='module(coro-early),cgscc(coro-split,coro-split)' -S | FileCheck %s ; RUN: opt < %s -passes='module(coro-early),cgscc(coro-split,coro-split)' -S | FileCheck %s
; Checks whether the dbg.declare for `__coro_frame` are created. ; Checks whether the dbg.declare for `__coro_frame` are created.
; CHECK-LABEL: define void @f( ; CHECK-LABEL: define void @f(
; CHECK: coro.init: ; CHECK: coro.init:
; CHECK: %[[begin:.*]] = call noalias nonnull i8* @llvm.coro.begin( ; CHECK: %[[begin:.*]] = call noalias nonnull i8* @llvm.coro.begin(
; CHECK: call void @llvm.dbg.declare(metadata i8* %[[begin]], metadata ![[CORO_FRAME:[0-9]+]], metadata !DIExpression()) ; CHECK: call void @llvm.dbg.declare(metadata i8* %[[begin]], metadata ![[CORO_FRAME:[0-9]+]], metadata !DIExpression())
; CHECK: %[[FramePtr:.*]] = bitcast i8* %[[begin]] to ; CHECK: %[[FramePtr:.*]] = bitcast i8* %[[begin]] to
; ;
; CHECK: define internal fastcc void @f.resume( ; CHECK: define internal fastcc void @f.resume(
; CHECK: entry.resume: ; CHECK: entry.resume:
; CHECK: call void @llvm.dbg.declare(metadata %f.Frame** %[[FramePtr_RESUME:.*]], metadata ![[CORO_FRAME_IN_RESUME:[0-9]+]], metadata !DIExpression() ; CHECK: %[[FramePtr_RESUME:.*]] = alloca %f.Frame*
; CHECK: call void @llvm.dbg.declare(metadata %f.Frame** %[[FramePtr_RESUME]], metadata ![[CORO_FRAME_IN_RESUME:[0-9]+]], metadata !DIExpression(DW_OP_deref)
; ;
; CHECK-DAG: ![[FILE:[0-9]+]] = !DIFile(filename: "coro-debug.cpp" ; CHECK-DAG: ![[FILE:[0-9]+]] = !DIFile(filename: "coro-debug.cpp"
; CHECK-DAG: ![[RAMP:[0-9]+]] = distinct !DISubprogram(name: "foo", linkageName: "_Z3foov", ; CHECK-DAG: ![[RAMP:[0-9]+]] = distinct !DISubprogram(name: "foo", linkageName: "_Z3foov",
; CHECK-DAG: ![[RAMP_SCOPE:[0-9]+]] = distinct !DILexicalBlock(scope: ![[RAMP]], file: ![[FILE]], line: 23 ; CHECK-DAG: ![[RAMP_SCOPE:[0-9]+]] = distinct !DILexicalBlock(scope: ![[RAMP]], file: ![[FILE]], line: 23
; CHECK-DAG: ![[CORO_FRAME]] = !DILocalVariable(name: "__coro_frame", scope: ![[RAMP_SCOPE]], file: ![[FILE]], line: [[PROMISE_VAR_LINE:[0-9]+]], type: ![[FRAME_TYPE:[0-9]+]], flags: DIFlagArtificial) ; CHECK-DAG: ![[CORO_FRAME]] = !DILocalVariable(name: "__coro_frame", scope: ![[RAMP_SCOPE]], file: ![[FILE]], line: [[PROMISE_VAR_LINE:[0-9]+]], type: ![[FRAME_TYPE:[0-9]+]], flags: DIFlagArtificial)
; CHECK-DAG: ![[FRAME_TYPE]] = !DICompositeType(tag: DW_TAG_structure_type, name: "__coro_frame_ty", scope: ![[RAMP]], {{.*}}elements: ![[ELEMENTS:[0-9]+]] ; CHECK-DAG: ![[FRAME_TYPE]] = !DICompositeType(tag: DW_TAG_structure_type, name: "__coro_frame_ty", scope: ![[RAMP]], {{.*}}elements: ![[ELEMENTS:[0-9]+]]
; CHECK-DAG: ![[ELEMENTS]] = !{![[RESUME_FN:[0-9]+]], ![[DESTROY_FN:[0-9]+]], ![[PROMISE:[0-9]+]], ![[INT64_0:[0-9]+]], ![[DOUBLE_1:[0-9]+]], ![[INT32_2:[0-9]+]], ![[INT32_3:[0-9]+]], ![[STRUCT_4:[0-9]+]], ![[CORO_INDEX:[0-9]+]] ; CHECK-DAG: ![[ELEMENTS]] = !{![[RESUME_FN:[0-9]+]], ![[DESTROY_FN:[0-9]+]], ![[PROMISE:[0-9]+]], ![[INT64_0:[0-9]+]], ![[DOUBLE_1:[0-9]+]], ![[INT32_2:[0-9]+]], ![[INT32_3:[0-9]+]], ![[STRUCT_4:[0-9]+]], ![[CORO_INDEX:[0-9]+]]
; CHECK-DAG: ![[RESUME_FN]] = !DIDerivedType(tag: DW_TAG_member, name: "__resume_fn"{{.*}}, flags: DIFlagArtificial ; CHECK-DAG: ![[RESUME_FN]] = !DIDerivedType(tag: DW_TAG_member, name: "__resume_fn"{{.*}}, flags: DIFlagArtificial
▲ Show 20 Lines • Show All 340 Lines • Show Last 20 Lines

llvm/test/Transforms/IndVarSimplify/pr55689.ll

  • This file was added.
; RUN: opt -S -passes='loop(indvars)' -verify-scev < %s | FileCheck %s
; REQUIRES: asserts
; XFAIL: *
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128-ni:1-p2:32:8:8:32-ni:2"
target triple = "x86_64-unknown-linux-gnu"
define void @test_01(i1 %b) {
; CHECK-LABEL: test_01
entry:
%b.ext = zext i1 %b to i32
%zero = and i32 %b.ext, 2
%precond = icmp ne i32 %zero, 0
call void @llvm.assume(i1 %precond)
br label %loop
loop:
%iv = phi i16 [ 0, %entry ], [ %iv.next, %loop ]
%iv.next = add i16 %iv, 1
%cond = icmp slt i16 %iv, 1
br i1 %cond, label %loop, label %exit
exit:
ret void
}
define void @test_02() {
; CHECK-LABEL: test_02
entry:
%tmp = and i1 false, undef
br i1 %tmp, label %preheader, label %unreached
preheader: ; preds = %entry
br label %loop
loop: ; preds = %loop, %preheader
%tmp3 = phi i32 [ 2, %preheader ], [ %tmp4, %loop ]
%tmp4 = add nuw nsw i32 %tmp3, 1
%tmp5 = icmp ugt i32 %tmp3, 74
br i1 %tmp5, label %unreached, label %loop
unreached: ; preds = %loop
unreachable
}
declare void @llvm.assume(i1)

llvm/test/Transforms/InstCombine/2011-06-13-nsw-alloca.ll

Show All 9 Lines; CHECK: alloca double*
store i32 %parm, i32* %1, align 4 store i32 %parm, i32* %1, align 4
store double* null, double** %ptr, align 4 store double* null, double** %ptr, align 4
%2 = load i32, i32* %1, align 4 %2 = load i32, i32* %1, align 4
%3 = icmp ne i32 %2, 0 %3 = icmp ne i32 %2, 0
br i1 %3, label %4, label %10 br i1 %3, label %4, label %10
; <label>:4 ; preds = %0 ; <label>:4 ; preds = %0
%5 = load i32, i32* %1, align 4 %5 = load i32, i32* %1, align 4
%6 = shl nsw i32 %5, 3 %6 = shl nuw i32 %5, 3
; With "nsw", the alloca and its bitcast can be fused: ; With "nuw", the alloca and its bitcast can be fused:
%7 = add nsw i32 %6, 2048 %7 = add nuw i32 %6, 2048
; CHECK: alloca double ; CHECK: alloca double
%8 = alloca i8, i32 %7 %8 = alloca i8, i32 %7
%9 = bitcast i8* %8 to double* %9 = bitcast i8* %8 to double*
; CHECK-NEXT: store double* ; CHECK-NEXT: store double*
store double* %9, double** %ptr, align 4 store double* %9, double** %ptr, align 4
br label %10 br label %10
; <label>:10 ; preds = %4, %0 ; <label>:10 ; preds = %4, %0
%11 = load double*, double** %ptr, align 4 %11 = load double*, double** %ptr, align 4
Show All 11 Linesdefine void @fu2(i32 %parm) nounwind ssp {
store i32 %parm, i32* %1, align 4 store i32 %parm, i32* %1, align 4
store double* null, double** %ptr, align 4 store double* null, double** %ptr, align 4
%2 = load i32, i32* %1, align 4 %2 = load i32, i32* %1, align 4
%3 = icmp ne i32 %2, 0 %3 = icmp ne i32 %2, 0
br i1 %3, label %4, label %10 br i1 %3, label %4, label %10
; <label>:4 ; preds = %0 ; <label>:4 ; preds = %0
%5 = load i32, i32* %1, align 4 %5 = load i32, i32* %1, align 4
%6 = mul nsw i32 %5, 8 %6 = mul nuw i32 %5, 8
; Without "nsw", the alloca and its bitcast cannot be fused: ; Without "nuw", the alloca and its bitcast cannot be fused:
%7 = add i32 %6, 2048 %7 = add i32 %6, 2048
; CHECK: alloca i8 ; CHECK: alloca i8
%8 = alloca i8, i32 %7 %8 = alloca i8, i32 %7
; CHECK-NEXT: bitcast double** ; CHECK-NEXT: bitcast double**
; CHECK-NEXT: store i8* ; CHECK-NEXT: store i8*
%9 = bitcast i8* %8 to double* %9 = bitcast i8* %8 to double*
store double* %9, double** %ptr, align 4 store double* %9, double** %ptr, align 4
br label %10 br label %10
; <label>:10 ; preds = %4, %0 ; <label>:10 ; preds = %4, %0
%11 = load double*, double** %ptr, align 4 %11 = load double*, double** %ptr, align 4
call void @bar(double* %11) call void @bar(double* %11)
ret void ret void
} }

llvm/test/Transforms/InstCombine/neg-alloca.ll

  • This file was added.
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -passes=instcombine -S | FileCheck %s
declare void @use(i32 *)
define void @foo(i64 %X) {
; Currently we cannot handle expressions of the form Offset - X * Scale.
; CHECK-LABEL: @foo(
; CHECK-NEXT: [[TMP1:%.*]] = mul nsw i64 [[X:%.*]], -4
; CHECK-NEXT: [[TMP2:%.*]] = add nsw i64 [[TMP1]], 24
; CHECK-NEXT: [[TMP3:%.*]] = alloca i8, i64 [[TMP2]], align 4
; CHECK-NEXT: [[TMP4:%.*]] = bitcast i8* [[TMP3]] to i32*
; CHECK-NEXT: call void @use(i32* nonnull [[TMP4]])
; CHECK-NEXT: ret void
;
%1 = mul nsw i64 %X, -4
%2 = add nsw i64 %1, 24
%3 = alloca i8, i64 %2, align 4
%4 = bitcast i8* %3 to i32*
call void @use(i32 *%4)
ret void
}

llvm/test/tools/llvm-objcopy/wasm/only-keep-debug.test

Show All 9 Lines
## Test that keep-section overrides only-keep-debug, even for known sections. ## Test that keep-section overrides only-keep-debug, even for known sections.
# RUN: yaml2obj %s -o %t # RUN: yaml2obj %s -o %t
# RUN: llvm-strip --only-keep-debug --keep-section=TYPE %t # RUN: llvm-strip --only-keep-debug --keep-section=TYPE %t
# RUN: obj2yaml %t | FileCheck --implicit-check-not=Name --check-prefix=CHECK --check-prefix=KEEPTYPE %s # RUN: obj2yaml %t | FileCheck --implicit-check-not=Name --check-prefix=CHECK --check-prefix=KEEPTYPE %s
# CHECK: Sections: # CHECK: Sections:
# KEEPTYPE: - Type: TYPE # KEEPTYPE: - Type: TYPE
# CHECK-NOT: - Type: TYPE
# CHECK: - Type: CUSTOM # CHECK: - Type: CUSTOM
# CHECK-NEXT: Name: .debug_info # CHECK-NEXT: Name: .debug_info
# CHECK: - Type: CUSTOM # CHECK: - Type: CUSTOM
# CHECK-NEXT: Name: .debug_line # CHECK-NEXT: Name: .debug_line
# KEEP: Name: foo # KEEP: Name: foo
## Test that remove-section overrides only-keep-debug. ## Test that remove-section overrides only-keep-debug.
# RUN: yaml2obj %s -o %t # RUN: yaml2obj %s -o %t
Show All 33 Lines

llvm/unittests/ADT/CMakeLists.txt

Show All 16 Linesadd_llvm_unittest(ADTTests
CoalescingBitVectorTest.cpp CoalescingBitVectorTest.cpp
CombinationGeneratorTest.cpp CombinationGeneratorTest.cpp
DAGDeltaAlgorithmTest.cpp DAGDeltaAlgorithmTest.cpp
DeltaAlgorithmTest.cpp DeltaAlgorithmTest.cpp
DenseMapTest.cpp DenseMapTest.cpp
DenseSetTest.cpp DenseSetTest.cpp
DepthFirstIteratorTest.cpp DepthFirstIteratorTest.cpp
DirectedGraphTest.cpp DirectedGraphTest.cpp
EditDistanceTest.cpp
EnumeratedArrayTest.cpp EnumeratedArrayTest.cpp
EquivalenceClassesTest.cpp EquivalenceClassesTest.cpp
FallibleIteratorTest.cpp FallibleIteratorTest.cpp
FloatingPointMode.cpp FloatingPointMode.cpp
FoldingSet.cpp FoldingSet.cpp
FunctionExtrasTest.cpp FunctionExtrasTest.cpp
FunctionRefTest.cpp FunctionRefTest.cpp
HashingTest.cpp HashingTest.cpp
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

llvm/unittests/ADT/EditDistanceTest.cpp

  • This file was added.
//===- llvm/unittest/Support/EditDistanceTest.cpp - Edit distance tests ---===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/edit_distance.h"
#include "gtest/gtest.h"
#include <cstdlib>
using namespace llvm;
namespace {
struct Result {
unsigned NumMaps;
unsigned EditDist;
};
} // namespace
static Result editDistanceAndMaps(StringRef A, StringRef B,
unsigned MaxEditDistance = 0) {
unsigned NumMaps = 0;
auto TrackMaps = [&](const char X) {
++NumMaps;
return X;
};
unsigned EditDist = llvm::ComputeMappedEditDistance(
makeArrayRef(A.data(), A.size()), makeArrayRef(B.data(), B.size()),
TrackMaps, true, MaxEditDistance);
return {NumMaps, EditDist};
}
TEST(EditDistance, VerifyShortCircuit) {
StringRef Hello = "Hello";
StringRef HelloWorld = "HelloWorld";
Result R = editDistanceAndMaps(Hello, HelloWorld, 5);
EXPECT_EQ(R.EditDist, 5U);
EXPECT_GT(R.NumMaps, 0U);
R = editDistanceAndMaps(Hello, HelloWorld);
EXPECT_EQ(R.EditDist, 5U);
EXPECT_GT(R.NumMaps, 0U);
R = editDistanceAndMaps(Hello, HelloWorld, 4);
EXPECT_EQ(R.EditDist, 5U);
EXPECT_EQ(R.NumMaps, 0U);
R = editDistanceAndMaps(HelloWorld, Hello, 4);
EXPECT_EQ(R.EditDist, 5U);
EXPECT_EQ(R.NumMaps, 0U);
R = editDistanceAndMaps(Hello, HelloWorld, 1);
EXPECT_EQ(R.EditDist, 2U);
EXPECT_EQ(R.NumMaps, 0U);
R = editDistanceAndMaps(HelloWorld, Hello, 1);
EXPECT_EQ(R.EditDist, 2U);
EXPECT_EQ(R.NumMaps, 0U);
}

llvm/utils/gn/secondary/llvm/unittests/ADT/BUILD.gn

Show All 23 Lines sources = [
"CoalescingBitVectorTest.cpp", "CoalescingBitVectorTest.cpp",
"CombinationGeneratorTest.cpp", "CombinationGeneratorTest.cpp",
"DAGDeltaAlgorithmTest.cpp", "DAGDeltaAlgorithmTest.cpp",
"DeltaAlgorithmTest.cpp", "DeltaAlgorithmTest.cpp",
"DenseMapTest.cpp", "DenseMapTest.cpp",
"DenseSetTest.cpp", "DenseSetTest.cpp",
"DepthFirstIteratorTest.cpp", "DepthFirstIteratorTest.cpp",
"DirectedGraphTest.cpp", "DirectedGraphTest.cpp",
"EditDistanceTest.cpp",
"EnumeratedArrayTest.cpp", "EnumeratedArrayTest.cpp",
"EquivalenceClassesTest.cpp", "EquivalenceClassesTest.cpp",
"FallibleIteratorTest.cpp", "FallibleIteratorTest.cpp",
"FloatingPointMode.cpp", "FloatingPointMode.cpp",
"FoldingSet.cpp", "FoldingSet.cpp",
"FunctionExtrasTest.cpp", "FunctionExtrasTest.cpp",
"FunctionRefTest.cpp", "FunctionRefTest.cpp",
"HashingTest.cpp", "HashingTest.cpp",
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

mlir/CMakeLists.txt

Show First 20 Lines • Show All 211 Lines • ▼ Show 20 Linesif (NOT LLVM_INSTALL_TOOLCHAIN_ONLY)
if (NOT LLVM_ENABLE_IDE) if (NOT LLVM_ENABLE_IDE)
add_llvm_install_targets(install-mlir-headers add_llvm_install_targets(install-mlir-headers
DEPENDS mlir-headers DEPENDS mlir-headers
COMPONENT mlir-headers) COMPONENT mlir-headers)
endif() endif()
endif() endif()
# Custom target to install all mlir libraries
add_custom_target(mlir-libraries)
set_target_properties(mlir-libraries PROPERTIES FOLDER "Misc")
if (NOT LLVM_ENABLE_IDE)
add_llvm_install_targets(install-mlir-libraries
DEPENDS mlir-libraries
COMPONENT mlir-libraries)
endif()
get_property(MLIR_LIBS GLOBAL PROPERTY MLIR_ALL_LIBS)
if(MLIR_LIBS)
list(REMOVE_DUPLICATES MLIR_LIBS)
foreach(lib ${MLIR_LIBS})
add_dependencies(mlir-libraries ${lib})
if(NOT LLVM_ENABLE_IDE)
add_dependencies(install-mlir-libraries install-${lib})
add_dependencies(install-mlir-libraries-stripped install-${lib}-stripped)
endif()
endforeach()
endif()
add_subdirectory(cmake/modules) add_subdirectory(cmake/modules)
if (MLIR_ENABLE_PYTHON_BENCHMARKS) if (MLIR_ENABLE_PYTHON_BENCHMARKS)
add_subdirectory(utils/mbr) add_subdirectory(utils/mbr)
endif() endif()

mlir/include/mlir/Dialect/Bufferization/Transforms/OneShotAnalysis.h

Show First 20 Lines • Show All 161 Lines • ▼ Show 20 Linespublic:
/// Find all tensors that are yielded/returned from a block and store them in /// Find all tensors that are yielded/returned from a block and store them in
/// `yieldedTensors`. Also include all aliasing tensors in the same block. /// `yieldedTensors`. Also include all aliasing tensors in the same block.
void gatherYieldedTensors(Operation *op); void gatherYieldedTensors(Operation *op);
/// Return true if the buffer of the given tensor value is written to. Must /// Return true if the buffer of the given tensor value is written to. Must
/// not be called for values inside not yet analyzed functions. /// not be called for values inside not yet analyzed functions.
bool isValueWritten(Value value) const; bool isValueWritten(Value value) const;
/// Return true if the buffer of the given tensor value is writable.
bool isWritable(Value value) const;
private: private:
/// `aliasInfo` keeps track of aliasing and equivalent values. Only internal /// `aliasInfo` keeps track of aliasing and equivalent values. Only internal
/// functions and `runOneShotBufferize` may access this object. /// functions and `runOneShotBufferize` may access this object.
BufferizationAliasInfo aliasInfo; BufferizationAliasInfo aliasInfo;
/// A set of all tensors (and maybe aliasing tensors) that yielded from a /// A set of all tensors (and maybe aliasing tensors) that yielded from a
/// block. /// block.
DenseSet<Value> yieldedTensors; DenseSet<Value> yieldedTensors;
Show All 17 Lines

mlir/include/mlir/Dialect/SCF/SCFOps.td

Show First 20 Lines • Show All 105 Lines • ▼ Show 20 Linesdef ExecuteRegionOp : SCF_Op<"execute_region", [
let regions = (region AnyRegion:$region); let regions = (region AnyRegion:$region);
let hasCanonicalizer = 1; let hasCanonicalizer = 1;
let hasCustomAssemblyFormat = 1; let hasCustomAssemblyFormat = 1;
let hasVerifier = 1; let hasVerifier = 1;
} }
//===----------------------------------------------------------------------===//
// ForOp
//===----------------------------------------------------------------------===//
def ForOp : SCF_Op<"for", def ForOp : SCF_Op<"for",
[AutomaticAllocationScope, DeclareOpInterfaceMethods<LoopLikeOpInterface, [AutomaticAllocationScope, DeclareOpInterfaceMethods<LoopLikeOpInterface,
["getSingleInductionVar", "getSingleLowerBound", "getSingleStep", ["getSingleInductionVar", "getSingleLowerBound", "getSingleStep",
"getSingleUpperBound"]>, "getSingleUpperBound"]>,
DeclareOpInterfaceMethods<RegionBranchOpInterface>, DeclareOpInterfaceMethods<RegionBranchOpInterface>,
SingleBlockImplicitTerminator<"scf::YieldOp">, SingleBlockImplicitTerminator<"scf::YieldOp">,
RecursiveSideEffects]> { RecursiveSideEffects]> {
let summary = "for operation"; let summary = "for operation";
▲ Show 20 Lines • Show All 300 Lines • ▼ Show 20 Lines let extraClassDeclaration = [{
// unaware of the fact that our terminator also needs a region to be // unaware of the fact that our terminator also needs a region to be
// well-formed. We override it here to ensure that we do the right thing. // well-formed. We override it here to ensure that we do the right thing.
static void ensureTerminator(Region &region, OpBuilder &builder, Location loc); static void ensureTerminator(Region &region, OpBuilder &builder, Location loc);
PerformConcurrentlyOp getTerminator(); PerformConcurrentlyOp getTerminator();
}]; }];
} }
//===----------------------------------------------------------------------===//
// PerformConcurrentlyOp
//===----------------------------------------------------------------------===//
def PerformConcurrentlyOp : SCF_Op<"foreach_thread.perform_concurrently", [ def PerformConcurrentlyOp : SCF_Op<"foreach_thread.perform_concurrently", [
NoSideEffect, NoSideEffect,
Terminator, Terminator,
HasParent<"ForeachThreadOp">, HasParent<"ForeachThreadOp">,
] # GraphRegionNoTerminator.traits> { ] # GraphRegionNoTerminator.traits> {
let summary = "terminates a `foreach_thread` block"; let summary = "terminates a `foreach_thread` block";
let description = [{ let description = [{
`scf.foreach_thread.perform_concurrently` is a designated terminator for `scf.foreach_thread.perform_concurrently` is a designated terminator for
Show All 19 Linesdef PerformConcurrentlyOp : SCF_Op<"foreach_thread.perform_concurrently", [
// TODO: Add a `PerformConcurrentlyOpInterface` interface for ops that can // TODO: Add a `PerformConcurrentlyOpInterface` interface for ops that can
// appear inside perform_concurrently. // appear inside perform_concurrently.
let extraClassDeclaration = [{ let extraClassDeclaration = [{
SmallVector<Type> yieldedTypes(); SmallVector<Type> yieldedTypes();
::llvm::iterator_range<Block::iterator> yieldingOps(); ::llvm::iterator_range<Block::iterator> yieldingOps();
}]; }];
} }
//===----------------------------------------------------------------------===//
// ParallelInsertSliceOp
//===----------------------------------------------------------------------===//
// TODO: Implement PerformConcurrentlyOpInterface. // TODO: Implement PerformConcurrentlyOpInterface.
def ParallelInsertSliceOp : SCF_Op<"foreach_thread.parallel_insert_slice", [ def ParallelInsertSliceOp : SCF_Op<"foreach_thread.parallel_insert_slice", [
AttrSizedOperandSegments, AttrSizedOperandSegments,
OffsetSizeAndStrideOpInterface, OffsetSizeAndStrideOpInterface,
HasParent<"PerformConcurrentlyOp">]> { HasParent<"PerformConcurrentlyOp">]> {
let summary = [{ let summary = [{
Specify the tensor slice update of a single thread within the terminator of Specify the tensor slice update of a single thread within the terminator of
an `scf.foreach_thread`. an `scf.foreach_thread`.
▲ Show 20 Lines • Show All 174 Lines • ▼ Show 20 Lines let extraClassDeclaration = [{
YieldOp elseYield(); YieldOp elseYield();
}]; }];
let hasFolder = 1; let hasFolder = 1;
let hasCanonicalizer = 1; let hasCanonicalizer = 1;
let hasCustomAssemblyFormat = 1; let hasCustomAssemblyFormat = 1;
let hasVerifier = 1; let hasVerifier = 1;
} }
//===----------------------------------------------------------------------===//
// ParallelOp
//===----------------------------------------------------------------------===//
def ParallelOp : SCF_Op<"parallel", def ParallelOp : SCF_Op<"parallel",
[AutomaticAllocationScope, [AutomaticAllocationScope,
AttrSizedOperandSegments, AttrSizedOperandSegments,
DeclareOpInterfaceMethods<LoopLikeOpInterface>, DeclareOpInterfaceMethods<LoopLikeOpInterface>,
RecursiveSideEffects, RecursiveSideEffects,
SingleBlockImplicitTerminator<"scf::YieldOp">]> { SingleBlockImplicitTerminator<"scf::YieldOp">]> {
let summary = "parallel for operation"; let summary = "parallel for operation";
let description = [{ let description = [{
▲ Show 20 Lines • Show All 68 Lines • ▼ Show 20 Lines let extraClassDeclaration = [{
unsigned getNumReductions() { return getInitVals().size(); } unsigned getNumReductions() { return getInitVals().size(); }
}]; }];
let hasCanonicalizer = 1; let hasCanonicalizer = 1;
let hasCustomAssemblyFormat = 1; let hasCustomAssemblyFormat = 1;
let hasVerifier = 1; let hasVerifier = 1;
} }
//===----------------------------------------------------------------------===//
// ReduceOp
//===----------------------------------------------------------------------===//
def ReduceOp : SCF_Op<"reduce", [HasParent<"ParallelOp">]> { def ReduceOp : SCF_Op<"reduce", [HasParent<"ParallelOp">]> {
let summary = "reduce operation for parallel for"; let summary = "reduce operation for parallel for";
let description = [{ let description = [{
"scf.reduce" is an operation occurring inside "scf.parallel" operations. "scf.reduce" is an operation occurring inside "scf.parallel" operations.
It consists of one block with two arguments which have the same type as the It consists of one block with two arguments which have the same type as the
operand of "scf.reduce". operand of "scf.reduce".
"scf.reduce" is used to model the value for reduction computations of a "scf.reduce" is used to model the value for reduction computations of a
Show All 34 Linesdef ReduceOp : SCF_Op<"reduce", [HasParent<"ParallelOp">]> {
]; ];
let arguments = (ins AnyType:$operand); let arguments = (ins AnyType:$operand);
let hasCustomAssemblyFormat = 1; let hasCustomAssemblyFormat = 1;
let regions = (region SizedRegion<1>:$reductionOperator); let regions = (region SizedRegion<1>:$reductionOperator);
let hasRegionVerifier = 1; let hasRegionVerifier = 1;
} }
//===----------------------------------------------------------------------===//
// ReduceReturnOp
//===----------------------------------------------------------------------===//
def ReduceReturnOp : def ReduceReturnOp :
SCF_Op<"reduce.return", [HasParent<"ReduceOp">, NoSideEffect, SCF_Op<"reduce.return", [HasParent<"ReduceOp">, NoSideEffect,
Terminator]> { Terminator]> {
let summary = "terminator for reduce operation"; let summary = "terminator for reduce operation";
let description = [{ let description = [{
"scf.reduce.return" is a special terminator operation for the block inside "scf.reduce.return" is a special terminator operation for the block inside
"scf.reduce". It terminates the region. It should have the same type as "scf.reduce". It terminates the region. It should have the same type as
the operand of "scf.reduce". Example for the custom format: the operand of "scf.reduce". Example for the custom format:
```mlir ```mlir
scf.reduce.return %res : f32 scf.reduce.return %res : f32
``` ```
}]; }];
let arguments = (ins AnyType:$result); let arguments = (ins AnyType:$result);
let assemblyFormat = "$result attr-dict `:` type($result)"; let assemblyFormat = "$result attr-dict `:` type($result)";
let hasVerifier = 1; let hasVerifier = 1;
} }
//===----------------------------------------------------------------------===//
// WhileOp
//===----------------------------------------------------------------------===//
def WhileOp : SCF_Op<"while", def WhileOp : SCF_Op<"while",
[DeclareOpInterfaceMethods<RegionBranchOpInterface>, [DeclareOpInterfaceMethods<RegionBranchOpInterface>,
RecursiveSideEffects]> { RecursiveSideEffects]> {
let summary = "a generic 'while' loop"; let summary = "a generic 'while' loop";
let description = [{ let description = [{
This operation represents a generic "while"/"do-while" loop that keeps This operation represents a generic "while"/"do-while" loop that keeps
iterating as long as a condition is satisfied. There is no restriction on iterating as long as a condition is satisfied. There is no restriction on
the complexity of the condition. It consists of two regions (with single the complexity of the condition. It consists of two regions (with single
▲ Show 20 Lines • Show All 118 Lines • ▼ Show 20 Lines let extraClassDeclaration = [{
Block::BlockArgListType getAfterArguments(); Block::BlockArgListType getAfterArguments();
}]; }];
let hasCanonicalizer = 1; let hasCanonicalizer = 1;
let hasCustomAssemblyFormat = 1; let hasCustomAssemblyFormat = 1;
let hasRegionVerifier = 1; let hasRegionVerifier = 1;
} }
//===----------------------------------------------------------------------===//
// YieldOp
//===----------------------------------------------------------------------===//
def YieldOp : SCF_Op<"yield", [NoSideEffect, ReturnLike, Terminator, def YieldOp : SCF_Op<"yield", [NoSideEffect, ReturnLike, Terminator,
ParentOneOf<["ExecuteRegionOp, ForOp", ParentOneOf<["ExecuteRegionOp, ForOp",
"IfOp, ParallelOp, WhileOp"]>]> { "IfOp, ParallelOp, WhileOp"]>]> {
let summary = "loop yield and termination operation"; let summary = "loop yield and termination operation";
let description = [{ let description = [{
"scf.yield" yields an SSA value from the SCF dialect op region and "scf.yield" yields an SSA value from the SCF dialect op region and
terminates the regions. The semantics of how the values are yielded is terminates the regions. The semantics of how the values are yielded is
defined by the parent operation. defined by the parent operation.
Show All 16 Lines

mlir/lib/Dialect/Bufferization/Transforms/OneShotAnalysis.cpp

Show First 20 Lines • Show All 299 Lines • ▼ Show 20 Linesbool OneShotAnalysisState::isValueWritten(Value value) const {
aliasInfo.applyOnAliases(value, [&](Value val) { aliasInfo.applyOnAliases(value, [&](Value val) {
for (OpOperand &use : val.getUses()) for (OpOperand &use : val.getUses())
if (isInPlace(use) && bufferizesToMemoryWrite(use)) if (isInPlace(use) && bufferizesToMemoryWrite(use))
isWritten = true; isWritten = true;
}); });
return isWritten; return isWritten;
} }
bool OneShotAnalysisState::isWritable(Value value) const {
// TODO: Out-of-place bufferized value could be considered writable.
if (auto bufferizableOp = getOptions().dynCastBufferizableOp(value))
return bufferizableOp.isWritable(value, *this);
// Query BufferizableOpInterface to see if the BlockArgument is writable.
if (auto bbArg = value.dyn_cast<BlockArgument>())
if (auto bufferizableOp =
getOptions().dynCastBufferizableOp(bbArg.getOwner()->getParentOp()))
return bufferizableOp.isWritable(bbArg, *this);
// Not a bufferizable op: The conservative answer is "not writable".
return false;
}
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Bufferization-specific alias analysis. // Bufferization-specific alias analysis.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// Return true if opOperand has been decided to bufferize in-place. /// Return true if opOperand has been decided to bufferize in-place.
static bool isInplaceMemoryWrite(OpOperand &opOperand, static bool isInplaceMemoryWrite(OpOperand &opOperand,
const BufferizationAliasInfo &aliasInfo, const BufferizationAliasInfo &aliasInfo,
AnalysisState &state) { const AnalysisState &state) {
// OpOperands that do not bufferize to a memory write do not write in-place. // OpOperands that do not bufferize to a memory write do not write in-place.
if (!state.bufferizesToMemoryWrite(opOperand)) if (!state.bufferizesToMemoryWrite(opOperand))
return false; return false;
// Check current bufferization decisions. // Check current bufferization decisions.
return aliasInfo.isInPlace(opOperand); return aliasInfo.isInPlace(opOperand);
} }
/// Return true if, under current bufferization decisions, the buffer of `value`
/// is not writable.
static bool aliasesNonWritableBuffer(Value value,
const BufferizationAliasInfo &aliasInfo,
AnalysisState &state) {
bool foundNonWritableBuffer = false;
aliasInfo.applyOnAliases(value, [&](Value v) {
// Query BufferizableOpInterface to see if the value is writable.
// TODO: Out-of-place bufferized value could be considered writable.
if (auto bufferizableOp = state.getOptions().dynCastBufferizableOp(v))
if (bufferizableOp && bufferizableOp.isWritable(v, state))
return;
// Query BufferizableOpInterface to see if the BlockArgument is writable.
if (auto bbArg = v.dyn_cast<BlockArgument>())
if (auto bufferizableOp = state.getOptions().dynCastBufferizableOp(
bbArg.getOwner()->getParentOp()))
if (bufferizableOp.isWritable(bbArg, state))
return;
foundNonWritableBuffer = true;
});
return foundNonWritableBuffer;
}
/// Return true if the buffer to which `operand` would bufferize is equivalent
/// to some buffer write.
static bool aliasesInPlaceWrite(Value value,
const BufferizationAliasInfo &aliasInfo,
AnalysisState &state) {
bool foundInplaceWrite = false;
aliasInfo.applyOnAliases(value, [&](Value v) {
for (auto &use : v.getUses()) {
if (isInplaceMemoryWrite(use, aliasInfo, state)) {
foundInplaceWrite = true;
return;
}
}
});
return foundInplaceWrite;
}
/// Return true if `a` happens before `b`, i.e., `a` or one of its ancestors /// Return true if `a` happens before `b`, i.e., `a` or one of its ancestors
/// properly dominates `b` and `b` is not inside `a`. /// properly dominates `b` and `b` is not inside `a`.
static bool happensBefore(Operation *a, Operation *b, static bool happensBefore(Operation *a, Operation *b,
const DominanceInfo &domInfo) { const DominanceInfo &domInfo) {
do { do {
// TODO: Instead of isProperAncestor + properlyDominates, we should use // TODO: Instead of isProperAncestor + properlyDominates, we should use
// properlyDominatesImpl(a, b, /*enclosingOpOk=*/false) // properlyDominatesImpl(a, b, /*enclosingOpOk=*/false)
if (a->isProperAncestor(b)) if (a->isProperAncestor(b))
▲ Show 20 Lines • Show All 225 Lines • ▼ Show 20 Lines for (OpOperand *uConflictingWrite : usesWrite) {
return true; return true;
} }
} }
} }
return false; return false;
} }
// Helper function to iterate on aliases of `root` and capture the writes.
static void getAliasingInplaceWrites(DenseSet<OpOperand *> &res, Value root,
const BufferizationAliasInfo &aliasInfo,
const AnalysisState &state) {
aliasInfo.applyOnAliases(root, [&](Value alias) {
for (auto &use : alias.getUses())
// Inplace write to a value that aliases root.
if (isInplaceMemoryWrite(use, aliasInfo, state))
res.insert(&use);
});
}
// Helper function to iterate on aliases of `root` and capture the reads.
static void getAliasingReads(DenseSet<OpOperand *> &res, Value root,
const BufferizationAliasInfo &aliasInfo,
const AnalysisState &state) {
aliasInfo.applyOnAliases(root, [&](Value alias) {
for (auto &use : alias.getUses())
// Read to a value that aliases root.
if (state.bufferizesToMemoryRead(use))
res.insert(&use);
});
}
/// Return true if bufferizing `operand` inplace would create a conflict. A read /// Return true if bufferizing `operand` inplace would create a conflict. A read
/// R and a write W of the same alias set is a conflict if inplace bufferization /// R and a write W of the same alias set is a conflict if inplace bufferization
/// of W changes the value read by R to a value different from the one that /// of W changes the value read by R to a value different from the one that
/// would be expected by tracing back R's origin through SSA use-def chains. /// would be expected by tracing back R's origin through SSA use-def chains.
/// A conflict can only be introduced by a new alias and/or an inplace /// A conflict can only be introduced by a new alias and/or an inplace
/// bufferization decision. /// bufferization decision.
/// ///
/// Example: /// Example:
Show All 17 Lines
/// ///
/// Note: If `checkConsistencyOnly`, this function may be called with a null /// Note: If `checkConsistencyOnly`, this function may be called with a null
/// OpResult. In that case, only the consistency of bufferization decisions /// OpResult. In that case, only the consistency of bufferization decisions
/// involving aliases of the given OpOperand are checked. /// involving aliases of the given OpOperand are checked.
static bool wouldCreateReadAfterWriteInterference( static bool wouldCreateReadAfterWriteInterference(
OpOperand &operand, const DominanceInfo &domInfo, AnalysisState &state, OpOperand &operand, const DominanceInfo &domInfo, AnalysisState &state,
const BufferizationAliasInfo &aliasInfo, const BufferizationAliasInfo &aliasInfo,
bool checkConsistencyOnly = false) { bool checkConsistencyOnly = false) {
// Helper function to iterate on aliases of `root` and capture the reads.
auto getAliasingReads = [&](DenseSet<OpOperand *> &res, Value root) {
aliasInfo.applyOnAliases(root, [&](Value alias) {
for (auto &use : alias.getUses())
// Read to a value that aliases root.
if (state.bufferizesToMemoryRead(use))
res.insert(&use);
});
};
// Helper function to iterate on aliases of `root` and capture the writes.
auto getAliasingInplaceWrites = [&](DenseSet<OpOperand *> &res, Value root) {
aliasInfo.applyOnAliases(root, [&](Value alias) {
for (auto &use : alias.getUses())
// Inplace write to a value that aliases root.
if (isInplaceMemoryWrite(use, aliasInfo, state))
res.insert(&use);
});
};
// Collect reads and writes of all aliases of OpOperand and OpResult. // Collect reads and writes of all aliases of OpOperand and OpResult.
DenseSet<OpOperand *> usesRead, usesWrite; DenseSet<OpOperand *> usesRead, usesWrite;
getAliasingReads(usesRead, operand.get()); getAliasingReads(usesRead, operand.get(), aliasInfo, state);
getAliasingInplaceWrites(usesWrite, operand.get()); getAliasingInplaceWrites(usesWrite, operand.get(), aliasInfo, state);
for (OpResult result : state.getAliasingOpResult(operand)) { for (OpResult result : state.getAliasingOpResult(operand)) {
getAliasingReads(usesRead, result); getAliasingReads(usesRead, result, aliasInfo, state);
getAliasingInplaceWrites(usesWrite, result); getAliasingInplaceWrites(usesWrite, result, aliasInfo, state);
} }
if (!checkConsistencyOnly && state.bufferizesToMemoryWrite(operand)) if (!checkConsistencyOnly && state.bufferizesToMemoryWrite(operand))
usesWrite.insert(&operand); usesWrite.insert(&operand);
return hasReadAfterWriteInterference(usesRead, usesWrite, domInfo, state, return hasReadAfterWriteInterference(usesRead, usesWrite, domInfo, state,
aliasInfo); aliasInfo);
} }
/// Return true if bufferizing `opOperand` inplace would create a write to a /// Check the reverse SSA use-def chain (following aliasing OpOperands) for
/// non-writable buffer. /// non-writable tensor values. Stop searching when an out-of-place bufferized
/// OpOperand was found (or when the OpOperand was not bufferized yet).
/// `currentOpOperand` is assumed to be in-place, even if that decision was not
/// materialized in `aliasInfo` yet.
static bool static bool
wouldCreateWriteToNonWritableBuffer(OpOperand &opOperand, hasPrecedingAliasingNonWritableTensor(Value value, OpOperand *currentOpOperand,
const BufferizationAliasInfo &aliasInfo, const BufferizationAliasInfo &aliasInfo,
AnalysisState &state) { const OneShotAnalysisState &state) {
// Certain buffers are not writeable: SmallVector<Value> worklist;
// 1. A function bbArg that is not inplaceable or worklist.push_back(value);
// 2. A constant op. while (!worklist.empty()) {
bool nonWritable = Value nextVal = worklist.pop_back_val();
aliasesNonWritableBuffer(opOperand.get(), aliasInfo, state); if (!state.isWritable(nextVal))
if (!nonWritable) return true;
// If `nextVal` is not a BlockArgument: End of use-def chain reached.
auto opResult = nextVal.dyn_cast<OpResult>();
if (!opResult)
continue;
// Follow reverse SSA use-def chain.
SmallVector<OpOperand *> aliasingOpOperands =
state.getAliasingOpOperand(opResult);
for (OpOperand *opOperand : aliasingOpOperands)
if (aliasInfo.isInPlace(*opOperand) || currentOpOperand == opOperand)
worklist.push_back(opOperand->get());
}
return false; return false;
}
// This is a problem only if the buffer is written to via some alias. /// Return true if bufferizing `operand` inplace would create a write to a
bool hasWrite = aliasesInPlaceWrite(opOperand.get(), aliasInfo, state) || /// non-writable buffer.
state.bufferizesToMemoryWrite(opOperand); static bool wouldCreateWriteToNonWritableBuffer(
OpOperand &operand, const BufferizationAliasInfo &aliasInfo,
OneShotAnalysisState &state, bool checkConsistencyOnly = false) {
// Collect writes of all aliases of OpOperand and OpResult.
DenseSet<OpOperand *> usesWrite;
getAliasingInplaceWrites(usesWrite, operand.get(), aliasInfo, state);
for (OpResult result : state.getAliasingOpResult(operand)) {
getAliasingInplaceWrites(usesWrite, result, aliasInfo, state);
}
if (!checkConsistencyOnly && state.bufferizesToMemoryWrite(operand))
usesWrite.insert(&operand);
for (OpResult opResult : state.getAliasingOpResult(opOperand)) // Assuming that `operand` bufferizes in-place: For each write (to each
hasWrite |= aliasesInPlaceWrite(opResult, aliasInfo, state); // alias), check if there is a non-writable tensor in the reverse SSA use-def
// chain.
for (OpOperand *uWrite : usesWrite)
if (hasPrecedingAliasingNonWritableTensor(uWrite->get(), &operand,
aliasInfo, state))
return true;
return hasWrite; return false;
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Bufferization analyses. // Bufferization analyses.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// Determine if `operand` can be bufferized in-place. /// Determine if `operand` can be bufferized in-place.
static LogicalResult bufferizableInPlaceAnalysisImpl( static LogicalResult bufferizableInPlaceAnalysisImpl(
OpOperand &operand, BufferizationAliasInfo &aliasInfo, AnalysisState &state, OpOperand &operand, BufferizationAliasInfo &aliasInfo,
const DominanceInfo &domInfo) { OneShotAnalysisState &state, const DominanceInfo &domInfo) {
bool foundInterference = bool foundInterference =
wouldCreateWriteToNonWritableBuffer(operand, aliasInfo, state) || wouldCreateWriteToNonWritableBuffer(operand, aliasInfo, state) ||
wouldCreateReadAfterWriteInterference(operand, domInfo, state, aliasInfo); wouldCreateReadAfterWriteInterference(operand, domInfo, state, aliasInfo);
if (foundInterference) if (foundInterference)
aliasInfo.bufferizeOutOfPlace(operand); aliasInfo.bufferizeOutOfPlace(operand);
else else
aliasInfo.bufferizeInPlace(operand, state); aliasInfo.bufferizeInPlace(operand, state);
Show All 16 Lines
/// When bufferized inplace, an ExtractSliceOp does not by itself create any /// When bufferized inplace, an ExtractSliceOp does not by itself create any
/// read or write from memory. Instead, it has the effect of merging the alias /// read or write from memory. Instead, it has the effect of merging the alias
/// sets of the source and the result buffers. /// sets of the source and the result buffers.
/// ///
/// An analysis is required to ensure inplace bufferization would not result in /// An analysis is required to ensure inplace bufferization would not result in
/// RaW dependence violations. /// RaW dependence violations.
static LogicalResult inPlaceAnalysis(SmallVector<Operation *> &ops, static LogicalResult inPlaceAnalysis(SmallVector<Operation *> &ops,
BufferizationAliasInfo &aliasInfo, BufferizationAliasInfo &aliasInfo,
AnalysisState &state, OneShotAnalysisState &state,
const DominanceInfo &domInfo, const DominanceInfo &domInfo,
unsigned analysisFuzzerSeed = 0) { unsigned analysisFuzzerSeed = 0) {
if (analysisFuzzerSeed) { if (analysisFuzzerSeed) {
// This is a fuzzer. For testing purposes only. Randomize the order in which // This is a fuzzer. For testing purposes only. Randomize the order in which
// operations are analyzed. The bufferization quality is likely worse, but // operations are analyzed. The bufferization quality is likely worse, but
// we want to make sure that no assertions are triggered anywhere. // we want to make sure that no assertions are triggered anywhere.
std::mt19937 g(analysisFuzzerSeed); std::mt19937 g(analysisFuzzerSeed);
llvm::shuffle(ops.begin(), ops.end(), g); llvm::shuffle(ops.begin(), ops.end(), g);
Show All 16 Linesstatic bool hasTensorSemantics(Operation *op) {
bool hasTensorResult = any_of(op->getResultTypes(), isaTensor); bool hasTensorResult = any_of(op->getResultTypes(), isaTensor);
bool hasTensorOperand = any_of(op->getOperandTypes(), isaTensor); bool hasTensorOperand = any_of(op->getOperandTypes(), isaTensor);
return hasTensorResult || hasTensorOperand; return hasTensorResult || hasTensorOperand;
} }
/// Analyze all ops that are contained in `op`. /// Analyze all ops that are contained in `op`.
static LogicalResult inPlaceAnalysis(Operation *op, static LogicalResult inPlaceAnalysis(Operation *op,
BufferizationAliasInfo &aliasInfo, BufferizationAliasInfo &aliasInfo,
AnalysisState &state, OneShotAnalysisState &state,
const DominanceInfo &domInfo, const DominanceInfo &domInfo,
unsigned analysisFuzzerSeed = 0) { unsigned analysisFuzzerSeed = 0) {
// Collect ops so we can build our own reverse traversal. // Collect ops so we can build our own reverse traversal.
SmallVector<Operation *> ops; SmallVector<Operation *> ops;
op->walk([&](Operation *op) { op->walk([&](Operation *op) {
// No tensors => no buffers. // No tensors => no buffers.
if (!hasTensorSemantics(op)) if (!hasTensorSemantics(op))
return; return;
▲ Show 20 Lines • Show All 209 Lines • Show Last 20 Lines

mlir/lib/Dialect/MemRef/IR/MemRefOps.cpp

Show First 20 Lines • Show All 1,728 Lines • ▼ Show 20 Lines for (auto it : llvm::reverse(llvm::zip(reassociation, srcStrides))) {
for (unsigned idx = 0, e = reassoc.size(); idx < e; ++idx) { for (unsigned idx = 0, e = reassoc.size(); idx < e; ++idx) {
using saturated_arith::Wrapper; using saturated_arith::Wrapper;
reverseResultStrides.push_back(currentStrideToExpand); reverseResultStrides.push_back(currentStrideToExpand);
currentStrideToExpand = (Wrapper::stride(currentStrideToExpand) * currentStrideToExpand = (Wrapper::stride(currentStrideToExpand) *
Wrapper::size(resultShape[shapeIndex--])) Wrapper::size(resultShape[shapeIndex--]))
.asStride(); .asStride();
} }
} }
return makeStridedLinearLayoutMap( auto resultStrides = llvm::to_vector<8>(llvm::reverse(reverseResultStrides));
llvm::to_vector<8>(llvm::reverse(reverseResultStrides)), srcOffset, resultStrides.resize(resultShape.size(), 1);
return makeStridedLinearLayoutMap(resultStrides, srcOffset,
srcType.getContext()); srcType.getContext());
} }
static FailureOr<MemRefType> static FailureOr<MemRefType>
computeExpandedType(MemRefType srcType, ArrayRef<int64_t> resultShape, computeExpandedType(MemRefType srcType, ArrayRef<int64_t> resultShape,
ArrayRef<ReassociationIndices> reassociation) { ArrayRef<ReassociationIndices> reassociation) {
if (srcType.getLayout().isIdentity()) { if (srcType.getLayout().isIdentity()) {
// If the source is contiguous (i.e., no layout map specified), so is the // If the source is contiguous (i.e., no layout map specified), so is the
// result. // result.
▲ Show 20 Lines • Show All 1,145 Lines • Show Last 20 Lines

mlir/test/Dialect/Bufferization/Transforms/one-shot-bufferize-allow-return-allocs.mlir

Show All 25 Lines // CHECK: } else {
scf.yield %t : tensor<?xf32> scf.yield %t : tensor<?xf32>
} }
// CHECK: } // CHECK: }
// CHECK: %[[r_tensor:.*]] = bufferization.to_tensor %[[r]] // CHECK: %[[r_tensor:.*]] = bufferization.to_tensor %[[r]]
// CHECK: memref.dealloc %[[r]] // CHECK: memref.dealloc %[[r]]
// CHECK: return %[[r_tensor]] // CHECK: return %[[r_tensor]]
return %r : tensor<?xf32> return %r : tensor<?xf32>
} }
// -----
// CHECK-LABEL: func @write_to_alloc_tensor_or_readonly_tensor(
// CHECK-SAME: %[[arg0:.*]]: tensor<i32>
func.func @write_to_alloc_tensor_or_readonly_tensor(%arg0: tensor<i32>,
%cond: i1, %val: i32)
-> tensor<i32>
{
// CHECK: %[[r:.*]] = scf.if {{.*}} {
// CHECK: %[[arg0_m:.*]] = bufferization.to_memref %[[arg0]]
// CHECK: %[[clone:.*]] = bufferization.clone %[[arg0_m]]
// CHECK: scf.yield %[[clone]]
// CHECK: } else {
// CHECK: %[[alloc:.*]] = memref.alloc
// CHECK: memref.store %{{.*}}, %[[alloc]]
// CHECK: %[[casted:.*]] = memref.cast %[[alloc]]
// CHECK: scf.yield %[[casted]]
// CHECK: }
// CHECK: %[[r_t:.*]] = bufferization.to_tensor %[[r]]
// CHECK: memref.dealloc %[[r]]
// CHECK: return %[[r_t]]
%3 = scf.if %cond -> (tensor<i32>) {
scf.yield %arg0 : tensor<i32>
} else {
%7 = bufferization.alloc_tensor() : tensor<i32>
%8 = tensor.insert %val into %7[] : tensor<i32>
scf.yield %8 : tensor<i32>
}
return %3 : tensor<i32>
}

mlir/test/Dialect/Tensor/bufferize.mlir

// RUN: mlir-opt %s -tensor-bufferize -cse | FileCheck %s // RUN: mlir-opt %s -tensor-bufferize -cse | FileCheck %s
// CHECK-DAG: #[[$MAP0:.*]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)> // CHECK-DAG: #[[$MAP0:.*]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)>
// CHECK-DAG: #[[$MAP1:.*]] = affine_map<(d0, d1)[s0] -> (d0 * 20 + s0 + d1)> // CHECK-DAG: #[[$MAP1:.*]] = affine_map<(d0, d1)[s0] -> (d0 * 20 + s0 + d1)>
// CHECK-DAG: #[[$MAP2:.*]] = affine_map<(d0, d1, d2, d3)[s0] -> (d0 * 140 + d1 * 20 + d2 * 5 + d3 + s0)> // CHECK-DAG: #[[$MAP2:.*]] = affine_map<(d0, d1, d2, d3)[s0] -> (d0 * 140 + d1 * 20 + d2 * 5 + d3 + s0)>
// CHECK-DAG: #[[$MAP3:.*]] = affine_map<(d0) -> (d0 + 1)> // CHECK-DAG: #[[$MAP3:.*]] = affine_map<(d0) -> (d0 + 1)>
// CHECK-DAG: #[[$MAP4:.*]] = affine_map<() -> (1)> // CHECK-DAG: #[[$MAP4:.*]] = affine_map<() -> (1)>
// CHECK-DAG: #[[$MAP5:.*]] = affine_map<(d0, d1) -> (d0 * 2 + d1)> // CHECK-DAG: #[[$MAP5:.*]] = affine_map<(d0, d1) -> (d0 * 2 + d1)>
// CHECK-DAG: #[[$MAP6:.*]] = affine_map<(d0) -> (d0 * 2)> // CHECK-DAG: #[[$MAP6:.*]] = affine_map<(d0) -> (d0 * 2)>
// CHECK-DAG: #[[$MAP7:.*]] = affine_map<(d0, d1, d2)[s0] -> (d0 * 8 + s0 + d1 * 4 + d2)> // CHECK-DAG: #[[$MAP7:.*]] = affine_map<(d0, d1, d2)[s0] -> (d0 * 8 + s0 + d1 * 4 + d2)>
// CHECK-DAG: #[[$MAP8:.*]] = affine_map<(d0)[s0] -> (d0 * 4 + s0)> // CHECK-DAG: #[[$MAP8:.*]] = affine_map<(d0)[s0] -> (d0 * 4 + s0)>
// CHECK-DAG: #[[$MAP9:.*]] = affine_map<()[s0] -> (s0)>
// CHECK-DAG: #[[$MAP10:.*]] = affine_map<(d0)[s0] -> (d0 + s0)>
// CHECK-LABEL: func @dim( // CHECK-LABEL: func @dim(
// CHECK-SAME: %[[TENSOR:.*]]: tensor<f32>, // CHECK-SAME: %[[TENSOR:.*]]: tensor<f32>,
// CHECK-SAME: %[[INDEX:.*]]: index) -> index { // CHECK-SAME: %[[INDEX:.*]]: index) -> index {
// CHECK: %[[MEMREF:.*]] = bufferization.to_memref %[[TENSOR]] : memref<f32> // CHECK: %[[MEMREF:.*]] = bufferization.to_memref %[[TENSOR]] : memref<f32>
// CHECK: %[[EXTENT:.*]] = memref.dim %[[MEMREF]], %[[INDEX]] : memref<f32> // CHECK: %[[EXTENT:.*]] = memref.dim %[[MEMREF]], %[[INDEX]] : memref<f32>
// CHECK: return %[[EXTENT]] : index // CHECK: return %[[EXTENT]] : index
func.func @dim(%arg0: tensor<f32>, %arg1: index) -> index { func.func @dim(%arg0: tensor<f32>, %arg1: index) -> index {
▲ Show 20 Lines • Show All 308 Lines • ▼ Show 20 Linesfunc.func @tensor.expand_shape_of_slice(
// CHECK-SAME: [0, 1], [2, 3]] : memref<?x10xf32, #[[$MAP1]]> into memref<?x7x2x5xf32, #[[$MAP2]]> // CHECK-SAME: [0, 1], [2, 3]] : memref<?x10xf32, #[[$MAP1]]> into memref<?x7x2x5xf32, #[[$MAP2]]>
%1 = tensor.expand_shape %0 [[0, 1], [2, 3]] : %1 = tensor.expand_shape %0 [[0, 1], [2, 3]] :
tensor<?x10xf32> into tensor<?x7x2x5xf32> tensor<?x10xf32> into tensor<?x7x2x5xf32>
// CHECK: %[[r:.*]] = bufferization.to_tensor %[[expanded]] // CHECK: %[[r:.*]] = bufferization.to_tensor %[[expanded]]
// CHECK: return %[[r]] // CHECK: return %[[r]]
return %1 : tensor<?x7x2x5xf32> return %1 : tensor<?x7x2x5xf32>
} }
// CHECK-LABEL: func @tensor.expand_shape_of_scalar_slice(
// CHECK-SAME: %[[t1:.*]]: tensor<?xf32>
func.func @tensor.expand_shape_of_scalar_slice(
%t1: tensor<?xf32>, %o1: index, %s1: index) -> tensor<1xf32> {
// CHECK: %[[m1:.*]] = bufferization.to_memref %[[t1]] : memref<?xf32>
// CHECK: %[[subview:.*]] = memref.subview %[[m1]][%{{.*}}] [1] [1] : memref<?xf32> to memref<f32, #[[$MAP9]]>
%0 = tensor.extract_slice %t1[%o1][1][1] : tensor<?xf32> to tensor<f32>
// CHECK: %[[expanded:.*]] = memref.expand_shape %[[subview]] [] : memref<f32, #[[$MAP9]]> into memref<1xf32, #[[$MAP10]]>
%1 = tensor.expand_shape %0 [] : tensor<f32> into tensor<1xf32>
// CHECK: %[[r:.*]] = bufferization.to_tensor %[[expanded]]
// CHECK: return %[[r]]
return %1 : tensor<1xf32>
}
// CHECK-LABEL: func @tensor.collapse_shape( // CHECK-LABEL: func @tensor.collapse_shape(
// CHECK-SAME: %[[t1:.*]]: tensor<2x?x?xf32> // CHECK-SAME: %[[t1:.*]]: tensor<2x?x?xf32>
func.func @tensor.collapse_shape(%t1: tensor<2x?x?xf32>) -> tensor<?x?xf32> { func.func @tensor.collapse_shape(%t1: tensor<2x?x?xf32>) -> tensor<?x?xf32> {
// CHECK: %[[m1:.*]] = bufferization.to_memref %[[t1]] : memref<2x?x?xf32> // CHECK: %[[m1:.*]] = bufferization.to_memref %[[t1]] : memref<2x?x?xf32>
// CHECK: %[[collapsed:.*]] = memref.collapse_shape %[[m1]] [ // CHECK: %[[collapsed:.*]] = memref.collapse_shape %[[m1]] [
// CHECK-SAME: [0, 1], [2]] : memref<2x?x?xf32> into memref<?x?xf32> // CHECK-SAME: [0, 1], [2]] : memref<2x?x?xf32> into memref<?x?xf32>
%0 = tensor.collapse_shape %t1 [[0, 1], [2]] %0 = tensor.collapse_shape %t1 [[0, 1], [2]]
: tensor<2x?x?xf32> into tensor<?x?xf32> : tensor<2x?x?xf32> into tensor<?x?xf32>
▲ Show 20 Lines • Show All 94 Lines • Show Last 20 Lines