Changes

[c++20] Synthesis of defaulted comparison functions.
Array members are not yet handled. In addition, defaulted comparisons 
can't yet find comparison operators by unqualified lookup (only by 
member lookup and ADL). These issues will be fixed in follow-on changes.

Revert 393dacacf7e7 "[ARM] Enable TypePromotion by default"
This caused "Too many bits for uint64_t" asserts when building Chromium.
See https://crbug.com/1031978#c2 for a reproducer. I'll follow up on the 
llvm-commits thread with a creduced version.
> ARMCodeGenPrepare has already been generalized and renamed to
> TypePromotion. We've had it enabled and tested downstream for a
> while, so enable it by default.
>
> Differential Revision: https://reviews.llvm.org/D70998

[lldb] Add a test for how we lazily create Clang AST nodes
Summary: One of the ways we try to make LLDB faster is by only creating
the Clang declarations (and loading the associated types) when we
actually need them for something. For example an evaluated expression
might need to load types to type check and codegen the expression.
Currently this mechanism isn't really tested, so we currently have no
way to know how many Clang nodes we load and when we load them. In
general there seems to be some confusion when and why certain Clang
nodes are created. As we are about to make some changes to the code
which is creating Clang AST nodes we probably should have a test that at
least checks that the current behaviour doesn't change. It also serves
as some kind of documentation on the current behaviour.
The test in this patch is just evaluating some expressions and checks
which Clang nodes are created due to this in the module AST. The check
happens by looking at the AST dump of the current module and then
scanning it for the declarations we are looking for.
I'm aware that there are things missing in this test (inheritance,
template parameters, non-expression evaluation commands) but I'll expand
it in follow up patches.
Also this test found two potential bugs in LLDB which are documented
near the respective asserts in the test:
1. LLDB seems to always load all types of local variables even when we
don't reference them in the expression. We had patches that tried to
prevent this but it seems that didn't work as well as it should have
(even though we don't complete these types). 2. We always seem to
complete the first field of any record we run into. This has the funny
side effect that LLDB is faster when all classes in a project have an
arbitrary `char unused;` as their first member. We probably want to fix
this.
Reviewers: shafik
Subscribers: abidh, JDevlieghere, lldb-commits
Tags: #lldb
Differential Revision: https://reviews.llvm.org/D71056

[compiler-rt] Add a critical section when flushing gcov counters
Summary: Counters can be flushed in a multi-threaded context for example
when the process is forked in different threads
(https://github.com/llvm/llvm-project/blob/master/llvm/lib/Transforms/Instrumentation/GCOVProfiling.cpp#L632-L663). 
In order to avoid pretty bad things, a critical section is needed around
the flush. We had a lot of crashes in this code in Firefox CI when we
switched to clang for linux ccov builds and those crashes disappeared
with this patch.
Reviewers: marco-c, froydnj, dmajor, davidxl
Reviewed By: marco-c, dmajor
Subscribers: froydnj, dmajor, dberris, jfb, #sanitizers, llvm-commits,
sylvestre.ledru
Tags: #sanitizers, #llvm
Differential Revision: https://reviews.llvm.org/D70910

[DebugInfo] Make describeLoadedValue() reg aware
Currently the describeLoadedValue() hook is assumed to describe the 
value of the instruction's first explicit define. The hook will not be 
called for instructions with more than one explicit define.
This commit adds a register parameter to the describeLoadedValue() hook, 
and invokes the hook for all registers in the worklist.
This will allow us to for example describe instructions which produce 
more than two parameters' values; e.g. Hexagon's various combine 
instructions.
This also fixes a case in our downstream target where we may pass 
smaller parameters in the high part of a register. If such a parameter's 
value is produced by a larger copy instruction, we can't describe the 
call site value using the super-register, and we instead need to know 
which sub-register that should be used.
This also allows us to handle cases like this:
  $ebx = [...]
 $rdi = MOVSX64rr32 $ebx
 $esi = MOV32rr $edi
 CALL64pcrel32 @call
The hook will first be invoked for the MOV32rr instruction, which will 
say that @call's second parameter (passed in $esi) is described by $edi. 
As $edi is not preserved it will be added to the worklist. When we get 
to the MOVSX64rr32 instruction, we need to describe two values; the 
sign-extended value of $ebx -> $rdi for the first parameter, and $ebx ->
$edi for the second parameter, which is now possible.
This commit modifies the dbgcall-site-lea-interpretation.mir test case. 
In the test case, the values of some 32-bit parameters were produced 
with LEA64r. Perhaps we can in general cases handle such by emitting 
expressions that AND out the lower 32-bits, but I have not been able to 
land in a case where a LEA64r is used for a 32-bit parameter instead of 
LEA64_32 from C code.
I have not found a case where it would be useful to describe parameters 
using implicit defines, so in this patch the hook is still only invoked 
for explicit defines of forwarding registers.

Revert "[DebugInfo] Make describeLoadedValue() reg aware"
This reverts commit 3cd93a4efcdeabeb20cb7bec9fbddcb540d337a1. I'll
recommit with a well-formatted arcanist commit message.

[lldb] Support for DWARF-5 atomic types
Summary: This patch adds support for atomic types (DW_TAG_atomic_type)
to LLDB. It's mostly just filling out all the switch-statements that
didn't implement Atomic case with the usual boilerplate.
Thanks Pavel for writing the test case.
Reviewers: labath, aprantl, shafik
Reviewed By: labath
Subscribers: jfb, abidh, JDevlieghere, lldb-commits
Tags: #lldb
Differential Revision: https://reviews.llvm.org/D71183

[DebugInfo] Make describeLoadedValue() reg aware
Summary: Currently the describeLoadedValue() hook is assumed to describe
the value of the instruction's first explicit define. The hook will not
be called for instructions with more than one explicit define.
This commit adds a register parameter to the describeLoadedValue() hook, 
and invokes the hook for all registers in the worklist.
This will allow us to for example describe instructions which produce 
more than two parameters' values; e.g. Hexagon's various combine 
instructions.
This also fixes situations in our downstream target where we may pass 
smaller parameters in the high part of a register. If such a parameter's 
value is produced by a larger copy instruction, we can't describe the 
call site value using the super-register, and we instead need to know 
which sub-register that should be used.
This also allows us to handle cases like this:
  $ebx = [...]
 $rdi = MOVSX64rr32 $ebx
 $esi = MOV32rr $edi
 CALL64pcrel32 @call
The hook will first be invoked for the MOV32rr instruction, which will 
say that @call's second parameter (passed in $esi) is described by $edi. 
As $edi is not preserved it will be added to the worklist. When we get 
to the MOVSX64rr32 instruction, we need to describe two values; the 
sign-extended value of $ebx -> $rdi for the first parameter, and $ebx ->
$edi for the second parameter, which is now possible.
This commit modifies the dbgcall-site-lea-interpretation.mir test case. 
In the test case, the values of some 32-bit parameters were produced 
with LEA64r. Perhaps we can in general cases handle such by emitting 
expressions that AND out the lower 32-bits, but I have not been able to 
land in a case where a LEA64r is used for a 32-bit parameter instead of 
LEA64_32 from C code.
I have not found a case where it would be useful to describe parameters 
using implicit defines, so in this patch the hook is still only invoked 
for explicit defines of forwarding registers.
Reviewers: djtodoro, NikolaPrica, aprantl, vsk
Reviewed By: djtodoro, vsk
Subscribers: ormris, hiraditya, llvm-commits
Tags: #debug-info, #llvm
Differential Revision: https://reviews.llvm.org/D70431

[cmake] Disable GCC 9's -Wredundant-move
Summary: This new warning (enabled by -Wextra) fires when a std::move is 
redundant, as the default compiler behavior would be to select a move 
operation anyway (e.g., when returning a local variable). Unlike
-Wpessimizing-move, it has no performance impact -- it just adds noise.
Currently llvm has about 1500 of these warnings. Unfortunately, the 
suggested fix -- removing std::move -- does not work because of some 
older compilers we still support. Specifically clang<=3.8 will not use a 
move operation if an implicit conversion is needed (Core issue 1579). In 
code like "A f(ConvertibleToA a) { return a; }" it will prefer a copy, 
or fail to compile if a copy is not possible.
This patch disables that warning to get a meaningful signal out of a GCC 
9 build.
Reviewers: rnk, aaron.ballman, xbolva00
Subscribers: mgorny, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D70963

Reland "[AST] Traverse the class type loc inside the member type loc.""
Summary: added a unittest which causes "TL.getClassTInfo" is null.
Reviewers: ilya-biryukov
Subscribers: mgorny, jkorous, arphaman, kadircet, usaxena95, cfe-commits
Tags: #clang
Differential Revision: https://reviews.llvm.org/D71186

[ARM] Additional tests and minor formatting. NFC
This adds some extra cost model tests for shifts, and does some minor 
adjustments to some Neon code to make it clear as to what it applies to. 
Both NFC.

[ARM] Teach the Arm cost model that a Shift can be folded into other
instructions
This attempts to teach the cost model in Arm that code such as:
 %s = shl i32 %a, 3
 %a = and i32 %s, %b Can under Arm or Thumb2 become:
 and r0, r1, r2, lsl #3
So the cost of the shift can essentially be free. To do this without 
trying to artificially adjust the cost of the "and" instruction, it 
needs to get the users of the shl and check if they are a type of 
instruction that the shift can be folded into. And so it needs to have 
access to the actual instruction in getArithmeticInstrCost, which if 
available is added as an extra parameter much like getCastInstrCost.
We otherwise limit it to shifts with a single user, which should 
hopefully handle most of the cases. The list of instruction that the 
shift can be folded into include ADC, ADD, AND, BIC, CMP, EOR, MVN, ORR, 
ORN, RSB, SBC and SUB. This translates to Add, Sub, And, Or, Xor and 
ICmp.
Differential Revision: https://reviews.llvm.org/D70966

gn build: Merge 6d5c273500a

[OpenCL] Handle address space conversions for constexpr (PR44177)
The AST for the constexpr.cl test contains address space conversion 
nodes to cast through the implicit generic address space.  These caused
the evaluator to reject the input as constexpr in C++ for OpenCL mode,
whereas the input was considered constexpr in plain C++ mode as the AST
won't have address space cast nodes then.
Fixes PR44177.
Differential Revision: https://reviews.llvm.org/D71015

[clang][Tooling] Fix potential UB in
ExpandResponseFilesCompilationDatabase
Summary:
`vector::assign` will cause UB at here.
fixes: https://github.com/clangd/clangd/issues/223
Reviewers: kadircet, sammccall, hokein
Reviewed By: sammccall
Subscribers: merge_guards_bot, ilya-biryukov, usaxena95, cfe-commits
Tags: #clang
Differential Revision: https://reviews.llvm.org/D71172

[ARM] Enable MVE masked loads and stores
With the extra optimisations we have done, these should now be fine to 
enable by default. Which is what this patch does.
Differential Revision: https://reviews.llvm.org/D70968

[CommandLine] Add missing Callbacks
It appears that the cl::bits options are not used anywhere in-tree. In 
the recent addition to add Callback's to the options, the Callback was 
missing from this one. This fixes it by adding the same code from the 
other classes.
It also adds a simple test, of sorts, just to make sure these continue 
compiling.

[lldb] Xfail TestCallOverriddenMethod.py for aarch64/linux
This test still fails on Linux aarch64. Tested by buildbot running
Ubuntu Bionic
Differential Revision: https://reviews.llvm.org/D70722

[ARM] Add missing REQUIRES: asserts to test. NFC

[ARM][MVE] Add complex vector intrinsics
Summary: This patch adds intrinsics for the following MVE instructions:
* VCADD, VHCADD
* VCMUL
* VCMLA
Each of the above 3 groups has a corresponding new LLVM IR intrinsic.
Reviewers: simon_tatham, MarkMurrayARM, ostannard, dmgreen
Reviewed By: MarkMurrayARM
Subscribers: merge_guards_bot, kristof.beyls, hiraditya, cfe-commits,
llvm-commits
Tags: #clang, #llvm
Differential Revision: https://reviews.llvm.org/D71190

[test][tools] Add missing and improve testing
Mostly this adds testing for certain aliases in more explicit ways. 
There are also a few tidy-ups, and additions of missing testing, where 
the feature was either not tested at all, or not tested explicitly and 
sufficiently.
Reviewed by: MaskRay, rupprecht, grimar
Differential Revision: https://reviews.llvm.org/D71116

[lldb] Improve/fix base address selection in location lists
Summary: Lldb support base address selection entries in location lists
was broken for a long time. This wasn't noticed until llvm started
producing these kinds of entries more frequently with r374600.
In r374769, I made a quick patch which added sufficient support for them 
to get the test suite to pass. However, I did not fully understand how 
this code operates, and so the fix was not complete. Specifically, what 
was lacking was the ability to handle modules which were not loaded at 
their preferred load address (for instance, due to ASLR).
Now that I better understand how this code works, I've come to the 
conclusion that the current setup does not provide enough information to
correctly process these entries. In the current setup the location lists
were parameterized by two addresses:
- the distance of the function start from the start of the compile unit.
 The purpose of this was to make the location ranges relative to the
 start of the function.
- the actual address where the function was loaded at. With this the
 function-start-relative ranges can be translated to actual memory
 locations.
The reason for the two values, instead of just one (the load bias) is (I 
think) MachO, where the debug info in the object files will appear to be 
relative to the address zero, but the actual code it refers to can be
moved and reordered by the linker. This means that the location lists
need to be "linked" to reflect the locations in the actual linked file.
These two bits of information were enough to correctly process location 
lists which do not contain base address selection entries (and so all 
entries are relative to the CU base). However, they don't work with them
because, in theory two base address can be completely unrelated (as can
happen for instace with hot/cold function splitting, where the linker
can reorder the two pars arbitrarily).
To fix that, I split the first parameter into two:
- the compile unit base address
- the function start address, as is known in the object file
The new algorithm becomes:
- the location lists are processed as they were meant to be processed.
 The CU base address is used as the initial base address value. Base
 address selection entries can set a new base.
- the difference between the "file" and "load" function start addresses
 is used to compute the load bias. This value is added to the final
 ranges to get the actual memory location.
This algorithm is correct for non-MachO debug info, as there the 
location lists correctly describe the code in the final executable, and 
the dynamic linker can just move the entire module, not pieces of it. It 
will also be correct for MachO if the static linker preserves relative 
positions of the various parts of the location lists -- I don't know 
whether it actually does that, but judging by the lack of base address 
selection support in dsymutil and lldb, this isn't something that has 
come up in the past.
I add a test case which simulates the ASLR scenario and demonstrates 
that base address selection entries now work correctly here.
Reviewers: JDevlieghere, aprantl, clayborg
Subscribers: dblaikie, lldb-commits
Tags: #lldb
Differential Revision: https://reviews.llvm.org/D70532

[lldb/DWARF] Switch to llvm location list parser
Summary: This patch deletes the lldb location list parser and teaches
the DWARFExpression class to use the parser in llvm instead. I have 
centralized all the places doing the parsing into a single 
GetLocationExpression function.
In theory the the actual location list parsing should be covered by llvm 
tests, and this glue code by our existing location list tests, but since 
we don't have that many location list tests, I've tried to extend the 
coverage a bit by adding some explicit dwarf5 loclist handling and a 
test of the dumping code.
For DWARF4 location lists this should be NFC (modulo small differences 
in error handling which should only show up on invalid inputs). In case 
of DWARF5, this fixes various missing bits of functionality, most 
notably, the lack of support for DW_LLE_offset_pair.
Reviewers: JDevlieghere, aprantl, clayborg
Subscribers: lldb-commits, dblaikie
Tags: #lldb
Differential Revision: https://reviews.llvm.org/D71003

[Attr] Add missing header for clang example.
The examples are easy to miss.

[DebugInfo] Nerf placeDbgValues, with prejudice
CodeGenPrepare::placeDebugValues moves variable location intrinsics to
be immediately after the Value they refer to. This makes tracking of
locations very easy; but it changes the order in which assignments
appear to the debugger, from the source programs order to the order in
which the optimised program computes values. This then leads to PR43986
and PR38754, where variable locations that were in a conditional block
are made unconditional, which is highly misleading.
This patch adjusts placeDbgValues to only re-order variable location 
intrinsics if they use a Value before it is defined, significantly
reducing the damage that it does. This is still not 100% safe, but the
rest of CodeGenPrepare needs polishing to correctly update debug info
when optimisations are performed to fully fix this.
This will probably break downstream debuginfo tests -- if the 
instruction-stream position of variable location changes isn't the focus
of the test, an easy fix should be to manually apply placeDbgValues'
behaviour to the failing tests, moving dbg.value intrinsics next to SSA
variable definitions thus:
  %foo = inst1
 %bar = ...
 %baz = ...
 void call @llvm.dbg.value(metadata i32 %foo, ...
to
  %foo = inst1
 void call @llvm.dbg.value(metadata i32 %foo, ...
 %bar = ...
 %baz = ...
This should return your test to exercising whatever it was testing
before.
Differential Revision: https://reviews.llvm.org/D58453

[DebugInfo][EarlyCSE] Use the salvageDebugInfoOrMarkUndef(); NFC
Use the newest API.
Differential Revision: https://reviews.llvm.org/D71061

[RISCV] Machine Operand Flag Serialization
Summary: These hooks ensure that the RISC-V backend can serialize and
parse MIR correctly.
Reviewers: jrtc27, luismarques
Reviewed By: luismarques
Subscribers: hiraditya, asb, rbar, johnrusso, simoncook, sabuasal,
niosHD, kito-cheng, shiva0217, jrtc27, MaskRay, zzheng, edward-jones,
rogfer01, MartinMosbeck, brucehoult, the_o, rkruppe, PkmX, jocewei,
psnobl, benna, Jim, s.egerton, pzheng, sameer.abuasal, apazos,
llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D70666

[Parser] Don't crash on MS assembly if target desc/asm parser isn't
linked in.
Summary: Instead, emit a diagnostic and return an empty ASM node, as we
do if the target is missing.
Filter this diagnostic out in clangd, where it's not meaningful.
Fixes https://github.com/clangd/clangd/issues/222
Reviewers: kadircet
Subscribers: mgorny, ilya-biryukov, jkorous, arphaman, usaxena95,
cfe-commits
Tags: #clang
Differential Revision: https://reviews.llvm.org/D71189

[RISCV] Fix mir-target-flags.ll

[clangd] Allow extract-to-function on regions that always return.
Summary: We only do a trivial check whether the region always returns -
it has to end with a return statement.
Reviewers: kadircet
Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95,
cfe-commits
Tags: #clang
Differential Revision: https://reviews.llvm.org/D70569

[test][llvm-cxxfilt] Fix darwin build bot
When committing dba420bc05ae, I missed that a darwin-specific change had 
been recently introduced into llvm-cxxfilt, which my change ignored and 
consequently broke the darwin build bot. This change fixes this issue as 
well as improving naming/commenting of things related to this point so 
that people are less likely to run into the same issue as I did.

[lldb] Remove Xfail decorators from steadily passing tests
This patch removes xfail decorator from some lldb testcases which are 
passing steadily now for past few week/months on aarch64/linux buildbot.

Fix build bot fails due to the patch here:
https://reviews.llvm.org/D70691 Fixed the LIT test case. Added the
REQUIRES instruction.

[test][llvm-cxxfilt] Add missing '-n'
See also e84468c1f.

Fix compilation warning from GCC7. NFC.

[clangd] Use expansion location when the ref is inside macros.
Summary: Previously, xrefs has inconsistent behavior when the reference
is inside macro body:
- AST-based xrefs (for main file) uses the expansion location;
- our index uses the spelling location;
This patch makes our index use file locations for references, which is 
consistent with AST-based xrefs, and kythe as well.
After this patch, memory usage of static index on LLVM increases ~5%.
Reviewers: ilya-biryukov
Subscribers: merge_guards_bot, MaskRay, jkorous, arphaman, kadircet,
usaxena95, cfe-commits
Tags: #clang
Differential Revision: https://reviews.llvm.org/D70480

[ModuloSchedule] Fix data types in ModuloScheduleExpander::isLoopCarried
The cycle values in modulo scheduling results can be negative. The
result of ModuloSchedule::getCycle() must be received as an int type.
Patch by Masaki Arai!
Differential Revision: https://reviews.llvm.org/D71122

[ARM][MVE] Add intrinsics for immediate shifts.
Summary: This adds the family of `vshlq_n` and `vshrq_n` ACLE
intrinsics, which shift every lane of a vector left or right by a
compile-time immediate. They mostly work by expanding to the IR `shl`,
`lshr` and
`ashr` operations, with their second operand being a vector splat of the
immediate.
There's a fiddly special case, though. ACLE specifies that the immediate
in `vshrq_n` can take values up to //and including// the bit size of the
vector lane. But LLVM IR thinks that shifting right by the full size of
the lane is UB, and feels free to replace the `lshr` with an `undef`
half way through the optimization pipeline. Hence, to keep this legal in
source code, I have to detect it at codegen time. Logical (unsigned)
right shifts by the element size are handled by simply emitting the zero
vector; arithmetic ones are converted into a shift of one bit less,
which will always give the same output.
In order to do that check, I also had to enhance the tablegen MveEmitter
so that it can cope with converting a builtin function's operand into a
bare integer to pass to a code-generating subfunction. Previously the
only bare integers it knew how to handle were flags generated from
within `arm_mve.td`.
Reviewers: dmgreen, miyuki, MarkMurrayARM, ostannard
Reviewed By: MarkMurrayARM
Subscribers: kristof.beyls, hiraditya, cfe-commits, llvm-commits
Tags: #clang, #llvm
Differential Revision: https://reviews.llvm.org/D71065

[llvm][VFABI] Add more testing for LLVM internal mangling.
Summary: The tests cover the internal mangling for:
1. Masked signatures. 2. Scalable signatures. 3. Masked scalable
signatures with linear.
Reviewers: andwar
Subscribers: llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D71146

[clangd] Implement range patching heuristics for cross-file rename.
Reviewers: sammccall, ilya-biryukov
Reviewed By: sammccall
Subscribers: merge_guards_bot, MaskRay, jkorous, mgrang, arphaman,
kadircet, usaxena95, cfe-commits
Tags: #clang
Differential Revision: https://reviews.llvm.org/D70594

Fix the compiler warnings: "-Winconsistent-missing-override",
"-Wunused-variable"
for d97b3e3e65cd77a81b39732af84a1a4229e95091

[GWP-ASan] 32-bit test pointers, allow multi-init for test.
Summary: GWP-ASan test currently fail on 32-bit platforms, as some of
the pointers are larger than `uintptr_t` on 32-bit platforms. Fix up all
those instances.
Also add an uncompress varint test where the result is an underflow.
Furthermore, allow multi-init for testing. Each gtest when running
`check-gwp_asan` apparently runs in its own instance, but when
integrating these tests into Android, this behaviour isn't the same. We
remove the global multi-init check here, to allow for testing to work
elsewhere, and we're not really worried about multi-init anyway as it's
part of our contract with the allocator.
Reviewers: eugenis, vlad.tsyrklevich
Reviewed By: eugenis
Subscribers: #sanitizers, llvm-commits, pcc
Tags: #sanitizers, #llvm
Differential Revision: https://reviews.llvm.org/D71121

[ARM] Fix NEON failure introduced by D71065.
I rewrote the isel tablegen for MVE immediate shifts, and accidentally 
removed the `let Predicates=[HasMVEInt]` that was wrapping the old 
version, which seems to have allowed those rules to cause trouble on 
non-MVE targets. That's what I get for only re-running the MVE tests.

[lldb][CMake] Fix build for the case of custom libedit installation

[lldb/SWIG] Guard Python type map in SWIG interface by SWIGPYTHON
Guard the Python type map in SBTarget by the SWIGPYTHON define to 
ensures the rest of the interface can be reused for other languages 
supported by SWIG.

[PowerPC] Refactor FinishCall. [NFC]
Refactor FinishCall to be more easily understandable as a precursor to 
implementing indirect calls for AIX. The refactor tries to group similar 
code together at the cost of some code duplication. The high level 
overview of the refactor:
- Adds a number of helper functions for things like:
 * Determining if a call is indirect.
 * What the Opcode for a call is.
 * Transforming the callee for a direct function call.
 * Extracting the Chain operand from a CallSeqStart node.
 * Building the operands of the call.
- Adds helpers for building the indirect call DAG nodes
 (excluding the call instruction itself which is created in
 `FinishCall`).
- Removes PrepareCall, which has been subsumed by the
 helpers.
- Rename 'InFlag' to 'Glue'.
- FinishCall has been refactored to:
 1) Set TOC pointer usage on the DAG for the TOC based
    subtargets.
 2) Calculate if a call is indirect.
 3) Determine the Opcode to use for the call
    instruction.
 4) Transform the Callee for direct calls, or build
    the DAG nodes for indirect calls.
 5) Buildup the call operands.
 6) Emit the call instruction.
 7) If needed, emit the callSeqEnd Node and
    finish lowering by calling `LowerCallResult`
