|
 | clang/lib/Sema/SemaStmt.cpp (diff) |
 | clang/include/clang/Sema/Sema.h (diff) |
 | clang/lib/Sema/SemaCoroutine.cpp (diff) |
 | clang/test/CXX/temp/temp.decls/temp.mem/p5.cpp (diff) |
 | clang/test/SemaCXX/constant-expression-cxx11.cpp (diff) |
 | clang/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.spec.auto/p7-cxx14.cpp (diff) |
 | clang/test/CXX/drs/dr3xx.cpp (diff) |
 | clang/test/SemaCXX/coroutines.cpp (diff) |
 | clang/lib/Sema/SemaType.cpp (diff) |
 | clang/test/CXX/expr/expr.prim/expr.prim.lambda/p4-cxx14.cpp (diff) |
 | clang/test/SemaCXX/coroutine-rvo.cpp (diff) |
 | clang/test/SemaCXX/deduced-return-type-cxx14.cpp (diff) |
 | clang/test/SemaCXX/constant-expression-cxx14.cpp (diff) |
 | clang/test/SemaCXX/warn-return-std-move.cpp (diff) |
 | clang/test/CXX/class/class.init/class.copy.elision/p3.cpp (diff) |
 | clang/test/SemaCXX/return-stack-addr.cpp (diff) |
 | clang/lib/Sema/SemaExprCXX.cpp (diff) |
|
 | clang/lib/Sema/SemaTemplateInstantiateDecl.cpp (diff) |
 | clang/include/clang/Sema/Sema.h (diff) |
 | clang/lib/Sema/SemaStmt.cpp (diff) |
 | clang/lib/Sema/Sema.cpp (diff) |
 | clang/test/CodeGen/nrvo-tracking.cpp (diff) |
 | clang/lib/Sema/SemaCoroutine.cpp (diff) |
 | clang/lib/Sema/SemaExprCXX.cpp (diff) |
|
 | clang/include/clang/Basic/riscv_vector.td (diff) |
Commit
54418c5a355eda7ff77a221c692ee90944c25196
by thakis[lld/mac] Make binaries written by lld strippable
Be less clever when writing the indirect symbols in LC_DYSYMTAB: lld used to make point __stubs and __la_symbol_ptr point at the same bytes in the indirect symbol table in the __LINKEDIT segment. That confused strip, so write the same bytes twice and make __stubs and __la_symbol_ptr point at one copy each, so that they don't share data. This unconfuses strip, and seems to be what ld64 does too, so hopefully tools are generally more used to this.
This makes the output binaries a bit larger, but not much: 4 bytes for roughly each called function from a dylib and each weak function. Chromium Framewoork grows by 6536 bytes, clang-format by a few hundred.
With this, `strip -x Chromium\ Framework` works (244 MB before stripping to 171 MB after stripping, compared to 236 MB=>164 MB with ld64). Running strip without `-x` produces the same error message now for lld-linked Chromium Framework as for when using ld64 as a linker.
`strip clang-format` also works now but didn't previously.
Fixes PR50657.
Differential Revision: https://reviews.llvm.org/D104081
|
 | lld/test/MachO/indirect-symtab.s (diff) |
 | lld/MachO/SyntheticSections.cpp (diff) |
Commit
643b6407faf460915679f304420cfbee87c47734
by kai.wang[RISCV] Avoid scalar outgoing argumetns overwriting vector frame objects.
When using FP to access stack objects, the scalable stack objects will be put at the lower end of the frame. It looks like
``` |-------------------| <-- FP | callee-saved regs | |-------------------| | scalar local vars | |-------------------| | RVV local vars | |-------------------| <-- SP ```
If there are scalar arguments that need to pass through memory and there are vector objects on the stack using FP to access. The outgoing scalar arguments will overwrite the vector objects. It looks like
``` |-------------------| <-- FP | callee-saved regs | |-------------------| | scalar local vars | |-------------------| |-------------------| | RVV local vars | | outgoing args | <- outgoing arguments |-------------------| <-- SP |-------------------| overwrite from here. ```
In this patch, we reserve the stack for the outgoing arguments before function calls if using FP to access and there are scalable vector frame objects. It looks like
``` |-------------------| <-- FP | callee-saved regs | |-------------------| | scalar local vars | |-------------------| | RVV local vars | |-------------------| | outgoing args | |-------------------| <-- SP ```
Differential Revision: https://reviews.llvm.org/D103622
|
 | llvm/lib/Target/RISCV/RISCVFrameLowering.cpp (diff) |
 | llvm/test/CodeGen/RISCV/rvv/rvv-out-arguments.ll (diff) |