Differential Revision: https://reviews.llvm.org/D70126

[ARM][MVE][Intrinsics] Add VMULL[BT]Q_(INT|POLY) intrinsics.
Summary: Add VMULL[BT]Q_(INT|POLY) intrinsics and unit tests.
Reviewers: simon_tatham, ostannard, dmgreen
Subscribers: kristof.beyls, hiraditya, cfe-commits, llvm-commits
Tags: #clang, #llvm
Differential Revision: https://reviews.llvm.org/D71066

[ARM][MVE][Intrinsics] Add VQADDQ, VHADDQ, VRHADDQ, VQSUBQ, VHSUBQ,
VQDMULHQ, VQRDMULHQ intrinsics.
Summary: Add VQADDQ, VHADDQ, VRHADDQ, VQSUBQ, VHSUBQ, VQDMULHQ,
VQRDMULHQ intrinsics and unit tests.
Reviewers: simon_tatham, ostannard, dmgreen, miyuki
Subscribers: kristof.beyls, hiraditya, cfe-commits, llvm-commits
Tags: #clang, #llvm
Differential Revision: https://reviews.llvm.org/D71198

[clangd] Delete default arguments while moving functions out-of-line
Summary: Only function declarations should have the default arguments.
This patch makes sure we don't propogate those arguments to out-of-line 
definitions.
Fixes https://github.com/clangd/clangd/issues/221
Reviewers: hokein
Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95,
cfe-commits
Tags: #clang
Differential Revision: https://reviews.llvm.org/D71187

[clangd] Delete ctor initializers while moving functions out-of-line
Summary: Currently we only delete function body from declaration, in
addition to that we should also drop ctor initializers.
Unfortunately CXXConstructorDecl doesn't store the location of `:`
before initializers, therefore we make use of token buffer to figure out
where to start deletion.
Fixes https://github.com/clangd/clangd/issues/220
Reviewers: hokein, ilya-biryukov
Subscribers: MaskRay, jkorous, arphaman, usaxena95, cfe-commits
Tags: #clang
Differential Revision: https://reviews.llvm.org/D71188

[lldb] Clean up accidentally passing TestDeadStrip.py
This test was accidentally passing on non-darwin OS because it was 
explicitly setting the CFLAGS make variable. This meant that (in the 
default config) it was building with absolutely no debug info, and so 
setting a breakpoint on a stripped symbol failed, because there was 
really no trace of it remaining. In other configurations, we were 
generating the debug info (-gsplit-dwarf implies -g) and the test failed 
because we did not treat the zeroed out debug info address specially. 
The test was also xfailed in pretty much every non-standard 
configuration.
This patch fixes the makefile to avoid messing with CFLAGS (use 
CFLAGS_EXTRAS instead). This causes it to fail in all configurations
(except darwin), and so I replace the various decorators with a simple 
os!=darwin check.