Commit
632cbcac79065a62a306dbda7b3a6e1f315e3260
by Raphael Isemann[lldb] Move once_flags in HostInfoLinux so the internal state struct
The HostInfoLinuxFields struct is supposed to be set up/torn down on Initialize/Terminate and should contain all the state of the plugin. `once_flags` are part of this state and should also be reset on `Terminate` so we can re-initialize these lazy values after the next `Initialize` call.
This itself is NFC as the HostInfoLinux was broken before this patch and is still broken afterwards. D104091 will be the proper fix.
Reviewed By: vitalybuka
Differential Revision: https://reviews.llvm.org/D104093
|
 | lldb/source/Host/linux/HostInfoLinux.cpp (diff) |
Commit
bc104fdcecc0da1650177f3587ffe233b37f071b
by qiucofan[PowerPC] Relax register superclasses for paired memops
Relaxing superclass constraint for VSX register classes helps reducing 32-byte spills and copies when register pressure is high.
In test case affected, some of them introduces more copies due to new allocation order. However, this patch should not be the root cause, and we may be able to fix it in other places of register allocation.
Reviewed By: nemanjai
Differential Revision: https://reviews.llvm.org/D104006
|
 | llvm/lib/Target/PowerPC/PPCRegisterInfo.cpp (diff) |
 | llvm/test/CodeGen/PowerPC/mma-intrinsics.ll (diff) |
 | llvm/test/CodeGen/PowerPC/vsx.ll (diff) |
 | llvm/test/CodeGen/PowerPC/mma-acc-spill.ll (diff) |
 | llvm/test/CodeGen/PowerPC/p9-xxinsertw-xxextractuw.ll (diff) |
 | llvm/test/CodeGen/PowerPC/remove-redundant-moves.ll (diff) |
 | llvm/test/CodeGen/PowerPC/mma-outer-product.ll (diff) |
 | llvm/test/CodeGen/PowerPC/aix-p9-xxinsertw-xxextractuw.ll (diff) |
 | llvm/test/CodeGen/PowerPC/constant-pool.ll (diff) |
 | llvm/test/CodeGen/PowerPC/vec_conv_i64_to_fp32_elts.ll (diff) |
 | llvm/test/CodeGen/PowerPC/paired-vector-intrinsics.ll (diff) |
|
 | lldb/unittests/Host/HostInfoTest.cpp (diff) |
 | lldb/source/Host/linux/HostInfoLinux.cpp (diff) |
 | lldb/include/lldb/Host/linux/HostInfoLinux.h (diff) |
|
 | clang/cmake/caches/Fuchsia.cmake (diff) |
 | clang/cmake/caches/Fuchsia-stage2.cmake (diff) |
Commit
22f194909ae24aed817976fb54b759550e90db36
by phosekRevert "[Driver] Support libc++ in MSVC"
This reverts commit 9625d61eb66c12388875e081b63ebed7e42c6bbb since libc++ currently has issues with disabled exceptions which breaks the runtimes build.
|
 | clang/include/clang/Driver/Options.td (diff) |
 | clang/lib/Driver/ToolChains/MSVC.cpp (diff) |
 | clang/test/Driver/Inputs/msvc_libcxx_tree/usr/bin/.keep |
 | clang/test/Driver/Inputs/msvc_libcxx_tree/usr/include/c++/v1/.keep |
 | clang/test/Driver/Inputs/msvc_libcxx_tree/usr/lib/x86_64-pc-windows-msvc/.keep |
 | clang/test/Driver/msvc-libcxx.cpp |
 | clang/test/Driver/Inputs/msvc_libcxx_tree/usr/lib/.keep |
 | clang/test/Driver/Inputs/msvc_libcxx_tree/usr/include/x86_64-pc-windows-msvc/c++/v1/.keep |