Reland 198fbcb8, "Driver: Don't look for libc++ headers in the install
directory on Android.", which was reverted in b3249027.
Fixed the test case to set --sysroot, which lets it succeed in the case
where a directory named "/usr/include/c++/v1" or
"/usr/local/include/c++/v1" exists.
Original commit message:
> The NDK uses a separate set of libc++ headers in the sysroot. Any
headers
> in the installation directory are not going to work on Android, not
least
> because they use a different name for the inline namespace (std::__1
instead
> of std::__ndk1).
>
> This effectively makes it impossible to produce a single toolchain
that is
> capable of targeting both Android and another platform that expects
libc++
> headers to be installed in the installation directory, such as Mac.
>
> In order to allow this scenario to work, stop looking for headers in
the
> install directory on Android.
Differential Revision: https://reviews.llvm.org/D71154

scudo: Add a basic malloc/free benchmark.
Differential Revision: https://reviews.llvm.org/D71104

Magic number checker shouldn't warn on user defined string literals
Fixes a false positive brought up by PR40633.

[clangd] also filter out another possible diag from MS ASM syntax

The field ‘totalFrames’ which is total number of frames available, is
mandatory in StackTraces response for VSCode extension that implements
DAP and declares capability 'supportsDelayedStackTraceLoading':
"The debug adapter supports the delayed loading of parts of the stack, 
which requires that both the 'startFrame' and 'levels' arguments and the
'totalFrames' result of the 'StackTrace' request are supported."
Lack of this field makes VSCode incorrectly display stack traces
information
D71034

[PowerPC][NFC] Rename ANDI(S)o8 to ANDI(S)8o
Summary: This is found during https://reviews.llvm.org/D70758 All the
other record forms are having suffix o at the end. ANDIo8 and ANDISo8
are the only two that put o before 8.
This patch rename them to be consistent with others.
Reviewers: #powerpc, hfinkel, nemanjai, lei, steven.zhang, echristo,
jhibbits, joerg
Reviewed By: jhibbits
Subscribers: wuzish, hiraditya, kbarton, shchenz, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D70928

[InstCombine] add tests for shuffle with insertelement operand; NFC

Fix clang -Wcovered-switch-default after
llvmorg-10-init-11484-g6626e5a06a9
We need to place llvm_unreachable after switch to work around the GCC 
warning.

[clang][IFS] Allow 2 output files when using -o and -c with clang IFS
stubs.
This patch allows for -o to be used with -c when compiling with clang 
interface stubs enabled. This is because the second file will be an 
intermediate ifs stubs file that is the text stub analog of the .o file. 
Both get produces in this case, so two files.
Why are we doing this? Because we want to support the case where 
interface stubs are used bu first invoking clang like so:
clang -c <other flags> -emit-interface-stubs foo.c -o foo.o
... clang -emit-interface-stubs <.o files> -o libfoo.so
This should generate N .ifs files, and one .ifso file. Prior to this 
patch, using -o with the -c invocation was not possible. Currently the 
clang driver supports generating a a.out/.so file at the same time as a 
merged ifs file / ifso file, but this is done by checking that the final 
job is the IfsMerge job. When -c is used, the final job is a Compile job 
so what this patch does is check to figure out of the job type is 
TY_IFS_CPP.
Differential Revision: https://reviews.llvm.org/D70763