Commit
c4a0969b9c14acc795ae9e841b8289c3d36220b1
by sjoerd.meijerFunction Specialization Pass
This adds a function specialization pass to LLVM. Constant parameters like function pointers and constant globals are propagated to the callee by specializing the function.
This is a first version with a number of limitations: - The pass is off by default, so needs to be enabled on the command line, - It does not handle specialization of recursive functions, - It does not yet handle constants and constant ranges, - Only 1 argument per function is specialised, - The cost-model could be further looked into, and perhaps related, - We are not yet caching analysis results.
This is based on earlier work by Matthew Simpson (D36432) and Vinay Madhusudan. More recently this was also discussed on the list, see:
https://lists.llvm.org/pipermail/llvm-dev/2021-March/149380.html.
The motivation for this work is that function specialisation often comes up as a reason for performance differences of generated code between LLVM and GCC, which has this enabled by default from optimisation level -O3 and up. And while this certainly helps a few cpu benchmark cases, this also triggers in real world codes and is thus a generally useful transformation to have in LLVM.
Function specialisation has great potential to increase compile-times and code-size. The summary from some investigations with this patch is: - Compile-time increases for short compile jobs is high relatively, but the increase in absolute numbers still low. - For longer compile-jobs, the extra compile time is around 1%, and very much in line with GCC. - It is difficult to blame one thing for compile-time increases: it looks like everywhere a little bit more time is spent processing more functions and instructions. - But the function specialisation pass itself is not very expensive; it doesn't show up very high in the profile of the optimisation passes.
The goal of this work is to reach parity with GCC which means that eventually we would like to get this enabled by default. But first we would like to address some of the limitations before that.
Differential Revision: https://reviews.llvm.org/D93838
|
 | llvm/include/llvm/Transforms/IPO.h (diff) |
 | llvm/lib/Transforms/IPO/IPO.cpp (diff) |
 | llvm/lib/Transforms/IPO/PassManagerBuilder.cpp (diff) |
 | llvm/include/llvm/Transforms/Scalar/SCCP.h (diff) |
 | llvm/lib/Transforms/Scalar/FunctionSpecialization.cpp |
 | llvm/test/Transforms/FunctionSpecialization/function-specialization5.ll |
 | llvm/lib/Transforms/Scalar/SCCP.cpp (diff) |
 | llvm/lib/Transforms/Utils/SCCPSolver.cpp (diff) |
 | llvm/include/llvm/LinkAllPasses.h (diff) |
 | llvm/lib/Transforms/IPO/SCCP.cpp (diff) |
 | llvm/lib/Transforms/Scalar/CMakeLists.txt (diff) |
 | llvm/test/Transforms/FunctionSpecialization/function-specialization2.ll |
 | llvm/lib/Passes/PassBuilder.cpp (diff) |
 | llvm/test/Transforms/FunctionSpecialization/function-specialization-recursive.ll |
 | llvm/test/Transforms/FunctionSpecialization/function-specialization3.ll |
 | llvm/test/Transforms/FunctionSpecialization/function-specialization4.ll |
 | llvm/include/llvm/Transforms/Utils/SCCPSolver.h (diff) |
 | llvm/include/llvm/Transforms/IPO/SCCP.h (diff) |
 | llvm/test/Transforms/FunctionSpecialization/function-specialization.ll |
 | llvm/include/llvm/InitializePasses.h (diff) |
 | llvm/lib/Passes/PassRegistry.def (diff) |
|
 | llvm/utils/gn/secondary/llvm/lib/Transforms/Scalar/BUILD.gn (diff) |
Commit
f98b7796142d996861cbba824f3cacef0b446ef8
by akuegel[mlir] Refactor ComplexOps.td [NFC]
Create a ComplexUnaryOp base class and use it for AbsOp, ReOp and ImOp. Sort all ops in lexicographic order.
Differential Revision: https://reviews.llvm.org/D104095
|
 | mlir/include/mlir/Dialect/Complex/IR/ComplexOps.td (diff) |
Commit
47d138c93992f779a5dd0810b0e7402e043df61d
by dmitry.polukhin[clang-tidy] LIT test fix for Remark diagnostic
There is a followup fix for a unit test introduced at D102906. The test file was placed into a temp folder and test assumed that it would be visible without the full path specification.
This behaviour can be changed in future and it would be good to specify full path to the file at the test.
Test Plan: ``` ninja check-clang-tools ```
Reviewed By: DmitryPolukhin
Differential Revision: https://reviews.llvm.org/D104021
|
 | clang-tools-extra/test/clang-tidy/infrastructure/remarks.cpp (diff) |
Commit
6455418d3d2a2de1a8251cc2ccf2e87b9ae3112d
by srhines[compiler-rt] [builtins] [AArch64] Add missing AArch64 data synchronization barrier (dsb) to __clear_cache
https://developer.arm.com/documentation/den0024/a/Caches/Cache-maintenance covers how to properly clear caches on AArch64, and the builtin implementation was missing a `dsb ish` after clearing the icache for the selected range.
Reviewed By: kristof.beyls
Differential Revision: https://reviews.llvm.org/D104094
|
 | compiler-rt/lib/builtins/clear_cache.c (diff) |
Commit
ca964b40e6e5d20fb658f2d36238b46a35dd860f
by sven.vanhaastregt[OpenCL][NFC] Reorganize ClangOpenCLBuiltinEmitter comments
Since 8866793b4e0a ("[OpenCL] Add OpenCL builtin test generator", 2021-06-09) there are two emitters in this file, so move the file-level comment to the appropriate class.
|
 | clang/utils/TableGen/ClangOpenCLBuiltinEmitter.cpp (diff) |