[c++20] Fix incorrect assumptions in checks for comparison category
types.
In the presence of modules, we can have multiple lookup results for the 
same entity, and we need to re-check for completeness each time we 
consider a type.

[Attr] Move ParsedTargetAttr out of the TargetAttr class
Need to forward declare it in ASTContext.h for D68627, so it can't be a
nested struct.
Differential Revision: https://reviews.llvm.org/D71159

[PGO][PGSO] Instrument the code gen / target passes.
Summary: Split off of D67120.
Add the profile guided size optimization instrumentation / queries in
the code gen or target passes. This doesn't enable the size
optimizations in those passes yet as they are currently disabled in
shouldOptimizeForSize (for non-IR pass queries).
A second try after reverted D71072.
Reviewers: davidxl
Subscribers: hiraditya, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D71149

Include Stmt.h where it seems to be necessary for modules builds
Summary: After 60573ae6fe50 removed an include of Expr.h from
ASTContext.h, this header fails to compile in some modular build
configurations. I have not been able to reproduce the problem locally.
The header compiles fine in isolation. However, based on reading the
code, it seems like it would require Stmt to be complete. Based on that
intuition, we decided to add the include.
Reviewers: rdhindsa
Subscribers: cfe-commits
Tags: #clang
Differential Revision: https://reviews.llvm.org/D71222

[ValueTracking] Allow context-sensitive nullness check for non-pointers
Summary: Same as D60846 and D69571 but with a fix for the problem
encountered after them. Both times it was a missing context adjustment
in the handling of PHI nodes.
The reproducers created from the bugs that caused the old commits to be 
reverted are included.
Reviewers: nikic, nlopes, mkazantsev, spatel, dlrobertson, uabelho,
hakzsam, hans
Subscribers: hiraditya, bollu, asbirlea, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D71181

[IPConstantProp][NFCI] Improve and modernize tests
Summary: This change is in preparation to reuse these test for the
Attributor. It mainly is to remove UB, make it clear what is tested, and
use
"modern" run lines.
Reviewers: fhahn, efriedma, mssimpso, davide
Subscribers: bollu, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D69747

[libc] Add implementation of errno and define the other macros of
errno.h.
Reviewers: stanshebs, alexbrachet
Subscribers: mgorny, MaskRay, tschuett, libc-commits
Tags: #libc-project
Differential Revision: https://reviews.llvm.org/D71094

[PowerPC] [NFC] Cleanup xxpermdi peephole optimization
Summary: Following on from rG884351547da2, this patch cleans up the
logic for `xxpermdi` peephole optimizations by converting two layers of
nested `if`s to early breaks and simplifying the logic.
Reviewers: hfinkel, nemanjai, jsji, lkail, #powerpc, steven.zhang
Reviewed By: #powerpc, steven.zhang
Subscribers: wuzish, steven.zhang, hiraditya, kbarton, shchenz,
llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D71170
Patch by vddvss (Colin Samples).

[hwasan] Offline symbolization script.
Summary: A script to symbolize hwasan reports after the fact using
unstripped binaries. Supports stack-based reports. Requires
llvm-symbolizer
(addr2line is not an option).
Reviewers: pcc, hctim
Subscribers: mgorny, #sanitizers, llvm-commits
Tags: #sanitizers, #llvm
Differential Revision: https://reviews.llvm.org/D71148

Implement LWG#1203 for raw_ostream.
Implement LWG#1203 (https://cplusplus.github.io/LWG/issue1203) for
raw_ostream like libc++ does for std::basic_ostream<...>.
Add a operator<< overload that takes an rvalue reference of a typed
derived from raw_ostream, streams the value to it and returns the stream
of the same type as the argument.
This allows free operator<< to work with rvalue reference raw_ostreams: 
raw_ostream& operator<<(raw_ostream&, const SomeType& Value); 
raw_os_ostream(std::cout) << SomeType();
It also allows using the derived type like: auto Foo =
(raw_string_ostream(buffer) << "foo").str();
Author: Christian Sigg <csigg@google.com> Differential Revision:
https://reviews.llvm.org/D70686

Also synthesize _cmd and self for properties
Patch by: Pierre Habouzit
Differential Revision: https://reviews.llvm.org/D71226

[FormatManager] Provide a single entrypoint for GetCandidateLanguages().

[c++20] Defaulted comparison support for array members.

[AArch64][SVE] Implement SPLAT_VECTOR for i1 vectors.
The generated sequence with whilelo is unintuitive, but it's the best I
could come up with given the limited number of SVE instructions that 
interact with scalar registers. The other sequence I was considering was
something like dup+cmpne, but an extra scalar instruction seems better
than an extra vector instruction.
Differential Revision: https://reviews.llvm.org/D71160

[Codegen][X86] Modernize/regenerate old tests. NFCI.
Summary: Switch to FileCheck where possible. Adjust tests so they can be
easily regenerated by update scripts.
Reviewers: craig.topper, spatel, RKSimon
Reviewed By: spatel
Subscribers: MatzeB, qcolombet, arphaman, jfb, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D71211

[ConstantFold][SVE] Fix constant folding for shufflevector.
Don't try to fold away shuffles which can't be folded.  Fix creation of 
shufflevector constant expressions.
Differential Revision: https://reviews.llvm.org/D71147

Avoid Attr.h includes, CodeGen edition
This saves around 20 includes of Attr.h. Not much.

Revert "[ARM][MVE] Add intrinsics for immediate shifts." and two
follow-on commits: one warning fix and one functionality.
As it's breaking at least the lto bot:
http://lab.llvm.org:8011/builders/clang-with-lto-ubuntu/builds/15132/steps/test-stage1-compiler/logs/stdio
This reverts commits:
 8d70f3c933a5b81a87a5ab1af0e3e98ee2cd7c67
ff4dceef9201c5ae3924e92f6955977f243ac71d
d97b3e3e65cd77a81b39732af84a1a4229e95091

add support for strict operation fpextend/fpround/fsqrt on X86 backend
Differential Revision: https://reviews.llvm.org/D71184

[FormatManager] GetCandidateLanguages shouldn't know about ValueObject.
Reviewers: jingham, teemperor, JDevlieghere, aprantl
Subscribers: lldb-commits
Tags: #lldb
Differential Revision: https://reviews.llvm.org/D71236

[llvm/dwarfdump] Use the architecture string to filter.
Currently dwarfdump uses the ArchType to filter out architectures, which 
is problematic for architectures like arm64e and x86_64h that map back 
to arm64 and x86_64 respectively. The result is that the filter doesn't 
work for these architectures because it matches all the variants. This 
is especially bad because usually these architectures are the reason to 
use the filter in the first place.
Instead, we should match the architecture based on the string name. This 
means the filter works for the values printed by dwarfdump. It has the 
unfortunate side effect of not working for aliases, like AArch64, but I 
think that's worth the trade-off.
rdar://53653014
Differential revision: https://reviews.llvm.org/D71230

[NFC] Add { } to silence compiler warning [-Wmissing-braces].
../llvm/lib/Target/PowerPC/PPCISelLowering.cpp:5371:37: warning: suggest
braces around initialization of subobject [-Wmissing-braces]
 std::array<EVT, 2> ReturnTypes = {MVT::Other, MVT::Glue};
                                   ^~~~~~~~~~~~~~~~~~~~~
                                   {                    }