|
 | llvm/tools/llvm-rust-demangle-fuzzer/llvm-rust-demangle-fuzzer.cpp (diff) |
Commit
5e6bfb661e8b51b440eda04d0be0c9a00b8713e9
by llvm-dev[Analysis] Pass RecurrenceDescriptor as const reference. NFCI.
We were passing the RecurrenceDescriptor by value to most of the reduction analysis methods, despite it being rather bulky with TrackingVH members (that can be costly to copy). In all these cases we're only using the RecurrenceDescriptor for rather basic purposes (access to types/kinds etc.).
Differential Revision: https://reviews.llvm.org/D104029
|
 | llvm/lib/Transforms/Utils/LoopUtils.cpp (diff) |
 | llvm/lib/Target/AArch64/AArch64TargetTransformInfo.cpp (diff) |
 | llvm/lib/Transforms/Vectorize/LoopVectorizationLegality.cpp (diff) |
 | llvm/lib/Analysis/TargetTransformInfo.cpp (diff) |
 | llvm/lib/Target/RISCV/RISCVTargetTransformInfo.h (diff) |
 | llvm/lib/Transforms/Vectorize/LoopVectorize.cpp (diff) |
 | llvm/include/llvm/Analysis/TargetTransformInfo.h (diff) |
 | llvm/include/llvm/Transforms/Utils/LoopUtils.h (diff) |
 | llvm/lib/Target/AArch64/AArch64TargetTransformInfo.h (diff) |
 | llvm/include/llvm/Analysis/TargetTransformInfoImpl.h (diff) |
|
 | llvm/include/llvm/ProfileData/SampleProf.h (diff) |
Commit
56d5c46b494d2232792a46e9b95de40b082f4164
by bing1.yu[X86] Support __tile_stream_loadd intrinsic for new AMX interface
Adding support for __tile_stream_loadd intrinsic.
Reviewed By: LuoYuanke
Differential Revision: https://reviews.llvm.org/D103784
|
 | llvm/lib/Target/X86/X86LowerAMXType.cpp (diff) |
 | clang/include/clang/Basic/BuiltinsX86_64.def (diff) |
 | llvm/lib/Target/X86/X86InstrAMX.td (diff) |
 | llvm/lib/Target/X86/X86ExpandPseudo.cpp (diff) |
 | llvm/test/CodeGen/X86/AMX/amx-tile-basic.ll (diff) |
 | clang/lib/Headers/amxintrin.h (diff) |
 | llvm/lib/Target/X86/X86ISelDAGToDAG.cpp (diff) |
 | llvm/lib/Target/X86/X86PreAMXConfig.cpp (diff) |
 | llvm/lib/Target/X86/X86RegisterInfo.cpp (diff) |
 | llvm/lib/Target/X86/X86FastTileConfig.cpp (diff) |
 | llvm/include/llvm/IR/IntrinsicsX86.td (diff) |
 | clang/test/CodeGen/X86/amx_api.c (diff) |
|
 | llvm/lib/Transforms/Vectorize/VectorCombine.cpp (diff) |
|
 | llvm/test/Transforms/VectorCombine/AArch64/load-extractelement-scalarization.ll (diff) |
 | llvm/lib/Transforms/Vectorize/VectorCombine.cpp (diff) |
Commit
0cc3100bf8d126ce080c0075cf25784b45e5f990
by vsavchenko[analyzer] Introduce a new interface for tracking
Tracking values through expressions and the stores is fundamental for producing clear diagnostics. However, the main components participating in this process, namely `trackExpressionValue` and `FindLastStoreBRVisitor`, became pretty bloated. They have an interesting dynamic between them (and some other visitors) that one might call a "chain reaction". `trackExpressionValue` adds `FindLastStoreBRVisitor`, and the latter calls `trackExpressionValue`.
Because of this design, individual checkers couldn't affect what's going to happen somewhere in the middle of that chain. Whether they want to produce a more informative note or keep the overall tracking going by utilizing some of the domain expertise. This all lead to two biggest problems that I see:
* Some checkers don't use it This should probably never be the case for path-sensitive checks.
* Some checkers incorporated their logic directly into those components This doesn't make the maintenance easier, breaks multiple architecture principles, and makes the code harder to read adn understand, thus, increasing the probability of the first case.
This commit introduces a prototype for a new interface that will be responsible for tracking. My main idea here was to make operations that I want have as a checker developer easy to implement and hook directly into the tracking process.
Differential Revision: https://reviews.llvm.org/D103605
|
 | clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporterVisitors.h (diff) |
 | clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp (diff) |
Commit
967c06b3e95ba776fb06ad0ea5aa699cf2e1b59a
by vsavchenko[analyzer] Reimplement trackExpressionValue as ExpressionHandler
This commit moves trackExpressionValue into the Tracker interface as DefaultExpressionHandler. It still can be split into smaller handlers, but that can be a future change.
Additionally, this commit doesn't remove the original trackExpressionValue interface, so it's not too big. One of the next commits will address it.
Differential Revision: https://reviews.llvm.org/D103616
|
 | clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp (diff) |
Commit
b6bcf953220db7880f2bb508f6f5c02b41078b2c
by vsavchenko[analyzer] Change FindLastStoreBRVisitor to use Tracker
Additionally, this commit completely removes any uses of FindLastStoreBRVisitor from the analyzer except for the one in Tracker.
The next step is actually removing this class altogether from the header file.
Differential Revision: https://reviews.llvm.org/D103618
|
 | clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountDiagnostics.cpp (diff) |
 | clang/lib/StaticAnalyzer/Checkers/UndefCapturedBlockVarChecker.cpp (diff) |
 | clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporterVisitors.h (diff) |
 | clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp (diff) |
Commit
87a5c4d3745a06ec0594fa3f7aaf7f58a53315ec
by vsavchenko[analyzer] Hide and rename FindLastStoreBRVisitor
This component should not be used directly at this point and it is simply an implementation detail, that's why StoreSiteFinder is out of the header file.
Differential Revision: https://reviews.llvm.org/D103624
|
 | clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporterVisitors.h (diff) |
 | clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp (diff) |
Commit
f853d2601abd4f6ab789ca1513ae8b59ba5d38b7
by vsavchenko[analyzer] Turn ReturnVisitor into a tracking visitor
Whenever Tracker spawns a visitor that needs to call tracker back, we have to use TrackingBugReporterVisitor in order to maintain all the hooks that the checker might've used.
Differential Revision: https://reviews.llvm.org/D103628
|
 | clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp (diff) |
|
 | clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp (diff) |
|
 | clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp (diff) |
|
 | clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporterVisitors.h (diff) |
 | clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp (diff) |
 | clang/lib/StaticAnalyzer/Checkers/ObjCContainersChecker.cpp (diff) |
 | clang/lib/StaticAnalyzer/Checkers/MIGChecker.cpp (diff) |
Commit
646e970d44d7eaf4f56e2956fb58b48eb9360cb3
by llvm-dev[llvm-stress] Fix dead code preventing us generating per-element vector selects
This has been reported several times by the PVS Studio team as well as coming up in some static analysis.
getRandom() % 1 always returns 0 so we never actually test this codepath, (git blame suggests this has always been like this) - given that we have plenty of other "getRandom() & 1" the typo is pretty obvious, and matches the intention in the comment above - with this change we generate a nice mixture of scalar/vector condition selects of vectors.
I don't know llvm-stress that well - but I don't think we guarantee that the same seed value will always generate the same IR for later versions of the program - just that the same binary would.
Differential Revision: https://reviews.llvm.org/D104022
|
 | llvm/tools/llvm-stress/llvm-stress.cpp (diff) |
Commit
63042d46bb0c2481a8b7aa1c324405c2720b3603
by martinclang-format: [JS] don't sort named imports if off.
The previous implementation would accidentally still sort the individual named imports, even if the module reference was in a clang-format off block.
Differential Revision: https://reviews.llvm.org/D104101
|
 | clang/unittests/Format/SortImportsTestJS.cpp (diff) |
 | clang/lib/Format/SortJavaScriptImports.cpp (diff) |
Commit
b102e6880ab06654f945284a520f68c099732f44
by olemarius.strohm[OpenCL] Fix overloading resolution of addrspace constructors
This fixes the prioritization of address spaces when choosing a constructor, stopping them from being considered equally good, which made the construction of types that could be constructed by more than one of the constructors.
It does this by preferring the most specific address space, which is decided by seeing if one of the address spaces is a superset of the other, and preferring the other.
Fixes: PR50329
Reviewed By: Anastasia
Differential Revision: https://reviews.llvm.org/D102850
|
 | clang/test/SemaOpenCLCXX/addrspace-constructors.clcpp (diff) |
 | clang/test/CodeGenOpenCLCXX/addrspace-constructors.clcpp (diff) |
 | clang/lib/Sema/SemaOverload.cpp (diff) |