[c++20] Fix handling of unqualified lookups from a defaulted comparison
function.
We need to perform unqualified lookups from the context of a defaulted 
comparison, but not until we implicitly define the function, at which 
point we can't do those lookups any more. So perform the lookup from the 
end of the class containing the =default declaration and store the 
lookup results on the defaulted function until we synthesize the body.

Remove unused Unit test directory for xray.

[NFC][MacroFusion] Adding the assertion if someone want to fuse more
than 2 instructions
As discussed in https://reviews.llvm.org/D69998, we miss to create some
dependency edges if chained more than 2 instructions. Adding an
assertion here if someone want to chain more than 2 instructions.
Differential Revision: https://reviews.llvm.org/D71180

Turn off unused variable checking here since we're explicitly adding a
command line for clang-tidy.

[MC] Delete MCCodePadder
D34393 added MCCodePadder as an infrastructure for padding code with NOP
instructions. It lacked tests and was not being worked on since then.
Intel has now worked on an assembler patch to mitigate performance loss 
after applying microcode update for the Jump Conditional Code Erratum.
https://www.intel.com/content/www/us/en/support/articles/000055650/processors.html
This new patch shares similarity with MCCodePadder, but has a concrete 
use case in mind and is being actively developed. The infrastructure it 
introduces can potentially be used for general performance improvement 
via alignment. Delete the unused MCCodePadder so that people can develop 
the new feature from a clean state.
Reviewed By: jyknight, skan
Differential Revision: https://reviews.llvm.org/D71106

Revert "[compiler-rt] Add a critical section when flushing gcov
counters"
This reverts commit 88f5bf77f92899b19fdafdffc7b060f930c1cb8b as it broke 
green dragon bots.
http://lab.llvm.org:8080/green/job/clang-stage1-RA/4401/

[NFCi][llvm][MIRVRegNamerUtils] Making some code cleanup and stylistic
changes.
Making some changes to MIRVRegNamerUtils.cpp to use some more modern c++ 
features as well as some changes to generally make the code more concise 
and more understandable.
I make this an NFCi because in one case I drop the whole
"if (!MO->isDef()) MO->setIsKill(false);" thing that was added in the 
original implementation, generally because I don't think this is really 
semantically sound. I also changed up the implementation of 
VRegRenamer::createVirtualRegisterWithLowerName somewhat because I am 
now lower-casing the name unconditionally because I confirmed that that 
was in fact aditya_nandakumar@apple.com's intent.
In all other cases, behavior should not be changed.
Differential Revision: https://reviews.llvm.org/D71182

[Remarks][Driver] Error on -foptimization-record-file with multiple
-arch options
This adds a check for the usage of -foptimization-record-file with 
multiple -arch options. This is not permitted since it would require us 
to rename the file requested by the user to avoid overwriting it for the 
second cc1 invocation.

Remove implicit conversion that promotes half to other larger precision
types for fp classification builtins
Summary: It shouldn't promote half to double or any larger precision
types for fp classification builtins. Because fp classification builtins
would get incorrect result with promoted argument. For example,
__builtin_isnormal with a subnormal half value should return false, but
it is not. That the subnormal half value is promoted to a normal double
value.
Reviewers: aaron.ballman
Reviewed By: aaron.ballman
Subscribers: cfe-commits
Tags: #clang
Differential Revision: https://reviews.llvm.org/D71049

[BPF] Support to emit debugInfo for extern variables
extern variable usage in BPF is different from traditional pure user
space application. Recent discussion in linux bpf mailing list has two
use cases where debug info types are required to use extern variables:
 - extern types are required to have a suitable interface
   in libbpf (bpf loader) to provide kernel config parameters
   to bpf programs.
  
https://lore.kernel.org/bpf/CAEf4BzYCNo5GeVGMhp3fhysQ=_axAf=23PtwaZs-yAyafmXC9g@mail.gmail.com/T/#t
 - extern types are required so kernel bpf verifier can
   verify program which uses external functions more precisely.
   This will make later link with actual external function no
   need to reverify.
  
https://lore.kernel.org/bpf/87eez4odqp.fsf@toke.dk/T/#m8d5c3e87ffe7f2764e02d722cb0d8cbc136880ed
This patch added bpf support to consume such info into BTF, which can
then be used by bpf loader. Function processFuncPrototypes() only adds
extern function definitions into BTF. The functions with actual
definition have been added to BTF in some other places.
Differential Revision: https://reviews.llvm.org/D70697

[OpenMP][NFCI] Introduce llvm/IR/OpenMPConstants.h
Summary: The new OpenMPConstants.h is a location for all OpenMP related
constants
(and helpers) to live.
This patch moves the directives there (the enum OpenMPDirectiveKind) and 
rewires Clang to use the new location.
Initially part of D69785.
Reviewers: kiranchandramohan, ABataev, RaviNarayanaswamy, gtbercea,
grokos, sdmitriev, JonChesterfield, hfinkel, fghanim
Subscribers: jholewinski, ppenzin, penzn, llvm-commits, cfe-commits,
jfb, guansong, bollu, hiraditya, mgorny
Tags: #clang, #llvm
Differential Revision: https://reviews.llvm.org/D69853

[llvm-readobj][test] - Move platform specific test cases and their
inputs to separate folders.
This creates the next subfolders in the test directory:
"COFF", "ELF", "MachO", "wasm".
I've also removed platform specific prefixes, like "coff-*". One unused
binary was removed as well: `Inputs/relocs.obj.elf-mips`
Differential revision: https://reviews.llvm.org/D71203